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-Schema.cpp

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
+
+module Crafter.Review:Schema_impl;
+import :Schema;
+import :Json;
+import std;
+
+namespace Crafter::Review::Schema {
+    namespace {
+        template <std::size_t N>
+        Json Strings(const std::array<std::string_view, N>& values) {
+            Json out = Json::array();
+            for (const std::string_view value : values) out.push_back(value);
+            return out;
+        }
+
+        Json String(std::string_view description = {}) {
+            Json out = {{"type", "string"}};
+            if (!description.empty()) out["description"] = description;
+            return out;
+        }
+
+        Json StringList(std::string_view description) {
+            return {{"type", "array"}, {"items", {{"type", "string"}}}, {"description", description}};
+        }
+
+        Json Verdict(std::string_view description) {
+            Json out = {{"type", "string"}, {"enum", Strings(VerdictEnum)}};
+            if (!description.empty()) out["description"] = description;
+            return out;
+        }
+    }
+
+    Json Finding() {
+        Json contests = {
+            {"type", "object"},
+            {"additionalProperties", false},
+            {"required", {"id", "why"}},
+            {"properties", {
+                {"id", String()},
+                {"why", String("NEW evidence the disposition's recorded grounds do not survive")},
+            }},
+        };
+        return {
+            {"type", "object"},
+            {"additionalProperties", false},
+            {"required", {"finding", "evidence", "proposedAction", "items"}},
+            {"properties", {
+                {"finding", String("the defect - by your lens's charter question (objective wrongness)")},
+                {"evidence", String("file:line, a verbatim quote, the steps taken in the application and what was observed (a screenshot or snapshot path) - no vibes")},
+                {"proposedAction", String()},
+                {"items", StringList("the INVENTORY unit ids this finding concerns, copied exactly; a finding that spans units lists them all")},
+                {"dischargedBy", String("id of a disposition listed under DISPOSITIONS IN FORCE that discharges this finding (you verified its grounds); omit when none applies")},
+                {"contests", contests},
+            }},
+        };
+    }
+
+    Json Note() {
+        return {
+            {"type", "object"},
+            {"additionalProperties", false},
+            {"required", {"kind", "note", "evidence", "action"}},
+            {"properties", {
+                {"kind", {{"type", "string"}, {"enum", Strings(NoteKinds)}}},
+                {"note", String()},
+                {"evidence", String()},
+                {"action", String("what the orchestrator does with it (bank / record in the manifest / check at push time / nothing)")},
+                {"id", String("refutation-verified only: the disposition id")},
+                {"items", StringList("INVENTORY unit ids this note concerns")},
+            }},
+        };
+    }
+
+    Json Coverage() {
+        return {
+            {"type", "object"},
+            {"additionalProperties", false},
+            {"required", {"item", "verdict", "basis"}},
+            {"properties", {
+                {"item", String("an INVENTORY unit id, verbatim")},
+                {"verdict", {{"type", "string"}, {"enum", Strings(CoverageVerdicts)}}},
+                {"basis", String("what this verdict rests on: the tree ref, the command run, the steps taken in the application and the evidence file - or the literal string \"no record\"")},
+            }},
+        };
+    }
+
+    Json BlockSchema() {
+        return {
+            {"type", "object"},
+            {"additionalProperties", false},
+            {"required", {"verdict", "findings", "notes", "coverage"}},
+            {"properties", {
+                {"verdict", Verdict("FIX FIRST iff any finding is undischarged - the pipeline derives the same and fails closed on disagreement")},
+                {"findings", {{"type", "array"}, {"items", Finding()}}},
+                {"notes", {{"type", "array"}, {"items", Note()}}},
+                {"coverage", {{"type", "array"}, {"items", Coverage()}, {"minItems", 1}, {"maxItems", 1}, {"description", "exactly one entry: the unit this pass covers"}}},
+            }},
+        };
+    }
+
+    Json WholeSchema() {
+        return {
+            {"type", "object"},
+            {"additionalProperties", false},
+            {"required", {"verdict", "findings", "notes", "coverage", "summary"}},
+            {"properties", {
+                {"verdict", Verdict({})},
+                {"findings", {{"type", "array"}, {"items", Finding()}}},
+                {"notes", {{"type", "array"}, {"items", Note()}}},
+                {"coverage", {{"type", "array"}, {"items", Coverage()}, {"description", "one entry per unit you were asked to cover"}}},
+                {"summary", String("5-10 sentences: the range as you judged it and the constraints the block passes must respect (the functional lens: how to reach each touched screen, the login used, what the block passes must not touch)")},
+            }},
+        };
+    }
+
+    std::string SchemaJson(std::string_view kind) {
+        return DumpCompactSorted(kind == "block" ? BlockSchema() : WholeSchema());
+    }
+}