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>

implementations/Crafter.Review-Artifact.cpp

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
+
+module Crafter.Review:Artifact_impl;
+import :Artifact;
+import :Text;
+import :Crypto;
+import :Platform;
+import :Process;
+import std;
+
+namespace fs = std::filesystem;
+
+namespace Crafter::Review::Artifact {
+    namespace {
+        std::string ReadBytes(const fs::path& path) {
+            std::optional<std::string> bytes = Platform::ReadFile(path);
+            if (!bytes) throw std::runtime_error(std::format("{}: cannot read", path.string()));
+            return std::move(*bytes);
+        }
+
+        // Four decimal digits and a '-' at `at`, as (\d{4})-: the number.
+        std::optional<std::int64_t> FourDigits(std::string_view name, std::size_t at) {
+            std::size_t end = at;
+            for (std::int32_t i = 0; i < 4; ++i) {
+                if (end >= name.size()) return std::nullopt;
+                const auto [c, used] = Dyn::CodePointAt(name, end);
+                if (!Dyn::IsDecimal(c)) return std::nullopt;
+                end += used;
+            }
+            if (end >= name.size() || name[end] != '-') return std::nullopt;
+            return Dyn::ParseInt(name.substr(at, end - at));
+        }
+    }
+
+    std::string Sha256File(const fs::path& path) {
+        return Sha256Hex(ReadBytes(path));
+    }
+
+    std::string ArtifactHash(std::string_view mode, const fs::path& path) {
+        if (mode == "reply") return Sha256File(path);
+        std::string all;
+        for (const std::string& name : PatchFiles(path)) all += ReadBytes(path / name);
+        return Sha256Hex(all);
+    }
+
+    std::vector<std::string> PatchFiles(const fs::path& path) {
+        std::vector<std::string> out;
+        for (const fs::directory_entry& entry : fs::directory_iterator(path)) {
+            std::string name = entry.path().filename().string();
+            if (name.ends_with(".patch")) out.push_back(std::move(name));
+        }
+        std::ranges::sort(out);
+        return out;
+    }
+
+    std::optional<std::int64_t> PatchNumber(std::string_view name) {
+        if (name.starts_with('v')) {
+            const std::size_t digits = Dyn::DecimalRun(name, 1);
+            if (digits > 0 && 1 + digits < name.size() && name[1 + digits] == '-') {
+                if (const std::optional<std::int64_t> k = FourDigits(name, 2 + digits)) return k;
+            }
+        }
+        return FourDigits(name, 0);
+    }
+
+    std::map<std::int64_t, std::string> PatchTexts(const fs::path& path) {
+        std::map<std::int64_t, std::string> out;
+        for (const std::string& name : PatchFiles(path)) {
+            const std::optional<std::int64_t> k = PatchNumber(name);
+            if (!k) throw Dyn::Error("AttributeError", "'NoneType' object has no attribute 'group'");
+            out[*k] = Dyn::ReadText(path / name);
+        }
+        return out;
+    }
+
+    std::optional<std::string> PatchHead(const fs::path& path) {
+        const std::vector<std::string> files = PatchFiles(path);
+        if (files.empty()) return std::nullopt;
+        // open(errors='replace').readline().split(): the first line, universal
+        // newlines and all.
+        const std::string text = Dyn::UniversalNewlines(Dyn::DecodeReplace(ReadBytes(path / files.back())));
+        const std::vector<std::string> first = Dyn::Split(std::string_view(text).substr(0, text.find('\n')));
+        if (first.size() > 1 && first[0] == "From" && Dyn::Length(first[1]) == 40) return first[1];
+        return std::nullopt;
+    }
+
+    std::string Git(const fs::path& tree, std::span<const std::string> args) {
+        std::vector<std::string> argv = {"git", "-C", tree.string()};
+        argv.insert(argv.end(), args.begin(), args.end());
+        const Process::Captured run = Process::Run(argv);
+        if (run.returnCode != 0) {
+            const std::string& said = run.err.empty() ? run.out : run.err;
+            throw Dyn::Error("RuntimeError", std::format("git -C {} {}: {}", tree.string(), Dyn::Join(args, " "),
+                                                        Dyn::Strip(Dyn::UniversalNewlines(Dyn::DecodeReplace(said)))));
+        }
+        return Dyn::UniversalNewlines(Dyn::DecodeReplace(run.out));
+    }
+
+    bool IsToplevel(const fs::path& tree) {
+        try {
+            const std::string top = Dyn::Strip(Git(tree, std::array<std::string, 2>{"rev-parse", "--show-toplevel"}));
+            return fs::weakly_canonical(fs::absolute(top)) == fs::weakly_canonical(fs::absolute(tree));
+        } catch (const std::exception&) {
+            return false;
+        }
+    }
+
+    std::string TreeHead(const fs::path& tree) {
+        return Dyn::Strip(Git(tree, std::array<std::string, 2>{"rev-parse", "HEAD"}));
+    }
+
+    std::string TreeDirty(const fs::path& tree) {
+        return Dyn::Strip(Git(tree, std::array<std::string, 3>{"status", "--porcelain", "--untracked-files=no"}));
+    }
+}