feat(pipeline): the pure pipeline, checked against its goldens

The modules that turn a frozen range into passes and passes into a
verdict: :Schema, :Tools (the DENY, git and base lists, a leaf, so the
config and the pool both read them), :Plan, :Artifact, :Inventory,
:Dispositions, :State, :Normalize, :Stream, :Prompt, :Config, and the URL
half of :PgWire. Units, jobs, results, the config and the claude stream
stay JSON from end to end, so every key keeps its place; :Text gives JSON
values truthiness, get, ==, membership and Str(), and throws Dyn::Error
under a name for each kind of unexpected data.

Exactness where the bytes are seen:
- the stream classifiers are hand-written scanners with case-insensitive
  folds (the Kelvin sign is a k), Unicode \b and \s, and `.` stopping at
  \n; the SQL call detection takes `<exe> sql` with any path before it;
- config problems carry the JSON scanner's and the UTF-8 decoder's own
  texts, positions included;
- a float total is Neumaier's compensated sum, and the build passes
  -ffp-contract=off: -march=native would fuse a*b+c;
- `crafter-review inventory` and `config` print what the goldens record,
  byte for byte (the fixture and 14 configs, broken ones included); a
  message names this binary as the command to run.

tests/Goldens: the recorded answers over the fixtures next to them (the
commits fixture, a rich versioned series with CRLF, a folded subject,
Markdown headings in and out of fences, the code-key rewrites); the suite
compares 2304 results as DumpFile writes them, so a key out of order fails
too. All agree.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

interfaces/Crafter.Review-Artifact.cppm

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
+
+export module Crafter.Review:Artifact;
+import std;
+
+// The frozen artifact and the tree it was cut from: the hash formula, the
+// HEAD a format-patch export names, the tree checks.
+export namespace Crafter::Review::Artifact {
+    std::string Sha256File(const std::filesystem::path& path);
+    // reply: the sha256 of the draft file; series and commits: the sha256 of
+    // the sorted *.patch files concatenated (`cat $(ls *.patch | sort) |
+    // sha256sum`).
+    std::string ArtifactHash(std::string_view mode, const std::filesystem::path& path);
+    // The *.patch names in the directory, sorted by code point.
+    std::vector<std::string> PatchFiles(const std::filesystem::path& path);
+    // K of a format-patch file name, ^(?:v\d+-)?(\d{4})-: 1 for
+    // 0001-x.patch and v2-0001-x.patch; nullopt for a name without one.
+    std::optional<std::int64_t> PatchNumber(std::string_view name);
+    // {K: text} of the export, each patch read as Dyn::ReadText reads a file
+    // (strict UTF-8, universal newlines). Dyn::Error (AttributeError) for a
+    // patch name without a number.
+    std::map<std::int64_t, std::string> PatchTexts(const std::filesystem::path& path);
+    // The commit the last patch was cut from (its `From <sha>` line): the
+    // range HEAD.
+    std::optional<std::string> PatchHead(const std::filesystem::path& path);
+
+    // `git -C <tree> <args>`'s stdout; Dyn::Error (RuntimeError) with git's
+    // message when it fails.
+    std::string Git(const std::filesystem::path& tree, std::span<const std::string> args);
+    bool IsToplevel(const std::filesystem::path& tree);
+    std::string TreeHead(const std::filesystem::path& tree);
+    // Tracked changes only (untracked files never reach a commit); "" when
+    // clean.
+    std::string TreeDirty(const std::filesystem::path& tree);
+}