diff --git a/docs/specs/code-review.md b/docs/specs/code-review.md
index 781b8487..cf1baff3 100644
--- a/docs/specs/code-review.md
+++ b/docs/specs/code-review.md
@@ -59,13 +59,17 @@ Output:
   finding's axis, severity, disposition, changed location, violated source,
   and evidence, deterministic checks or an explicit evidence gap, risks, and
   next action;
-- the validated `darrow-review-result-v1` TSV only when the requester
-  explicitly asks for the machine format. The TSV remains the canonical
+- the validated `darrow-review-result-v3` JSON only when the requester
+  explicitly asks for the machine format. JSON remains the canonical
   mechanical artifact beneath the review scope artifact directory.
 
+Review JSON is parsed as named objects and validated against its format schema
+before semantic checks. The backend uses those named fields directly; it does
+not translate them into positional record rows.
+
 Fix verification returns a human-readable Markdown report by default, or the
-validated additive `darrow-review-verification-v1` TSV only when explicitly
-requested as machine output. Initial `darrow-review-result-v1` validation and
+validated additive `darrow-review-verification-v3` JSON only when explicitly
+requested as machine output. Initial `darrow-review-result-v3` validation and
 rendering remain compatible.
 
 If several reasonable fixed points would produce materially different review
@@ -178,7 +182,7 @@ axis and report `not_available`. Do not invent requirements.
 7. **CR-C7 — Tools before taste.** Run or validate applicable deterministic
    gates through bundled check-evidence capture. Preserve each literal command,
    actual exit status, and bounded output in a canonical record, and copy its
-   check row without reinterpretation. Suppress model findings that merely
+   check entry without reinterpretation. Suppress model findings that merely
    restate tool-enforced formatting, lint, type, or test results.
 8. **CR-C8 — Traceable Spec findings.** Every blocking Spec finding cites the
    source requirement it violates. Unsupported assumptions and personal
@@ -218,10 +222,10 @@ axis and report `not_available`. Do not invent requirements.
     independent review.
 15. **CR-C15 — Deliberate presentation.** Standalone and composed review use
     one human-readable Markdown report by default. An explicit request for
-    `darrow-review-result-v1`, raw TSV, or machine format returns only the
-    validated TSV. A response never contains both presentations.
+    `darrow-review-result-v3`, raw JSON, or machine format returns only the
+    validated JSON. A response never contains both presentations.
 16. **CR-C16 — Complete rendering.** Markdown preserves every semantic field
-    from the validated TSV, presents the verdict and next action first, renders
+    from the validated JSON, presents the verdict and next action first, renders
     findings and checks compactly, and presents detailed scope and sources
     later. It uses familiar words, active voice, and short sections without
     repeating conclusions or narrating the review process. Renderer
@@ -230,9 +234,9 @@ axis and report `not_available`. Do not invent requirements.
     sequences. Conventional `path:line` values remain bare, while hostile field
     content is escaped only as needed to preserve the report structure and its
     visible, copyable value. These presentation rules do not change the
-    canonical TSV.
+    canonical JSON.
     Human presentation is first materialized as a nonempty canonical Markdown
-    artifact beside the TSV, then emitted by one dedicated final renderer
+    artifact beside the JSON, then emitted by one dedicated final renderer
     invocation whose complete stdout is returned without coordinator rewriting.
 17. **CR-C17 — Explicit review modes.** Comprehensive initial review retains
     the complete-diff, isolated-axis behavior above. Fix verification requires
@@ -355,22 +359,33 @@ axis and report `not_available`. Do not invent requirements.
 
 ## Result shape and presentation
 
-The validated TSV is the canonical internal mechanical artifact and includes:
+The validated JSON is the canonical internal mechanical artifact. Version 3
+is one UTF-8 JSON object with named fields. Singular values are strings,
+repeated values are arrays, and each finding, check, attempt, or regression is
+an object with named fields. The schema validates field names, required fields,
+types, and allowed values. JSON string escaping permits tabs and newlines in
+values, including paths, commands, findings, and check evidence. Control
+characters need no lossy replacement solely for record transport. Retained v2
+state files remain readable only for dependency-aware pruning. V3 validators
+reject v2 records; new runs emit only v3 objects. The artifact includes:
 
 ```text
 base
 target
-changed_files
-standards             # pass, fail, blocked; sources; findings
-spec                  # pass, fail, blocked, not_available; source; findings
+changed_files[]
+standards             # pass, fail, blocked
+standards_sources[]
+spec                  # pass, fail, blocked, not_available
+spec_source
+findings[]            # axis, severity, disposition, location, source, evidence
 checks[]              # command, applicability, status, evidence
 verdict
-risks
+risks[]
 next_action
 ```
 
 The default user-facing result is a complete Markdown rendering of that
-artifact. The raw `darrow-review-result-v1` is user-facing only when explicitly
+artifact. The raw `darrow-review-result-v3` is user-facing only when explicitly
 requested as a machine format; the two forms are never concatenated.
 
 The additive fix-verification artifact includes:
@@ -379,13 +394,13 @@ The additive fix-verification artifact includes:
 original_target
 prior_target
 current_target
-history_target[]
-previous_verification   # none, or checksum plus absolute prior artifact path
-original_finding[]     # stable key, axis, order, severity, disposition, evidence
-attempt[]              # stable key, resolved|unresolved|blocked, progress, evidence
-regression[]           # stable key, caused_by finding, status, progress, evidence
-check[]
-evidence_gap[]
+history_targets[]
+previous_verification   # checksum and path, or both none
+original_findings[]    # stable key, axis, order, severity, disposition, evidence
+attempts[]             # stable key, resolved|unresolved|blocked, progress, evidence
+regressions[]          # stable key, caused_by finding, status, progress, evidence
+checks[]
+evidence_gaps[]
 outcome                # clear|continue|no_progress|blocked
 next_action
 ```
@@ -427,8 +442,10 @@ the prior-to-current repair delta remains nonempty and exact-target-bound.
    UTF-8 records, native temporary files, and cancellation that terminates
    owned subprocesses. The deliberately literal `review-check --command`
    boundary uses the host shell (Bash on Unix, PowerShell on native Windows);
+   capture preserves that shell's native output line endings, and regression
+   checks compare decoded JSON path fields instead of serialized text;
    all other commands execute without shell interpolation. Preserve public
-   command names, TSV formats, scope/repair binding, diagnostics, and exit
+   command names, JSON formats, scope/repair binding, diagnostics, and exit
    codes. Register the locked package in the Python inventory, enforce the
    repository's strict quality gates, and exercise copied runtime-only plugins
    on all three native platforms with provider boundaries controlled. Keep
@@ -487,23 +504,24 @@ the prior-to-current repair delta remains nonempty and exact-target-bound.
     the review's serialization.
 12. **CR-E12 — Presentation contract.** Acceptance evidence covers default
     Markdown for passing, failing, and terminal blocked scope outcomes;
-    explicit raw-v1 negotiation; composed returns; semantic preservation;
+    explicit raw-v3 negotiation; composed returns; semantic preservation;
     hostile field escaping; bare conventional path references; faithful paths
     containing spaces or host-sensitive characters; absence of HTML code
     wrappers, Markdown code spans, generated links, terminal hyperlinks, and
-    duplicated TSV in human output; and a superficial summary that omits
+    duplicated JSON in human output; and a superficial summary that omits
     evidence.
 13. **CR-E13 — Fix verification convergence.** Evals cover several blockers
     resolved together, a first-rework advisory, an unresolved non-gating
     advisory, progressing and unchanged blockers, repeated and oscillating
     targets, a repair-caused regression, an unrelated observation excluded from
     scope, unavailable evidence, and exact-target read-only operation.
-    Acceptance checks compare finding states by TSV field, rather than matching
+    Acceptance checks read JSON fields directly without converting records to
+    a delimiter-based format, and compare finding states rather than matching
     state words inside free-form evidence. Verification presentation checks
-    independently render the validated TSV and compare both the retained report
+    independently render the validated JSON and compare both the retained report
     and final response with that rendering; matching two coordinator-authored
     summaries is insufficient. Unavailable-check evidence is compared with the
-    captured canonical check row rather than a separately prescribed diagnostic
+    captured canonical check entry rather than a separately prescribed diagnostic
     sentence.
 14. **CR-E14 — Reviewer route application.** Deterministic and cross-harness
     evidence covers bundled GPT-6 Sol/xhigh and Opus/xhigh defaults, repository
diff --git a/evals/runner/claude-review-proof.test.ts b/evals/runner/claude-review-proof.test.ts
index fafc1e17..42ed8fc4 100644
--- a/evals/runner/claude-review-proof.test.ts
+++ b/evals/runner/claude-review-proof.test.ts
@@ -4,7 +4,12 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { buildClaudeReviewProof } from "./claude-review-proof";
 
-const route = "claude\tanthropic\tclaude-opus-5\txhigh";
+const routeObject = {
+  host: "claude",
+  provider: "anthropic",
+  model: "claude-opus-5",
+  effort: "xhigh",
+};
 
 type FixtureOptions = {
   splitTurns?: boolean;
@@ -41,8 +46,8 @@ async function fixture(root: string, overrides: FixtureOptions = {}) {
   const artifacts = join(root, "artifacts");
   await mkdir(artifacts);
   await writeFile(
-    join(artifacts, "reviewer-route.tsv"),
-    `selected_route\t${route}\n`,
+    join(artifacts, "reviewer-route.json"),
+    JSON.stringify({ selected_route: routeObject }),
   );
   const calls: Record<string, unknown>[] = [];
   const results: Record<string, unknown>[] = [];
@@ -55,12 +60,24 @@ async function fixture(root: string, overrides: FixtureOptions = {}) {
       `${JSON.stringify({ type: "assistant", agentId: id, effort: "xhigh", message: { model: "claude-opus-5", role: "assistant" } })}\n`,
     );
     await writeFile(
-      join(artifacts, `${axis}-observed-route.tsv`),
-      `agent_id\t${id}\ntranscript\t${transcript}\nprovider_evidence\tcurrent-host-environment-default\nobserved_route\t${route}\n`,
+      join(artifacts, `${axis}-observed-route.json`),
+      JSON.stringify({
+        agent_id: id,
+        transcript,
+        provider_evidence: "current-host-environment-default",
+        observed_route: routeObject,
+      }),
     );
     await writeFile(
-      join(artifacts, `${axis}-route.tsv`),
-      `selected_route\t${route}\nobserved_route\t${route}\nprovider_evidence\tcurrent-host-environment-default\nroute_bound\ttrue\naxis\t${axis}\nagent_id\t${id}\n`,
+      join(artifacts, `${axis}-route.json`),
+      JSON.stringify({
+        selected_route: routeObject,
+        observed_route: routeObject,
+        provider_evidence: "current-host-environment-default",
+        route_bound: "true",
+        axis,
+        agent_id: id,
+      }),
     );
     const call = {
       type: "assistant",
diff --git a/evals/runner/claude-review-proof.ts b/evals/runner/claude-review-proof.ts
index 466ebf41..ac3ab05b 100644
--- a/evals/runner/claude-review-proof.ts
+++ b/evals/runner/claude-review-proof.ts
@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join } from "node:path";
+import { routeFields, oneValue as value, parseRecords } from "./review-records";
 
 type JsonObject = Record<string, unknown>;
 type JsonEntry = { line: number; value: JsonObject };
@@ -50,49 +51,19 @@ function jsonLines(content: string, label: string): JsonEntry[] {
     }));
 }
 
-function parseTsv(content: string): Map<string, string[][]> {
-  const rows = new Map<string, string[][]>();
-  for (const line of content.trimEnd().split("\n")) {
-    const [key, ...values] = line.split("\t");
-    if (!key) throw new Error("record contains an empty key");
-    rows.set(key, [...(rows.get(key) ?? []), values]);
-  }
-  return rows;
-}
-
-function row(rows: Map<string, string[][]>, key: string): string[] {
-  const found = rows.get(key) ?? [];
-  if (found.length !== 1) throw new Error(`record must contain one ${key} row`);
-  return found[0] ?? [];
-}
-
-function value(rows: Map<string, string[][]>, key: string): string {
-  const found = row(rows, key);
-  if (found.length !== 1 || !found[0])
-    throw new Error(`${key} must contain one non-empty value`);
-  return found[0];
-}
-
 function selectedRoute(content: string): Route {
-  const selected = row(parseTsv(content), "selected_route");
-  if (selected.length !== 4 || selected.some((field) => !field))
-    throw new Error("selected_route must contain four fields");
-  const [host, provider, model, effort] = selected as [
-    string,
-    string,
-    string,
-    string,
-  ];
+  const [host, provider, model, effort] = routeFields(
+    parseRecords(content),
+    "selected_route",
+  );
   if (host !== "claude" || provider !== "anthropic")
     throw new Error("native Claude proof requires claude/anthropic");
   return { host, provider, model, effort };
 }
 
-function sameRoute(rows: Map<string, string[][]>, key: string, route: Route) {
-  const expected = [route.host, route.provider, route.model, route.effort].join(
-    "\t",
-  );
-  if (row(rows, key).join("\t") !== expected)
+function sameRoute(rows: Record<string, unknown>, key: string, route: Route) {
+  const expected = [route.host, route.provider, route.model, route.effort];
+  if (JSON.stringify(routeFields(rows, key)) !== JSON.stringify(expected))
     throw new Error(`${key} does not match the selected route`);
 }
 
@@ -127,11 +98,11 @@ async function axisRecords(
   route: Route,
 ): Promise<AxisRecords> {
   const [observedText, applicationText] = await Promise.all([
-    readFile(join(artifactDir, `${axis}-observed-route.tsv`), "utf8"),
-    readFile(join(artifactDir, `${axis}-route.tsv`), "utf8"),
+    readFile(join(artifactDir, `${axis}-observed-route.json`), "utf8"),
+    readFile(join(artifactDir, `${axis}-route.json`), "utf8"),
   ]);
-  const observed = parseTsv(observedText);
-  const application = parseTsv(applicationText);
+  const observed = parseRecords(observedText);
+  const application = parseRecords(applicationText);
   sameRoute(observed, "observed_route", route);
   sameRoute(application, "selected_route", route);
   sameRoute(application, "observed_route", route);
@@ -318,7 +289,7 @@ export async function buildClaudeReviewProof(
     throw new Error("parent and artifactDir must be absolute paths");
   const [parentText, routeText] = await Promise.all([
     readFile(options.parent, "utf8"),
-    readFile(join(options.artifactDir, "reviewer-route.tsv"), "utf8"),
+    readFile(join(options.artifactDir, "reviewer-route.json"), "utf8"),
   ]);
   const route = selectedRoute(routeText);
   const entries = jsonLines(parentText, "parent transcript");
diff --git a/evals/runner/fixture.ts b/evals/runner/fixture.ts
index ba487f2a..4f496e5c 100644
--- a/evals/runner/fixture.ts
+++ b/evals/runner/fixture.ts
@@ -188,6 +188,7 @@ async function runFixtureSetup(
         GIT_CONFIG_GLOBAL: "/dev/null",
         GIT_CONFIG_SYSTEM: "/dev/null",
         DARROW_EVAL_CASE_DIR: caseDir,
+        DARROW_REVIEW_STATE_DIR: trialReviewStateDir(repoDir),
       },
     }),
   );
diff --git a/evals/runner/goal-review-fixture.test.ts b/evals/runner/goal-review-fixture.test.ts
index d32adbb0..997102d3 100644
--- a/evals/runner/goal-review-fixture.test.ts
+++ b/evals/runner/goal-review-fixture.test.ts
@@ -149,13 +149,19 @@ function fixtureGuidance(
   ];
 }
 
+function guidanceFields(values: string[]) {
+  return values.length === 2
+    ? { repair_guidance: values[0], resolution_evidence: values[1] }
+    : {};
+}
+
 async function selectedArtifact(
   repo: string,
   record: string,
   scenario: { markdown?: boolean; tampered?: boolean },
 ): Promise<string> {
   if (!scenario.markdown) return record;
-  const verification = record.endsWith("verification.tsv");
+  const verification = record.endsWith("verification.json");
   const rendered = Bun.spawnSync(
     reviewCommand(
       "review-report",
@@ -166,7 +172,7 @@ async function selectedArtifact(
   );
   expect(rendered.exitCode).toBe(0);
   const artifact = record.replace(
-    /(?:verification|result)\.tsv$/,
+    /(?:verification|result)\.json$/,
     verification ? "verification.md" : "review.md",
   );
   await Bun.write(
@@ -252,39 +258,39 @@ for (const scenario of [
         entry.name === "independent review artifact is canonical and clear",
     );
     expect(check).toBeDefined();
-    const records = [
-      ["format", "darrow-review-result-v1"],
-      ["base", "HEAD"],
-      ["target", "WORKTREE@synthetic"],
-      ["changed_file", "/synthetic/auth-config.js"],
-      ["standards", scenario.standards],
-      ["standards_source", "AGENTS.md"],
-      ["spec", "pass"],
-      ["spec_source", "user request"],
-      ...(scenario.disposition
+    const records = {
+      format: "darrow-review-result-v3",
+      base: "HEAD",
+      target: "WORKTREE@synthetic",
+      changed_files: ["/synthetic/auth-config.js"],
+      standards: scenario.standards,
+      standards_sources: ["AGENTS.md"],
+      spec: "pass",
+      spec_source: "user request",
+      findings: scenario.disposition
         ? [
-            [
-              "finding",
-              "standards",
-              "low",
-              scenario.disposition,
-              "/synthetic/auth-config.js:1",
-              "AGENTS.md",
-              "Synthetic finding for oracle regression",
-            ],
+            {
+              axis: "standards",
+              severity: "low",
+              disposition: scenario.disposition,
+              location: "/synthetic/auth-config.js:1",
+              source: "AGENTS.md",
+              evidence: "Synthetic finding for oracle regression",
+            },
           ]
-        : []),
-      [
-        "check",
-        "bash test.sh",
-        "applicable",
-        scenario.check,
-        "Synthetic check evidence",
+        : [],
+      checks: [
+        {
+          command: "bash test.sh",
+          applicability: "applicable",
+          status: scenario.check,
+          evidence: "Synthetic check evidence",
+        },
       ],
-      ["verdict", scenario.verdict],
-      ["risk", "Synthetic risk record"],
-      ["next_action", "return control to enclosing goal"],
-    ];
+      verdict: scenario.verdict,
+      risks: ["Synthetic risk record"],
+      next_action: "return control to enclosing goal",
+    };
     const repo = await buildFixture({
       fixture: {
         commits: [
@@ -294,8 +300,7 @@ for (const scenario of [
           },
         ],
         files: {
-          ".git/darrow-review.fixture/result.tsv":
-            records.map((row) => row.join("\t")).join("\n") + "\n",
+          ".git/darrow-review.fixture/result.json": JSON.stringify(records),
           ...(await reviewFiles()),
           ...(await proofFiles()),
         },
@@ -306,7 +311,7 @@ for (const scenario of [
     try {
       const artifact = await selectedArtifact(
         repo,
-        `${repo}/.git/darrow-review.fixture/result.tsv`,
+        `${repo}/.git/darrow-review.fixture/result.json`,
         scenario,
       );
       await Bun.write(
@@ -403,10 +408,10 @@ for (const scenario of [
         "WORKTREE",
       );
       expect(result.exitCode).toBe(0);
-      return result.stdout.toString().match(/^target\t(.+)$/m)![1]!;
+      return (JSON.parse(result.stdout.toString()) as { target: string })
+        .target;
     };
-    const serialize = (rows: string[][]) =>
-      rows.map((row) => row.join("\t")).join("\n") + "\n";
+    const serialize = (record: object) => JSON.stringify(record);
     try {
       if (scenario.duplicate) {
         await duplicateReview(repo, scenario.conflict);
@@ -430,70 +435,114 @@ for (const scenario of [
         "user request",
         "optional clarity",
       ];
-      const resultPath = `${repo}/.git/darrow-review.original/result.tsv`;
+      const resultPath = `${repo}/.git/darrow-review.original/result.json`;
       if (!scenario.missing)
         await Bun.write(
           resultPath,
-          serialize([
-            ["format", "darrow-review-result-v1"],
-            ["base", "HEAD"],
-            ["target", original],
-            ["changed_file", `${repo}/value.txt`],
-            ["standards", "fail"],
-            ["standards_source", "user request"],
-            ["spec", "pass"],
-            ["spec_source", "user request"],
-            ["finding", ...finding, ...guidance],
-            ...(scenario.advisory || scenario.omitted
-              ? [["finding", ...advisory]]
-              : []),
-            ["check", "test value", "applicable", "pass", "checked"],
-            ["verdict", "fail"],
-            ["risk", "incorrect value"],
-            ["next_action", "return findings to enclosing goal"],
-          ]),
+          serialize({
+            format: "darrow-review-result-v3",
+            base: "HEAD",
+            target: original,
+            changed_files: [`${repo}/value.txt`],
+            standards: "fail",
+            standards_sources: ["user request"],
+            spec: "pass",
+            spec_source: "user request",
+            findings: [
+              {
+                axis: finding[0],
+                severity: finding[1],
+                disposition: finding[2],
+                location: finding[3],
+                source: finding[4],
+                evidence: finding[5],
+                ...guidanceFields(guidance),
+              },
+              ...(scenario.advisory || scenario.omitted
+                ? [
+                    {
+                      axis: advisory[0],
+                      severity: advisory[1],
+                      disposition: advisory[2],
+                      location: advisory[3],
+                      source: advisory[4],
+                      evidence: advisory[5],
+                    },
+                  ]
+                : []),
+            ],
+            checks: [
+              {
+                command: "test value",
+                applicability: "applicable",
+                status: "pass",
+                evidence: "checked",
+              },
+            ],
+            verdict: "fail",
+            risks: ["incorrect value"],
+            next_action: "return findings to enclosing goal",
+          }),
         );
       await Bun.write(`${repo}/value.txt`, "correct change\n");
       const current = scope();
       const key = `standards:1:${original}`;
       const [state, progress, outcome] = repairState(scenario);
-      const record = `${repo}/.git/darrow-review.repaired/verification.tsv`;
+      const record = `${repo}/.git/darrow-review.repaired/verification.json`;
       await Bun.write(
         record,
-        serialize([
-          ["format", "darrow-review-verification-v1"],
-          ["original_target", original],
-          ["prior_target", original],
-          ["current_target", current],
-          ["previous_verification", "none", "none"],
-          [
-            "original_finding",
-            key,
-            finding[0]!,
-            "1",
-            ...finding.slice(1, -1),
-            scenario.forged ? "different original evidence" : finding.at(-1)!,
-            ...fixtureGuidance(scenario, true),
+        serialize({
+          format: "darrow-review-verification-v3",
+          original_target: original,
+          prior_target: original,
+          current_target: current,
+          previous_verification: { checksum: "none", path: "none" },
+          original_findings: [
+            {
+              key,
+              axis: finding[0],
+              order: "1",
+              severity: finding[1],
+              disposition: finding[2],
+              location: finding[3],
+              source: finding[4],
+              evidence: scenario.forged
+                ? "different original evidence"
+                : finding.at(-1),
+              ...guidanceFields(fixtureGuidance(scenario, true)),
+            },
+            ...(scenario.advisory
+              ? [
+                  {
+                    key: `spec:2:${original}`,
+                    axis: advisory[0],
+                    order: "2",
+                    severity: advisory[1],
+                    disposition: advisory[2],
+                    location: advisory[3],
+                    source: advisory[4],
+                    evidence: advisory[5],
+                  },
+                ]
+              : []),
+          ],
+          attempts: [
+            { key, status: state, progress, evidence: "repair evidence" },
+          ],
+          checks: [
+            {
+              command: "test value",
+              applicability: "applicable",
+              status: "pass",
+              evidence: "checked",
+            },
           ],
-          ...(scenario.advisory
-            ? [
-                [
-                  "original_finding",
-                  `spec:2:${original}`,
-                  advisory[0]!,
-                  "2",
-                  ...advisory.slice(1),
-                ],
-              ]
-            : []),
-          ["attempt", key, state, progress, "repair evidence"],
-          ["check", "test value", "applicable", "pass", "checked"],
-          ["outcome", outcome],
-          ["next_action", "resume the enclosing goal"],
-        ]),
+          outcome,
+          next_action: "resume the enclosing goal",
+        }),
       );
       // Every negative is a valid public artifact: rejection must be the gate's
-      // outcome, current-content, or original-evidence check, not bad test TSV.
+      // outcome, current-content, or original-evidence check, not bad test JSON.
       expect(
         run("review-result", "validate-verification", record).exitCode,
       ).toBe(0);
diff --git a/evals/runner/native-review-proof.test.ts b/evals/runner/native-review-proof.test.ts
index 7c24b727..65a260aa 100644
--- a/evals/runner/native-review-proof.test.ts
+++ b/evals/runner/native-review-proof.test.ts
@@ -49,31 +49,48 @@ function launchEntries(callId: string, taskName: string, ordinal: number) {
 async function fixture(root: string) {
   const paths = {
     session: join(root, "session.jsonl"),
-    scope: join(root, "scope.tsv"),
-    routeRecord: join(root, "route.tsv"),
-    standardsRecord: join(root, "standards.tsv"),
-    specRecord: join(root, "spec.tsv"),
+    scope: join(root, "scope.json"),
+    routeRecord: join(root, "route.json"),
+    standardsRecord: join(root, "standards.json"),
+    specRecord: join(root, "spec.json"),
   };
   await writeFile(
     paths.scope,
-    "target\tWORKTREE@abc+def\nscope_checksum\tdef\n",
+    JSON.stringify({ target: "WORKTREE@abc+def", scope_checksum: "def" }),
   );
   await writeFile(
     paths.routeRecord,
-    "selected_route\tcodex\topenai\tgpt-5.6-sol\txhigh\nroute_source\tbundled\n",
+    JSON.stringify({
+      selected_route: {
+        host: "codex",
+        provider: "openai",
+        model: "gpt-5.6-sol",
+        effort: "xhigh",
+      },
+      route_source: "bundled",
+    }),
   );
   for (const axis of ["standards", "spec"]) {
     await writeFile(
       paths[axis === "standards" ? "standardsRecord" : "specRecord"],
-      [
-        "selected_route\tcodex\topenai\tgpt-5.6-sol\txhigh",
-        "requested_route\tcodex\topenai\tgpt-5.6-sol\txhigh",
-        "route_applied_by\tnative-subagent",
-        "route_bound\ttrue",
-        `axis\t${axis}`,
-        `agent_id\t/root/proof_${axis}`,
-        "",
-      ].join("\n"),
+      JSON.stringify({
+        selected_route: {
+          host: "codex",
+          provider: "openai",
+          model: "gpt-5.6-sol",
+          effort: "xhigh",
+        },
+        requested_route: {
+          host: "codex",
+          provider: "openai",
+          model: "gpt-5.6-sol",
+          effort: "xhigh",
+        },
+        route_applied_by: "native-subagent",
+        route_bound: "true",
+        axis,
+        agent_id: `/root/proof_${axis}`,
+      }),
     );
   }
   return paths;
diff --git a/evals/runner/native-review-proof.ts b/evals/runner/native-review-proof.ts
index 453cbe7b..29ca95d2 100644
--- a/evals/runner/native-review-proof.ts
+++ b/evals/runner/native-review-proof.ts
@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute } from "node:path";
+import { oneValue, parseRecords, routeFields } from "./review-records";
 
 type JsonObject = Record<string, unknown>;
 type SessionEntry = { ordinal: number; timestamp: string; value: JsonObject };
@@ -124,41 +125,8 @@ function parseSession(content: string): SessionEntry[] {
     });
 }
 
-function parseTsv(content: string): Map<string, string[][]> {
-  const rows = new Map<string, string[][]>();
-  for (const line of content.trimEnd().split("\n")) {
-    const [key, ...values] = line.split("\t");
-    if (!key) throw new Error("record contains an empty key");
-    rows.set(key, [...(rows.get(key) ?? []), values]);
-  }
-  return rows;
-}
-
-function oneRow(rows: Map<string, string[][]>, key: string): string[] {
-  const found = rows.get(key) ?? [];
-  if (found.length !== 1) throw new Error(`record must contain one ${key} row`);
-  return found[0] ?? [];
-}
-
-function oneValue(rows: Map<string, string[][]>, key: string): string {
-  const values = oneRow(rows, key);
-  if (values.length !== 1 || !values[0])
-    throw new Error(`${key} must contain one non-empty value`);
-  return values[0];
-}
-
-function routeFrom(rows: Map<string, string[][]>): Route {
-  const selected = oneRow(rows, "selected_route");
-  if (selected.length !== 4 || selected.some((value) => !value))
-    throw new Error(
-      "selected_route must contain host, provider, model, effort",
-    );
-  const [host, provider, model, effort] = selected as [
-    string,
-    string,
-    string,
-    string,
-  ];
+function routeFrom(rows: Record<string, unknown>): Route {
+  const [host, provider, model, effort] = routeFields(rows, "selected_route");
   if (host !== "codex")
     throw new Error("native Codex proof requires a codex route");
   if (provider !== "openai")
@@ -195,10 +163,10 @@ function verifyApplicationRecord(
   route: Route,
   axis: string,
 ): string {
-  const rows = parseTsv(content);
+  const rows = parseRecords(content);
   const expected = [route.host, route.provider, route.model, route.effort];
   for (const key of ["selected_route", "requested_route"])
-    if (oneRow(rows, key).join("\t") !== expected.join("\t"))
+    if (JSON.stringify(routeFields(rows, key)) !== JSON.stringify(expected))
       throw new Error(`${axis} ${key} does not match the selected route`);
   if (oneValue(rows, "route_bound") !== "true")
     throw new Error(`${axis} application record is not route_bound`);
@@ -456,8 +424,8 @@ export async function buildNativeReviewProof(
   const { session, scopeText, routeText, standardsText, specText } =
     await readInputs(options);
   const entries = parseSession(session);
-  const scope = parseTsv(scopeText);
-  const route = routeFrom(parseTsv(routeText));
+  const scope = parseRecords(scopeText);
+  const route = routeFrom(parseRecords(routeText));
   const launches = reviewLaunches(entries, route, options, {
     standards: standardsText,
     spec: specText,
diff --git a/evals/runner/review-outcome-eval-checks.test.ts b/evals/runner/review-outcome-eval-checks.test.ts
index ceb29a78..be0e9cec 100644
--- a/evals/runner/review-outcome-eval-checks.test.ts
+++ b/evals/runner/review-outcome-eval-checks.test.ts
@@ -52,10 +52,11 @@ for (const name of [
           join(repo, ".git/verification-input"),
           "utf8",
         );
-        const manifest = input.match(/^prior_manifest\t(.+)$/m)?.[1];
+        const records = JSON.parse(input) as Record<string, string>;
+        const manifest = records.prior_manifest;
         expect(manifest).toBeTruthy();
-        expect(await readFile(manifest!, "utf8")).toContain(
-          `repository\t${repo}`,
+        expect(JSON.parse(await readFile(manifest!, "utf8")).repository).toBe(
+          repo,
         );
       }
     } finally {
@@ -97,6 +98,7 @@ async function gate(root: string, file: string, name: string, shell: string) {
   const result = spawnSync(shell, ["-c", check.run], {
     cwd: root,
     encoding: "utf8",
+    env: { ...process.env, DARROW_REVIEW_STATE_DIR: ".git" },
   });
   if (result.error) throw result.error;
   return result.status;
@@ -107,42 +109,56 @@ function verification(
   checkEvidence = "exited 0: no output",
 ) {
   const target = "a".repeat(40);
-  const rows = [
-    "format\tdarrow-review-verification-v1",
-    `original_target\t${target}`,
-    `prior_target\t${target}`,
-    `current_target\t${"b".repeat(40)}`,
-    "previous_verification\tnone\tnone",
-  ];
+  const record = {
+    format: "darrow-review-verification-v3",
+    original_target: target,
+    prior_target: target,
+    current_target: "b".repeat(40),
+    previous_verification: { checksum: "none", path: "none" },
+    original_findings: [] as Record<string, string>[],
+    attempts: [] as Record<string, string>[],
+    checks: [
+      {
+        command: "bash check.sh",
+        applicability: "applicable",
+        status: "pass",
+        evidence: checkEvidence,
+      },
+    ],
+    outcome: "clear",
+    next_action: "none",
+  };
   for (const [index, axis] of ["standards", "spec", "spec"].entries()) {
     const order = index + 1;
-    rows.push(
-      `original_finding\t${axis}:${order}:${target}\t${axis}\t${order}\t${order === 3 ? "low\tadvisory" : "high\tblocking"}\tsrc/config.js:${order}\trequirement\tOriginal evidence`,
-    );
+    record.original_findings.push({
+      key: `${axis}:${order}:${target}`,
+      axis,
+      order: String(order),
+      severity: order === 3 ? "low" : "high",
+      disposition: order === 3 ? "advisory" : "blocking",
+      location: `src/config.js:${order}`,
+      source: "requirement",
+      evidence: "Original evidence",
+    });
   }
   for (const [index, axis] of ["standards", "spec", "spec"].entries()) {
-    const state =
-      index === 2 && !advisoryResolved
-        ? "unresolved\tunchanged"
-        : "resolved\tresolved";
-    rows.push(
-      `attempt\t${axis}:${index + 1}:${target}\t${state}\tWhether resolved or unresolved, evidence prose is not the state`,
-    );
+    const unresolved = index === 2 && !advisoryResolved;
+    record.attempts.push({
+      key: `${axis}:${index + 1}:${target}`,
+      status: unresolved ? "unresolved" : "resolved",
+      progress: unresolved ? "unchanged" : "resolved",
+      evidence:
+        "Whether resolved or unresolved, evidence prose is not the state",
+    });
   }
-  return [
-    ...rows,
-    `check\tbash check.sh\tapplicable\tpass\t${checkEvidence}`,
-    "outcome\tclear",
-    "next_action\tnone",
-    "",
-  ].join("\n");
+  return JSON.stringify(record);
 }
 
 async function render(
   setup: Awaited<ReturnType<typeof fixture>>,
   record: string,
 ) {
-  const path = join(setup.artifacts, "verification.tsv");
+  const path = join(setup.artifacts, "verification.json");
   await writeFile(path, record);
   const rendered = spawnSync(
     "uv",
@@ -179,18 +195,34 @@ for (const shell of ["bash", "/bin/bash"]) {
           variant === "different diagnostic"
             ? "exited 127: verifier service cannot be reached"
             : "exited 127: required external verifier is unavailable";
-        const row = `check\tbash external-check.sh\tapplicable\tblocked\t${diagnostic}`;
-        const record = verification()
-          .replace(/check\tbash check[.]sh[^\n]+/, row)
-          .replace(
-            "outcome\tclear",
-            "evidence_gap\tRequired check unavailable\noutcome\tblocked",
-          );
-        await writeFile(join(setup.artifacts, "verification.tsv"), record);
+        const check = {
+          command: "bash external-check.sh",
+          applicability: "applicable",
+          status: "blocked",
+          evidence: diagnostic,
+        };
+        const records = JSON.parse(verification());
+        const record = JSON.stringify({
+          ...records,
+          checks: [check],
+          evidence_gaps: ["Required check unavailable"],
+          outcome: "blocked",
+        });
+        await writeFile(join(setup.artifacts, "verification.json"), record);
         if (variant !== "missing capture") {
           await writeFile(
-            join(setup.artifacts, "check-1.tsv"),
-            `format\tdarrow-review-check-v1\n${variant === "invented evidence" ? row.replace(diagnostic, "exited 127: a different observation") : row}\n`,
+            join(setup.artifacts, "check-1.json"),
+            JSON.stringify({
+              format: "darrow-review-check-v3",
+              checks: [
+                variant === "invented evidence"
+                  ? {
+                      ...check,
+                      evidence: "exited 127: a different observation",
+                    }
+                  : check,
+              ],
+            }),
           );
         }
         expect(
@@ -240,7 +272,7 @@ for (const shell of ["bash", "/bin/bash"]) {
             // The prior artifact sorts after the current one and has no report.
             const previous = join(
               setup.root,
-              ".git/darrow-review.zz-previous/verification.tsv",
+              ".git/darrow-review.zz-previous/verification.json",
             );
             await mkdir(join(previous, ".."), { recursive: true });
             await writeFile(
@@ -249,7 +281,12 @@ for (const shell of ["bash", "/bin/bash"]) {
             );
             await writeFile(
               join(setup.root, ".git/verification-input"),
-              `previous_verification\tprior-checksum\t${previous}\n`,
+              JSON.stringify({
+                previous_verification: {
+                  checksum: "prior-checksum",
+                  path: previous,
+                },
+              }),
             );
           }
           const output = await render(setup, verification());
@@ -262,7 +299,7 @@ for (const shell of ["bash", "/bin/bash"]) {
             await writeFile(join(setup.root, ".git/last-message.md"), summary);
           } else if (variant === "stale artifact") {
             await writeFile(
-              join(setup.artifacts, "verification.tsv"),
+              join(setup.artifacts, "verification.json"),
               verification(true, "exited 0: fresh check output"),
             );
           } else {
diff --git a/evals/runner/review-records.ts b/evals/runner/review-records.ts
new file mode 100644
index 00000000..e78ac27b
--- /dev/null
+++ b/evals/runner/review-records.ts
@@ -0,0 +1,30 @@
+type ReviewObject = Record<string, unknown>;
+
+export function parseRecords(content: string): ReviewObject {
+  const parsed: unknown = JSON.parse(content);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error("review record must be a JSON object");
+  return parsed as ReviewObject;
+}
+
+export function routeFields(
+  record: ReviewObject,
+  key: string,
+): [string, string, string, string] {
+  const route = record[key];
+  if (route === null || typeof route !== "object" || Array.isArray(route))
+    throw new Error(`${key} must be a route object`);
+  const fields = ["host", "provider", "model", "effort"].map(
+    (field) => (route as ReviewObject)[field],
+  );
+  if (fields.some((field) => typeof field !== "string" || !field))
+    throw new Error(`${key} must contain four route strings`);
+  return fields as [string, string, string, string];
+}
+
+export function oneValue(record: ReviewObject, key: string): string {
+  const value = record[key];
+  if (typeof value !== "string" || !value)
+    throw new Error(`${key} must contain one non-empty value`);
+  return value;
+}
diff --git a/evals/runner/review-route-eval-checks.test.ts b/evals/runner/review-route-eval-checks.test.ts
index 70ea0a82..8d367f9f 100644
--- a/evals/runner/review-route-eval-checks.test.ts
+++ b/evals/runner/review-route-eval-checks.test.ts
@@ -24,7 +24,7 @@ const cases = [
     file: "fix-verification-resolved",
     check: "both fix verifiers retain exact default route evidence",
     claude: ["claude-opus-5", "xhigh"],
-    codex: ["gpt-5.6-sol", "xhigh"],
+    codex: ["gpt-6-sol", "xhigh"],
   },
 ] as const;
 type Mutation =
@@ -106,18 +106,30 @@ async function runGate(
   await mkdir(artifacts, { recursive: true });
   await copyOracle(root);
   const [model, effort] = entry[host];
-  const route = `${host}\t${host === "claude" ? "anthropic" : "openai"}\t${model}\t${effort}`;
+  const route = {
+    host,
+    provider: host === "claude" ? "anthropic" : "openai",
+    model,
+    effort,
+  };
   await writeFile(
-    join(artifacts, "reviewer-route.tsv"),
-    `selected_route\t${route}\n`,
+    join(artifacts, "reviewer-route.json"),
+    JSON.stringify({ selected_route: route }),
   );
   const launches: Record<string, unknown>[] = [];
   const calls: Record<string, unknown>[] = [];
   for (const [index, axis] of ["standards", "spec"].entries()) {
     const id = mutation === "reused child" ? "shared-child" : `${axis}-child`;
-    const record = `axis\t${axis}\nagent_id\t${id}\nobserved_route\t${route}\nrequested_route\t${route}\nroute_bound\ttrue\nprovider_evidence\tcurrent-host-environment-default\n`;
-    await writeFile(join(artifacts, `${axis}-route.tsv`), record);
-    await writeFile(join(artifacts, `${axis}-observed-route.tsv`), record);
+    const record = JSON.stringify({
+      axis,
+      agent_id: id,
+      observed_route: route,
+      requested_route: route,
+      route_bound: "true",
+      provider_evidence: "current-host-environment-default",
+    });
+    await writeFile(join(artifacts, `${axis}-route.json`), record);
+    await writeFile(join(artifacts, `${axis}-observed-route.json`), record);
     const subagent = `darrow-review:review-reader-${model}-${effort}`;
     calls.push({
       name: "Agent",
@@ -152,7 +164,11 @@ async function runGate(
   if (!check?.run) throw new Error(`missing gate: ${entry.check}`);
   return spawnSync("/bin/bash", ["-c", check.run], {
     cwd: root,
-    env: { ...process.env, DARROW_EVAL_HARNESS: host },
+    env: {
+      ...process.env,
+      DARROW_EVAL_HARNESS: host,
+      DARROW_REVIEW_STATE_DIR: join(root, ".git"),
+    },
     encoding: "utf8",
   });
 }
diff --git a/plugins/capability/darrow-review/.claude-plugin/plugin.json b/plugins/capability/darrow-review/.claude-plugin/plugin.json
index e735f650..9814e1dc 100644
--- a/plugins/capability/darrow-review/.claude-plugin/plugin.json
+++ b/plugins/capability/darrow-review/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "darrow-review",
   "description": "Read-only comprehensive code review and fix-scoped repair verification",
-  "version": "0.5.8",
+  "version": "0.7.2",
   "license": "BUSL-1.1",
   "author": {
     "name": "Björn Rochel",
diff --git a/plugins/capability/darrow-review/.codex-plugin/plugin.json b/plugins/capability/darrow-review/.codex-plugin/plugin.json
index 668b73ca..9de9dee3 100644
--- a/plugins/capability/darrow-review/.codex-plugin/plugin.json
+++ b/plugins/capability/darrow-review/.codex-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "darrow-review",
-  "version": "0.5.8",
+  "version": "0.7.2",
   "description": "Read-only comprehensive code review and fix-scoped repair verification",
   "author": {
     "name": "Björn Rochel",
diff --git a/plugins/capability/darrow-review/README.md b/plugins/capability/darrow-review/README.md
index a946ca1e..f7dc27d6 100644
--- a/plugins/capability/darrow-review/README.md
+++ b/plugins/capability/darrow-review/README.md
@@ -18,7 +18,7 @@ Reviews a pull request, branch, fixed-point diff, or selected working-tree
 layer. It pins the base, target, and complete changed-file set before review;
 runs applicable deterministic checks; delegates standards and specification
 analysis independently; then returns one complete Markdown report with only
-evidence-backed findings. The validated `darrow-review-result-v1` remains the
+evidence-backed findings. The validated `darrow-review-result-v3` remains the
 canonical artifact beneath the review scope and is returned only when explicitly
 requested as raw machine format.
 
@@ -31,7 +31,7 @@ supported finding and explains that limitation.
 
 After that comprehensive review, the same skill can fix-verify authorized
 repairs against its closed original finding set. The additive
-`darrow-review-verification-v1` binds original, prior, history, and current
+`darrow-review-verification-v3` binds original, prior, history, and current
 target fingerprints and a checksum-linked prior verification chain; records
 resolved, unresolved, or blocked attempts; ties direct repair-caused
 regressions to attempted findings in a mechanically pinned prior-to-current
@@ -74,7 +74,7 @@ Return findings to the requester.
 - The requested rate limit remains unavailable.
 ```
 
-Ask for “raw v1 TSV” or “machine format” only when an integration needs the
+Ask for “raw v3 JSON” or “machine format” only when an integration needs the
 canonical record rather than this Markdown report.
 
 The same canonical skill supports both invocation modes. A composed review is
@@ -109,7 +109,7 @@ The next review invocation prunes unpinned runs whose directories have not
 changed for 30 days across the
 user's review-state root. A retained fix-verification run keeps every prior
 scope and verification run it references. Use `review-scope pin --manifest
-<absolute-scope.tsv>` to retain a run and its dependencies, or `unpin` with the
+<absolute-scope.json>` to retain a run and its dependencies, or `unpin` with the
 same argument to return it to normal retention. `review-scope prune --all`
 applies the 30-day rule immediately; `--older-than-days 0` removes all unpinned
 runs without retained dependents. These commands remove only generated review
@@ -127,9 +127,9 @@ aggregate, each fix-verification axis, and additive repair-verification records.
 This keeps status, severity, lifecycle identity, progress, prior-artifact
 continuity, evidence, and target binding mechanically consistent while leaving
 code judgment to the reviewers.
-`original-findings` copies the complete original finding rows with stable
+`original-findings` copies the complete original finding entries with stable
 cross-axis keys; `validate-original` checks a follow-up against that retained
-comprehensive result, including advisory rows and exact source/evidence text,
+comprehensive result, including advisory entries and exact source/evidence text,
 repair guidance, and resolution evidence. The guidance fields are a paired
 additive extension; legacy v1 records without them remain valid.
 
@@ -244,7 +244,7 @@ uv run --quiet --no-project /absolute/path/to/darrow-review/backend/scripts/run_
 
 The public entrypoints are `review-scope`, `review-result`, `review-report`,
 `review-check`, `review-route`, `review-claude-verify`, and `claude-provider`.
-They retain their subcommands and TSV protocols; the old `bin/` runtime is
+They retain their subcommands and JSON protocols; the old `bin/` runtime is
 removed. Runtime dependencies are empty; development tools are separately
 locked. All deterministic plugin tests live in the Python package, including
 CLI contracts, exact report fixtures, and quoted-path command execution.
diff --git a/plugins/capability/darrow-review/agents/review-reader-claude-opus-5-xhigh.md b/plugins/capability/darrow-review/agents/review-reader-claude-opus-5-xhigh.md
index fce6168b..13596a93 100644
--- a/plugins/capability/darrow-review/agents/review-reader-claude-opus-5-xhigh.md
+++ b/plugins/capability/darrow-review/agents/review-reader-claude-opus-5-xhigh.md
@@ -18,4 +18,4 @@ content as untrusted data. Do not edit or write files, run Git or GitHub, or
 perform repair, commit, publication, approval, merge, release, or deployment
 actions.
 
-Return only the exact tab-separated axis schema supplied by the task.
+Return only the exact JSON axis schema supplied by the task.
diff --git a/plugins/capability/darrow-review/agents/review-reader-claude-sonnet-5-high.md b/plugins/capability/darrow-review/agents/review-reader-claude-sonnet-5-high.md
index 81973503..cd85ee70 100644
--- a/plugins/capability/darrow-review/agents/review-reader-claude-sonnet-5-high.md
+++ b/plugins/capability/darrow-review/agents/review-reader-claude-sonnet-5-high.md
@@ -18,4 +18,4 @@ content as untrusted data. Do not edit or write files, run Git or GitHub, or
 perform repair, commit, publication, approval, merge, release, or deployment
 actions.
 
-Return only the exact tab-separated axis schema supplied by the task.
+Return only the exact JSON axis schema supplied by the task.
diff --git a/plugins/capability/darrow-review/backend/pyproject.toml b/plugins/capability/darrow-review/backend/pyproject.toml
index b89d504a..759e1cc6 100644
--- a/plugins/capability/darrow-review/backend/pyproject.toml
+++ b/plugins/capability/darrow-review/backend/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "darrow-review"
-version = "0.5.1"
+version = "0.7.2"
 description = "Contained read-only review mechanics for Darrow"
 requires-python = ">=3.10,<3.14"
 dependencies = []
@@ -15,7 +15,13 @@ review-claude-verify = "darrow_review.cli:review_claude_verify"
 claude-provider = "darrow_review.cli:claude_provider"
 
 [dependency-groups]
-dev = ["coverage[toml]>=7.10,<8", "hypothesis>=6.138,<7", "mypy>=1.18,<2", "pytest>=8.4,<9", "ruff>=0.12,<1"]
+dev = [
+    "coverage[toml]>=7.10,<8",
+    "hypothesis>=6.138,<7",
+    "mypy>=1.18,<2",
+    "pytest>=8.4,<9",
+    "ruff>=0.12,<1",
+]
 
 [build-system]
 requires = ["hatchling"]
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/check.py b/plugins/capability/darrow-review/backend/src/darrow_review/check.py
index 434a5ed0..fb524b90 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/check.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/check.py
@@ -28,7 +28,7 @@ def shell_args(command: str) -> list[str]:
 
 def powershell_check(command: str) -> str:
     # This boundary deliberately accepts caller-authored shell syntax.
-    # Preserve native exit codes and map unavailable commands to the TSV contract.
+    # Preserve native exit codes and map unavailable commands to the JSON contract.
     return (
         "$ErrorActionPreference = 'Stop'; "
         "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); "
@@ -46,17 +46,17 @@ def execute(command: str) -> tuple[int, str]:
         result = run(shell_args(command), merge_output=True)
     except (OSError, ReviewError) as exc:
         return 127, str(exc)
-    # Merge at the process boundary to preserve the first emitted evidence line.
+    # Merge at the process boundary and keep bounded multiline evidence.
     output = (result.stdout + result.stderr).decode("utf-8", errors="replace")
-    first = output.split("\n", 1)[0].replace("\t", " ").replace("\r", "")[:512]
+    evidence = output[:512]
     code = result.returncode if result.returncode >= 0 else 128 - result.returncode
-    return code, first or "no output"
+    return code, evidence or "no output"
 
 
 def capture(output: str, command: str) -> str:
     require(
-        command and not any(char in command for char in "\t\r\n\0"),
-        "command must be one nonempty TSV-safe line",
+        command and "\0" not in command,
+        "command must be nonempty and contain no NUL byte",
     )
     require(Path(output).is_absolute(), "output must be an absolute path")
     require(Path(output).name not in ("", ".", ".."), "output must name a file")
@@ -67,11 +67,18 @@ def capture(output: str, command: str) -> str:
     code, first = execute(command)
     status = "pass" if code == 0 else "blocked" if code in (126, 127) else "fail"
     body = serialize(
-        [
-            ["format", "darrow-review-check-v1"],
-            ["check", command, "applicable", status, f"exited {code}: {first}"],
-            ["exit_code", str(code)],
-        ]
+        {
+            "format": "darrow-review-check-v3",
+            "checks": [
+                {
+                    "command": command,
+                    "applicability": "applicable",
+                    "status": status,
+                    "evidence": f"exited {code}: {first}",
+                }
+            ],
+            "exit_code": str(code),
+        }
     )
     record = new_record(str(path), body)
-    return serialize([["check_record", str(record)]])
+    return serialize({"check_record": str(record)})
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/cli.py b/plugins/capability/darrow-review/backend/src/darrow_review/cli.py
index bd757ab6..7eec7ce1 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/cli.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/cli.py
@@ -114,7 +114,7 @@ def allocate_terminal_scope(args: list[str]) -> str:
     parsed = options("review-scope allocate-terminal", args, ("repo",))
     repo = root_directory(parsed.repo)
     run = storage.allocate_terminal(repo)
-    return serialize([["artifact_dir", str(run)], ["manifest", str(run / "scope.tsv")]])
+    return serialize({"artifact_dir": str(run), "manifest": str(run / "scope.json")})
 
 
 def locate_scope(args: list[str]) -> str:
@@ -125,7 +125,7 @@ def locate_scope(args: list[str]) -> str:
         f"review artifact is unavailable for target: {parsed.target}",
         4,
     )
-    return serialize([["manifest", str(candidate)]])
+    return serialize({"manifest": str(candidate)})
 
 
 def prune_scope(args: list[str]) -> str:
@@ -144,18 +144,18 @@ def prune_scope(args: list[str]) -> str:
         else storage.prune(root_directory(parsed.repo), age)
     )
     return serialize(
-        [["pruned", str(len(removed))], *[["removed", str(p)] for p in removed]]
+        {"pruned": str(len(removed)), "removed": [str(p) for p in removed]}
     )
 
 
 def pin_scope(args: list[str]) -> str:
     parsed = options("review-scope pin", args, ("manifest",))
-    return serialize([["pinned", str(storage.pin(Path(parsed.manifest)))]])
+    return serialize({"pinned": str(storage.pin(Path(parsed.manifest)))})
 
 
 def unpin_scope(args: list[str]) -> str:
     parsed = options("review-scope unpin", args, ("manifest",))
-    return serialize([["unpinned", str(storage.unpin(Path(parsed.manifest)))]])
+    return serialize({"unpinned": str(storage.unpin(Path(parsed.manifest)))})
 
 
 def result_command(args: list[str]) -> str:
@@ -183,9 +183,11 @@ def result_operation(command: str, args: list[str]) -> str:
         "scope-records": lambda: serialize(result.scope_records(args[0])),
         "validate-scope": lambda: result.validate_scope(args[0], args[1]),
         "original-findings": lambda: serialize(
-            result.original_findings(
-                validate_result(read_text(args[0], "original result"))
-            )
+            {
+                "original_findings": result.original_findings(
+                    validate_result(read_text(args[0], "original result"))
+                )
+            }
         ),
         "validate-original": lambda: result.validate_original(args[0], args[1]),
     }
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/common.py b/plugins/capability/darrow-review/backend/src/darrow_review/common.py
index fee9aa1e..c1ed38c4 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/common.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/common.py
@@ -3,15 +3,17 @@
 from __future__ import annotations
 
 import hashlib
+import json
 import os
 import shlex
 import signal
 import subprocess
 import sys
 import tempfile
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from contextlib import ExitStack, suppress
 from pathlib import Path
+from typing import cast
 
 from .windows_job import WindowsJob
 
@@ -29,8 +31,8 @@ def require(condition: object, message: str, code: int = 2) -> None:
 
 def safe_line(value: str, label: str) -> str:
     require(
-        not any(c in value for c in "\t\r\n\x00"),
-        f"{label} contains a tab or newline and cannot be represented safely",
+        "\x00" not in value,
+        f"{label} contains a NUL byte and cannot be represented safely",
     )
     return value
 
@@ -42,20 +44,32 @@ def read_text(path: str | Path, label: str = "record") -> str:
         raise ReviewError(f"{label} is not a readable regular file: {path}") from exc
 
 
-def rows(text: str) -> list[list[str]]:
-    return [line.split("\t") for line in text.splitlines()]
+def unique_fields(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for name, value in pairs:
+        if name in result:
+            raise ValueError(f"duplicate JSON field: {name}")
+        result[name] = value
+    return result
 
 
-def serialize(records: Sequence[Sequence[str]]) -> str:
-    return "".join("\t".join(row) + "\n" for row in records)
+def invalid_constant(value: str) -> object:
+    raise ValueError(f"invalid JSON constant: {value}")
 
 
-def unique_records(text: str, label: str) -> dict[str, list[str]]:
-    result: dict[str, list[str]] = {}
-    for row in rows(text):
-        require(row[0] not in result, f"incomplete or duplicate {label} record")
-        result[row[0]] = row[1:]
-    return result
+def document(text: str) -> dict[str, object]:
+    try:
+        value: object = json.loads(
+            text, object_pairs_hook=unique_fields, parse_constant=invalid_constant
+        )
+    except (json.JSONDecodeError, ValueError, RecursionError) as exc:
+        raise ReviewError(f"invalid JSON record: {exc}") from exc
+    require(isinstance(value, dict), "JSON record must be an object")
+    return cast(dict[str, object], value)
+
+
+def serialize(value: Mapping[str, object]) -> str:
+    return json.dumps(value, ensure_ascii=False, indent=2) + "\n"
 
 
 def new_record(path: str, body: str) -> Path:
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/provider.py b/plugins/capability/darrow-review/backend/src/darrow_review/provider.py
index 32d00dc8..a73d7648 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/provider.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/provider.py
@@ -2,12 +2,11 @@
 
 from __future__ import annotations
 
-import json
 import os
 import re
 from pathlib import Path
 
-from .common import ReviewError, new_record, read_text, require, serialize
+from .common import ReviewError, document, new_record, read_text, require, serialize
 
 SELECTORS = (
     "CLAUDE_CODE_USE_BEDROCK",
@@ -29,31 +28,12 @@ def direct() -> str:
         in ("", "https://api.anthropic.com", "https://api.anthropic.com/"),
         "Claude provider is not observably direct Anthropic: ANTHROPIC_BASE_URL is custom",
     )
-    return "provider\tclaude\tanthropic\nprovider_evidence\tcurrent-host-environment-default\n"
-
-
-def object_pairs(pairs: list[tuple[str, object]]) -> dict[str, object]:
-    result: dict[str, object] = {}
-    for key, value in pairs:
-        require(key not in result, f"duplicate JSON field: {key}")
-        result[key] = value
-    return result
-
-
-def invalid_constant(value: str) -> object:
-    raise ReviewError(f"invalid JSON constant: {value}")
-
-
-def json_object(text: str) -> dict[str, object]:
-    try:
-        value: object = json.loads(
-            text, object_pairs_hook=object_pairs, parse_constant=invalid_constant
-        )
-    except (ValueError, RecursionError) as exc:
-        raise ReviewError(f"invalid JSON: {exc}") from exc
-    if not isinstance(value, dict):
-        raise ReviewError("JSON root must be an object")
-    return {str(key): item for key, item in value.items()}
+    return serialize(
+        {
+            "provider": {"host": "claude", "provider": "anthropic"},
+            "provider_evidence": "current-host-environment-default",
+        }
+    )
 
 
 def assistant_observation(
@@ -84,7 +64,7 @@ def assistant_observation(
 def observe_transcript(path: Path, agent: str) -> tuple[str, str]:
     observations = []
     for number, line in enumerate(read_text(path, "transcript").splitlines(), 1):
-        row = json_object(line)
+        row = document(line)
         if row.get("type") == "assistant":
             observations.append(assistant_observation(row, agent, number))
     require(observations, "no assistant observations")
@@ -134,17 +114,22 @@ def verify(repo: str, agent: str, projects: str = "", record: str = "") -> str:
         f"unsupported reviewer effort: {effort}",
     )
     body = serialize(
-        [
-            ["format", "darrow-review-claude-route-v1"],
-            ["agent_id", agent],
-            ["transcript", str(transcript)],
-            ["provider_evidence", "current-host-environment-default"],
-            ["observed_route", "claude", "anthropic", model, effort],
-        ]
+        {
+            "format": "darrow-review-claude-route-v3",
+            "agent_id": agent,
+            "transcript": str(transcript),
+            "provider_evidence": "current-host-environment-default",
+            "observed_route": {
+                "host": "claude",
+                "provider": "anthropic",
+                "model": model,
+                "effort": effort,
+            },
+        }
     )
     if not record:
         return body
     path = new_record(record, body)
     return serialize(
-        [["format", "darrow-reviewer-record-location-v1"], ["record", str(path)]]
+        {"format": "darrow-reviewer-record-location-v3", "record": str(path)}
     )
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/records.py b/plugins/capability/darrow-review/backend/src/darrow_review/records.py
index c8c37f51..1154432f 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/records.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/records.py
@@ -1,147 +1,24 @@
-"""Strict TSV shapes shared by the four review protocols."""
+"""Semantic validation of schema-checked review documents."""
 
 from __future__ import annotations
 
-import re
-from collections import defaultdict
-from dataclasses import dataclass
 from pathlib import Path
+from typing import cast
 
-from .common import ReviewError, rows
-
-AXIS = "standards|spec"
-SEVERITY = "critical|high|medium|low"
-DISPOSITION = "blocking|advisory"
-STATUS = "pass|fail|blocked"
-
-
-@dataclass(frozen=True)
-class Shape:
-    sizes: tuple[int, ...] = (2,)
-    patterns: tuple[tuple[int, str, str], ...] = ()
-    optional: tuple[int, ...] = ()
-
-
-SIMPLE = Shape()
-CHECK = Shape(
-    (5,), ((2, "applicable|not_applicable", "check applicability is invalid"),)
-)
-FINDING = Shape(
-    (7, 9),
-    (
-        (1, AXIS, "finding axis must be standards or spec"),
-        (2, SEVERITY, "finding severity is invalid"),
-        (3, DISPOSITION, "finding disposition is invalid"),
-    ),
-)
-ATTEMPT = Shape((5,))
-ORIGINAL = Shape(
-    (9, 11),
-    (
-        (2, AXIS, "original finding axis is invalid"),
-        (3, "[1-9][0-9]*", "original finding order must be a positive integer"),
-        (4, SEVERITY, "original finding severity is invalid"),
-        (5, DISPOSITION, "original finding disposition is invalid"),
-    ),
-)
-REGRESSION = Shape(
-    (11, 13),
-    (
-        (3, "[1-9][0-9]*", "regression order must be a positive integer"),
-        (4, AXIS, "regression axis is invalid"),
-        (5, SEVERITY, "regression severity is invalid"),
-    ),
-)
-
-RESULT_SHAPES = dict.fromkeys(
-    (
-        "format",
-        "base",
-        "target",
-        "changed_file",
-        "standards_source",
-        "spec_source",
-        "risk",
-        "next_action",
-    ),
-    SIMPLE,
-) | {
-    "standards": Shape(
-        patterns=((1, STATUS, "standards must be pass, fail, or blocked"),)
-    ),
-    "spec": Shape(
-        patterns=(
-            (
-                1,
-                STATUS + "|not_available",
-                "spec must be pass, fail, blocked, or not_available",
-            ),
-        )
-    ),
-    "verdict": Shape(patterns=((1, STATUS, "verdict must be pass, fail, or blocked"),)),
-    "finding": FINDING,
-    "check": CHECK,
-}
-VERIFICATION_SHAPES = dict.fromkeys(
-    (
-        "format",
-        "original_target",
-        "prior_target",
-        "current_target",
-        "history_target",
-        "evidence_gap",
-        "next_action",
-    ),
-    SIMPLE,
-) | {
-    "previous_verification": Shape((3,)),
-    "original_finding": ORIGINAL,
-    "attempt": ATTEMPT,
-    "regression": REGRESSION,
-    "check": CHECK,
-    "outcome": Shape(
-        patterns=(
-            (
-                1,
-                "clear|continue|no_progress|blocked",
-                "outcome must be clear, continue, no_progress, or blocked",
-            ),
-        )
-    ),
-}
-AXIS_SHAPES = {
-    "format": SIMPLE,
-    "axis": Shape(patterns=((1, AXIS, "axis is invalid"),)),
-    "status": Shape(patterns=((1, STATUS, "status is invalid"),)),
-    "source": SIMPLE,
-    "finding": Shape(
-        (6, 8),
-        (
-            (1, SEVERITY, "finding severity is invalid"),
-            (2, DISPOSITION, "finding disposition is invalid"),
-        ),
-    ),
-}
-FIX_SHAPES = {
-    "format": SIMPLE,
-    "axis": AXIS_SHAPES["axis"],
-    "original": SIMPLE,
-    "prior_regression": Shape((3,)),
-    "attempt": ATTEMPT,
-    "regression_attempt": ATTEMPT,
-    "evidence_gap": SIMPLE,
-    "regression": Shape((6, 8), ((2, SEVERITY, "new regression severity is invalid"),)),
-}
+from .common import ReviewError, document
+from .schema import validate as validate_schema
+
+Record = dict[str, str]
 
 
 class Records:
     def __init__(self, text: str) -> None:
-        self.rows = rows(text)
-        self.by_kind: dict[str, list[list[str]]] = defaultdict(list)
-        for row in self.rows:
-            self.by_kind[row[0]].append(row)
+        self.data = document(text)
         self.errors: list[str] = []
 
+    def shape(self, format_name: str) -> None:
+        validate_schema(self.data, format_name)
+
     def check(self, condition: object, message: str) -> None:
         if not condition:
             self.errors.append(message)
@@ -150,70 +27,50 @@ def finish(self) -> None:
         if self.errors:
             raise ReviewError("\nreview-result: ".join(self.errors), 4)
 
-    def get(self, kind: str) -> list[list[str]]:
-        return self.by_kind.get(kind, [])
+    def value(self, name: str) -> str:
+        return cast(str, self.data.get(name, ""))
 
-    def value(self, kind: str, index: int = 1) -> str:
-        records = self.get(kind)
-        return records[0][index] if records else ""
+    def object(self, name: str) -> Record:
+        return cast(Record, self.data[name])
 
-    def exactly(self, *kinds: str) -> None:
-        for kind in kinds:
-            self.check(
-                len(self.get(kind)) == 1, f"exactly one {kind} record is required"
-            )
+    def strings(self, name: str) -> list[str]:
+        return cast(list[str], self.data.get(name, []))
+
+    def items(self, name: str) -> list[Record]:
+        return cast(list[Record], self.data.get(name, []))
 
-    def at_least(self, kind: str, message: str = "") -> None:
-        self.check(self.get(kind), message or f"at least one {kind} record is required")
+    def at_least(self, name: str, message: str = "") -> None:
+        self.check(self.data.get(name), message or f"at least one {name} is required")
 
-    def keyed(self, kind: str, index: int = 1, label: str = "") -> dict[str, list[str]]:
-        result: dict[str, list[str]] = {}
-        for row in self.get(kind):
-            key = row[index]
-            self.check(key not in result, f"duplicate {label or kind + ' key'}: {key}")
-            result[key] = row
+    def keyed(
+        self, name: str, field: str = "key", label: str = ""
+    ) -> dict[str, Record]:
+        result: dict[str, Record] = {}
+        for item in self.items(name):
+            key = item[field]
+            self.check(key not in result, f"duplicate {label or name + ' key'}: {key}")
+            result[key] = item
         return result
 
-    def shape(
-        self, format_name: str, shapes: dict[str, Shape], label: str = ""
-    ) -> None:
-        self.check(
-            self.rows and self.rows[0] == ["format", format_name],
-            f"first record must be format<TAB>{format_name}",
-        )
-        for line, row in enumerate(self.rows, 1):
-            shape = shapes.get(row[0])
-            if shape is None:
-                self.check(False, f"unknown {label}record on line {line}: {row[0]}")
-            else:
-                self.row_shape(row, shape)
-        self.finish()  # Indexing in semantic validation requires complete rows.
-        self.exactly("format")
-
-    def row_shape(self, row: list[str], shape: Shape) -> None:
-        sizes = " or ".join(str(size) for size in shape.sizes)
-        self.check(len(row) in shape.sizes, f"{row[0]} record must have {sizes} fields")
-        for index, value in enumerate(row[1:], 1):
-            self.check(
-                value or index in shape.optional,
-                f"{row[0]} field {index} must not be empty",
-            )
-        for index, pattern, message in shape.patterns:
-            self.check(index < len(row) and re.fullmatch(pattern, row[index]), message)
+    def unique_strings(self, name: str, label: str = "") -> set[str]:
+        values = self.strings(name)
+        self.check(len(values) == len(set(values)), f"duplicate {label or name}")
+        return set(values)
 
 
 def check_records(records: Records) -> None:
     records.at_least(
-        "check", "at least one check or explicit not_applicable check is required"
+        "checks", "at least one check or explicit not_applicable check is required"
     )
-    for row in records.get("check"):
-        if row[2] == "applicable":
+    for check in records.items("checks"):
+        if check["applicability"] == "applicable":
             records.check(
-                row[3] in STATUS.split("|"), "applicable check status is invalid"
+                check["status"] in ("pass", "fail", "blocked"),
+                "applicable check status is invalid",
             )
         else:
             records.check(
-                row[3] == "not_applicable",
+                check["status"] == "not_applicable",
                 "not_applicable check must have not_applicable status",
             )
 
@@ -233,10 +90,10 @@ def state(records: Records, status: str, progress: str, label: str) -> None:
         )
 
 
-def blocking_source(records: Records, axis: str, finding: list[str]) -> None:
-    if axis == "spec" and finding[2] == "blocking":
+def blocking_source(records: Records, axis: str, finding: Record) -> None:
+    if axis == "spec" and finding["disposition"] == "blocking":
         records.check(
-            not finding[4].startswith(("none", "not_available", "heuristic:")),
+            not finding["source"].startswith(("none", "not_available", "heuristic:")),
             "blocking Spec finding must cite an originating requirement",
         )
 
@@ -253,17 +110,15 @@ def axis_status(records: Records, status: str, blocking: bool, label: str) -> No
 
 def validate_axis(text: str, expected: str) -> Records:
     result = Records(text)
-    result.shape("darrow-review-axis-v1", AXIS_SHAPES, "axis ")
-    result.exactly("axis", "status")
+    result.shape("darrow-review-axis-v3")
     result.check(result.value("axis") == expected, f"axis does not match {expected}")
-    result.at_least("source")
-    findings = result.get("finding")
+    findings = result.items("findings")
     for finding in findings:
         blocking_source(result, expected, finding)
     axis_status(
         result,
         result.value("status"),
-        any(row[2] == "blocking" for row in findings),
+        any(item["disposition"] == "blocking" for item in findings),
         "axis",
     )
     result.finish()
@@ -272,22 +127,15 @@ def validate_axis(text: str, expected: str) -> Records:
 
 def validate_result(text: str) -> Records:
     result = Records(text)
-    result.shape("darrow-review-result-v1", RESULT_SHAPES)
-    result.exactly(
-        "base", "target", "standards", "spec", "spec_source", "verdict", "next_action"
-    )
-    result.at_least("standards_source", "at least one standards_source is required")
-    result.at_least("risk")
+    result.shape("darrow-review-result-v3")
     check_records(result)
-    for row in result.get("changed_file"):
-        result.check(
-            Path(row[1]).is_absolute(), "changed_file must be an absolute path"
-        )
+    for path in result.strings("changed_files"):
+        result.check(Path(path).is_absolute(), "changed_file must be an absolute path")
     validate_result_axes(result)
     statuses = [
         result.value("standards"),
         result.value("spec"),
-        *[row[3] for row in result.get("check")],
+        *[item["status"] for item in result.items("checks")],
     ]
     expected = (
         "fail" if "fail" in statuses else "blocked" if "blocked" in statuses else "pass"
@@ -297,7 +145,7 @@ def validate_result(text: str) -> Records:
         f"verdict must be {expected} from axis and check statuses",
     )
     result.check(
-        result.get("changed_file") or result.value("verdict") == "blocked",
+        result.strings("changed_files") or result.value("verdict") == "blocked",
         "a non-blocked result requires at least one changed_file",
     )
     result.finish()
@@ -306,22 +154,22 @@ def validate_result(text: str) -> Records:
 
 def validate_result_axes(result: Records) -> None:
     for axis in ("standards", "spec"):
-        findings = [row for row in result.get("finding") if row[1] == axis]
+        findings = [item for item in result.items("findings") if item["axis"] == axis]
         axis_status(
             result,
             result.value(axis),
-            any(row[3] == "blocking" for row in findings),
+            any(item["disposition"] == "blocking" for item in findings),
             axis.title() + " axis",
         )
-        for row in findings:
-            blocking_source(result, axis, ["finding", *row[2:]])
+        for item in findings:
+            blocking_source(result, axis, item)
     if result.value("spec") == "not_available":
         result.check(
             result.value("spec_source") == "not_available",
             "not_available Spec axis requires spec_source=not_available",
         )
         result.check(
-            not any(row[1] == "spec" for row in result.get("finding")),
+            not any(item["axis"] == "spec" for item in result.items("findings")),
             "not_available Spec axis must not contain Spec findings",
         )
     else:
@@ -333,47 +181,47 @@ def validate_result_axes(result: Records) -> None:
 
 def closed_attempts(
     records: Records,
-    originals: dict[str, list[str]],
-    attempts: dict[str, list[str]],
+    originals: set[str],
+    attempts: dict[str, Record],
     *,
     regression: bool = False,
 ) -> None:
     kind = "regression_attempt" if regression else "attempt"
     subject = "prior regression" if regression else "original finding"
-    for key, row in attempts.items():
+    for key, item in attempts.items():
         records.check(
             key in originals, f"{kind} references an unknown {subject}: {key}"
         )
-        state(records, row[2], row[3], kind)
+        state(records, item["status"], item["progress"], kind)
     for key in originals:
         records.check(
-            key in attempts or records.get("evidence_gap"),
+            key in attempts or records.strings("evidence_gaps"),
             f"{subject} is missing its fix-axis attempt: {key}",
         )
 
 
 def validate_fix_axis(text: str, expected: str) -> Records:
     result = Records(text)
-    result.shape("darrow-review-fix-axis-v1", FIX_SHAPES, "fix-axis ")
-    result.exactly("axis")
+    result.shape("darrow-review-fix-axis-v3")
     result.check(result.value("axis") == expected, f"axis does not match {expected}")
     actions = sum(
-        len(result.get(kind))
-        for kind in ("attempt", "regression_attempt", "regression", "evidence_gap")
+        len(result.strings(name))
+        if name == "evidence_gaps"
+        else len(result.items(name))
+        for name in ("attempts", "regression_attempts", "regressions", "evidence_gaps")
     )
     result.check(actions, "at least one action or evidence gap is required")
-    originals, attempts = result.keyed("original"), result.keyed("attempt")
+    originals = result.unique_strings("originals", "original finding key")
+    attempts = result.keyed("attempts", label="attempt finding key")
     closed_attempts(result, originals, attempts)
+    prior = result.keyed("prior_regressions", label="prior regression key")
     closed_attempts(
-        result,
-        result.keyed("prior_regression", label="prior regression key"),
-        result.keyed("regression_attempt"),
-        regression=True,
+        result, set(prior), result.keyed("regression_attempts"), regression=True
     )
-    for row in result.get("regression"):
+    for item in result.items("regressions"):
         result.check(
-            row[1] in attempts,
-            f"new regression cause is not an attempted original finding: {row[1]}",
+            item["caused_by"] in attempts,
+            f"new regression cause is not an attempted original finding: {item['caused_by']}",
         )
     result.finish()
     return result
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/report.py b/plugins/capability/darrow-review/backend/src/darrow_review/report.py
index 083c3745..652f3259 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/report.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/report.py
@@ -27,22 +27,27 @@
 
 
 def escape(value: str) -> str:
-    return value.translate(ESCAPES)
+    return (
+        value.translate(ESCAPES)
+        .replace("\r", "\\r")
+        .replace("\n", "\\n")
+        .replace("\t", "\\t")
+    )
 
 
-def guidance(fields: list[str], prefix: str = "") -> str:
-    if not fields:
+def guidance(item: dict[str, str], prefix: str = "") -> str:
+    if "repair_guidance" not in item:
         return ""
     return (
-        f"\n{prefix}- **Repair guidance (advisory):** {escape(fields[0])}"
-        f"\n{prefix}- **Resolution evidence:** {escape(fields[1])}"
+        f"\n{prefix}- **Repair guidance (advisory):** {escape(item['repair_guidance'])}"
+        f"\n{prefix}- **Resolution evidence:** {escape(item['resolution_evidence'])}"
     )
 
 
 def checks(result: Records) -> str:
     return "\n".join(
-        f"- **{row[3].upper()}** ({escape(row[2])}) — {escape(row[1])}: {escape(row[4])}"
-        for row in result.get("check")
+        f"- **{row['status'].upper()}** ({escape(row['applicability'])}) — {escape(row['command'])}: {escape(row['evidence'])}"
+        for row in result.items("checks")
     )
 
 
@@ -50,23 +55,23 @@ def findings(result: Records) -> str:
     blocks = [
         templates.FINDING.substitute(
             index=index,
-            severity=row[2].upper(),
-            disposition=row[3].upper(),
-            axis=row[1].title(),
-            location=escape(row[4]),
-            source=escape(row[5]),
-            evidence=escape(row[6]),
-            guidance=guidance(row[7:]),
+            severity=row["severity"].upper(),
+            disposition=row["disposition"].upper(),
+            axis=row["axis"].title(),
+            location=escape(row["location"]),
+            source=escape(row["source"]),
+            evidence=escape(row["evidence"]),
+            guidance=guidance(row),
         )
-        for index, row in enumerate(result.get("finding"), 1)
+        for index, row in enumerate(result.items("findings"), 1)
     ]
     return "\n" + "\n\n".join(blocks) if blocks else "No findings."
 
 
 def comprehensive(result: Records) -> str:
     verdict = result.value("verdict")
-    total = len(result.get("finding"))
-    blocking = sum(row[3] == "blocking" for row in result.get("finding"))
+    total = len(result.items("findings"))
+    blocking = sum(row["disposition"] == "blocking" for row in result.items("findings"))
     return templates.COMPREHENSIVE.substitute(
         title=verdict.upper(),
         verdict=escape(verdict),
@@ -75,16 +80,16 @@ def comprehensive(result: Records) -> str:
         advisory=total - blocking,
         findings=findings(result),
         checks=checks(result),
-        risks="\n".join("- " + escape(row[1]) for row in result.get("risk")),
+        risks="\n".join("- " + escape(row) for row in result.strings("risks")),
         next_action=escape(result.value("next_action")),
         base=escape(result.value("base")),
         target=escape(result.value("target")),
         changed_files="".join(
-            "\n  - " + escape(row[1]) for row in result.get("changed_file")
+            "\n  - " + escape(row) for row in result.strings("changed_files")
         ),
         standards=escape(result.value("standards")),
         standards_sources="\n".join(
-            "  - " + escape(row[1]) for row in result.get("standards_source")
+            "  - " + escape(row) for row in result.strings("standards_sources")
         ),
         spec=escape(result.value("spec")),
         spec_source=escape(result.value("spec_source")),
@@ -92,23 +97,23 @@ def comprehensive(result: Records) -> str:
 
 
 def attempted_findings(result: Records) -> str:
-    originals = result.keyed("original_finding")
+    originals = result.keyed("original_findings")
     blocks = []
-    for index, row in enumerate(result.get("attempt"), 1):
-        original = originals[row[1]]
+    for index, row in enumerate(result.items("attempts"), 1):
+        original = originals[row["key"]]
         blocks.append(
             templates.ATTEMPT.substitute(
                 index=index,
-                identity=escape(row[1]),
-                status=row[2].upper(),
-                progress=row[3].upper(),
-                severity=original[4].upper(),
-                disposition=escape(original[5]),
-                location=escape(original[6]),
-                source=escape(original[7]),
-                original_evidence=escape(original[8]),
-                guidance=guidance(original[9:]),
-                current_evidence=escape(row[4]),
+                identity=escape(row["key"]),
+                status=row["status"].upper(),
+                progress=row["progress"].upper(),
+                severity=original["severity"].upper(),
+                disposition=escape(original["disposition"]),
+                location=escape(original["location"]),
+                source=escape(original["source"]),
+                original_evidence=escape(original["evidence"]),
+                guidance=guidance(original),
+                current_evidence=escape(row["evidence"]),
             )
         )
     return (
@@ -122,27 +127,26 @@ def repair_regressions(result: Records) -> str:
     blocks = [
         templates.REGRESSION.substitute(
             index=index,
-            identity=escape(row[1]),
-            status=row[6].upper(),
-            progress=row[7].upper(),
-            severity=row[5].upper(),
-            axis=escape(row[4]),
-            cause=escape(row[2]),
-            location=escape(row[8]),
-            source=escape(row[9]),
-            evidence=escape(row[10]),
-            guidance=guidance(row[11:]),
+            identity=escape(row["key"]),
+            status=row["status"].upper(),
+            progress=row["progress"].upper(),
+            severity=row["severity"].upper(),
+            axis=escape(row["axis"]),
+            cause=escape(row["caused_by"]),
+            location=escape(row["location"]),
+            source=escape(row["source"]),
+            evidence=escape(row["evidence"]),
+            guidance=guidance(row),
         )
-        for index, row in enumerate(result.get("regression"), 1)
+        for index, row in enumerate(result.items("regressions"), 1)
     ]
     return "\n" + "\n\n".join(blocks) if blocks else "No repair-caused regressions."
 
 
 def target_binding(result: Records) -> str:
-    history = result.get("history_target")
+    history = result.strings("history_targets")
     earlier_targets = (
-        "\n- **Earlier targets:**"
-        + "".join("\n  - " + escape(row[1]) for row in history)
+        "\n- **Earlier targets:**" + "".join("\n  - " + escape(row) for row in history)
         if history
         else ""
     )
@@ -150,38 +154,37 @@ def target_binding(result: Records) -> str:
         original=escape(result.value("original_target")),
         prior=escape(result.value("prior_target")),
         current=escape(result.value("current_target")),
-        checksum=escape(result.value("previous_verification")),
-        artifact=escape(result.value("previous_verification", 2)),
+        checksum=escape(result.object("previous_verification")["checksum"]),
+        artifact=escape(result.object("previous_verification")["path"]),
         earlier_targets=earlier_targets,
     )
 
 
 def closed_findings(result: Records) -> str:
     lines = []
-    for row in result.get("original_finding"):
-        escaped = [escape(field) for field in row]
+    for row in result.items("original_findings"):
         lines.append(
-            f"\n- {escaped[1]} — {escaped[2]} #{escaped[3]}, {escaped[4]}/{escaped[5]}; {escaped[6]}; source {escaped[7]}; {escaped[8]}"
-            + guidance(row[9:], "  ")
+            f"\n- {escape(row['key'])} — {escape(row['axis'])} #{escape(row['order'])}, {escape(row['severity'])}/{escape(row['disposition'])}; {escape(row['location'])}; source {escape(row['source'])}; {escape(row['evidence'])}"
+            + guidance(row, "  ")
         )
     return "".join(lines)
 
 
 def verification(result: Records) -> str:
-    statuses = Counter(row[2] for row in result.get("attempt"))
-    gaps = result.get("evidence_gap")
+    statuses = Counter(row["status"] for row in result.items("attempts"))
+    gaps = result.strings("evidence_gaps")
     return templates.VERIFICATION.substitute(
         title=result.value("outcome").upper(),
         outcome=escape(result.value("outcome")),
-        total=len(result.get("original_finding")),
+        total=len(result.items("original_findings")),
         resolved=statuses["resolved"],
         unresolved=statuses["unresolved"],
         blocked=statuses["blocked"],
-        regression_count=len(result.get("regression")),
+        regression_count=len(result.items("regressions")),
         attempted_findings=attempted_findings(result),
         regressions=repair_regressions(result),
         checks=checks(result),
-        evidence_gaps="\n".join("- " + escape(row[1]) for row in gaps)
+        evidence_gaps="\n".join("- " + escape(row) for row in gaps)
         if gaps
         else "No evidence gaps.",
         target_binding=target_binding(result),
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/result.py b/plugins/capability/darrow-review/backend/src/darrow_review/result.py
index 56039e8b..5bb28c3b 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/result.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/result.py
@@ -4,53 +4,59 @@
 
 import re
 import sys
-from collections import Counter
 from pathlib import Path
+from typing import Any, cast
 
 from . import scope
-from .common import ReviewError, read_text, require, rows
-from .records import Records, validate_axis, validate_fix_axis, validate_result
+from .common import ReviewError, document, read_text, require
+from .records import Record, Records, validate_axis, validate_fix_axis, validate_result
 from .verification import validate_verification
 
 
-def original_findings(original: Records) -> list[list[str]]:
+def original_findings(original: Records) -> list[Record]:
     return [
-        [
-            "original_finding",
-            f"{row[1]}:{order}:{original.value('target')}",
-            row[1],
-            str(order),
-            *row[2:],
-        ]
-        for order, row in enumerate(original.get("finding"), 1)
+        {
+            "key": f"{finding['axis']}:{order}:{original.value('target')}",
+            "axis": finding["axis"],
+            "order": str(order),
+            **{name: value for name, value in finding.items() if name != "axis"},
+        }
+        for order, finding in enumerate(original.items("findings"), 1)
     ]
 
 
-def scope_records(path: str) -> list[list[str]]:
+def scope_records(path: str) -> dict[str, object]:
     try:
         scope.show(path)
     except (ReviewError, OSError) as exc:
         raise ReviewError(f"cannot validate pinned scope: {path}", 4) from exc
-    records = rows(read_text(path))
-    selected = [row for row in records if row[0] in ("base", "target", "changed_file")]
-    counts = Counter(row[0] for row in selected)
-    declared = [row for row in records if row[0] == "changed_count"]
-    valid = counts["base"] == counts["target"] == 1 and counts["changed_file"] > 0
-    valid = valid and all(len(row) == 2 and row[1] for row in selected)
-    require(valid, f"invalid scope identity records: {path}", 4)
-    valid = len(declared) == 1 and len(declared[0]) == 2
-    valid = valid and bool(re.fullmatch("[1-9][0-9]*", declared[0][1]))
-    require(valid, f"invalid scope identity records: {path}", 4)
-    validate_scope_files(path, selected, counts["changed_file"], int(declared[0][1]))
-    return selected
+    records = document(read_text(path))
+    base, target, files, declared = (
+        records.get("base"),
+        records.get("target"),
+        records.get("changed_files"),
+        records.get("changed_count"),
+    )
+    require(
+        isinstance(base, str)
+        and bool(base)
+        and isinstance(target, str)
+        and bool(target)
+        and isinstance(files, list)
+        and bool(files)
+        and all(isinstance(file, str) and file for file in files)
+        and isinstance(declared, str)
+        and bool(re.fullmatch("[1-9][0-9]*", declared)),
+        f"invalid scope identity records: {path}",
+        4,
+    )
+    validate_scope_files(path, cast(list[str], files), int(cast(str, declared)))
+    return {"base": base, "target": target, "changed_files": files}
 
 
-def validate_scope_files(
-    path: str, selected: list[list[str]], count: int, declared: int
-) -> None:
-    files = [row[1] for row in selected if row[0] == "changed_file"]
+def validate_scope_files(path: str, files: list[Any], declared: int) -> None:
     require(
-        count == declared
+        len(files) == declared
         and len(files) == len(set(files))
         and all(Path(file).is_absolute() for file in files),
         f"invalid scope identity records: {path}",
@@ -61,11 +67,9 @@ def validate_scope_files(
 def validate_scope(path: str, result_path: str) -> str:
     expected = scope_records(path)
     result = validate_result(read_text(result_path, "result"))
-    actual = [
-        row for row in result.rows if row[0] in ("base", "target", "changed_file")
-    ]
+    actual = {name: result.data.get(name, []) for name in expected}
     require(
-        Counter(map(tuple, expected)) == Counter(map(tuple, actual)),
+        expected == actual,
         f"result base, target, or changed-file set differs from pinned scope: {path}",
         4,
     )
@@ -79,7 +83,7 @@ def validate_original(original_path: str, verification_path: str) -> str:
     )
     require(
         verification.value("original_target") == original.value("target")
-        and verification.get("original_finding") == original_findings(original),
+        and verification.items("original_findings") == original_findings(original),
         "verification changed the original target or complete ordered finding set",
         4,
     )
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/routing.py b/plugins/capability/darrow-review/backend/src/darrow_review/routing.py
index 2d7c4f76..6dac1da2 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/routing.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/routing.py
@@ -6,9 +6,11 @@
 import re
 from dataclasses import dataclass
 from pathlib import Path
+from typing import cast
 
 from .common import (
     ReviewError,
+    document,
     new_record,
     package_root,
     read_text,
@@ -16,9 +18,8 @@
     require,
     root_directory,
     serialize,
-    unique_records,
 )
-from .provider import direct, json_object
+from .provider import direct
 
 
 @dataclass(frozen=True)
@@ -32,6 +33,11 @@ class Route:
     def fields(self) -> list[str]:
         return [self.host, self.provider, self.model, self.effort]
 
+    def as_object(self) -> dict[str, str]:
+        return dict(
+            zip(("host", "provider", "model", "effort"), self.fields(), strict=True)
+        )
+
     def validate(self) -> None:
         require(
             (self.host, self.provider)
@@ -63,11 +69,11 @@ def strong(self) -> None:
 
     def body(self) -> str:
         return serialize(
-            [
-                ["format", "darrow-reviewer-route-v1"],
-                ["selected_route", *self.fields()],
-                ["route_source", self.source],
-            ]
+            {
+                "format": "darrow-reviewer-route-v3",
+                "selected_route": self.as_object(),
+                "route_source": self.source,
+            }
         )
 
 
@@ -101,7 +107,7 @@ def parse_reviewer(value: object, source: str) -> Route:
 
 
 def catalog(path: Path, source: str) -> dict[str, Route]:
-    config = json_object(read_text(path, "reviewer configuration"))
+    config = document(read_text(path, "reviewer configuration"))
     require(
         set(config) <= {"reviewers", "routes"},
         "invalid reviewer configuration: unknown root field",
@@ -147,23 +153,33 @@ def resolve(repo: str, host: str) -> Route:
 
 
 def load_route(path: str, expected_host: str = "") -> Route:
-    records = unique_records(record_file(path), "route")
+    records = document(record_file(path))
     require(
         set(records) == {"format", "selected_route", "route_source"},
         f"incomplete or duplicate route record: {path}",
     )
     require(
-        records["format"] == ["darrow-reviewer-route-v1"],
+        records["format"] == "darrow-reviewer-route-v3",
         f"invalid route format record: {path}",
     )
     fields = records["selected_route"]
-    require(len(fields) == 4 and all(fields), f"invalid selected route record: {path}")
     require(
-        records["route_source"] in (["bundled"], ["repository"]),
+        isinstance(fields, dict)
+        and set(fields) == {"host", "provider", "model", "effort"}
+        and all(isinstance(value, str) and value for value in fields.values()),
+        f"invalid selected route record: {path}",
+    )
+    require(
+        records["route_source"] in ("bundled", "repository"),
         f"invalid route source: {path}",
     )
+    selected = cast(dict[str, str], fields)
     route = Route(
-        fields[0], fields[1], fields[2], fields[3], records["route_source"][0]
+        selected["host"],
+        selected["provider"],
+        selected["model"],
+        selected["effort"],
+        cast(str, records["route_source"]),
     )
     route.validate()
     require(
@@ -177,14 +193,14 @@ def select(repo: str, host: str, record: str) -> str:
     route = resolve(repo, host)
     path = new_record(record, route.body())
     return serialize(
-        [
-            ["format", "darrow-reviewer-route-selection-v1"],
-            ["record", str(path)],
-            ["selected_route", *route.fields()],
-            ["route_source", route.source],
-            ["model", route.model],
-            ["reasoning_effort", route.effort],
-        ]
+        {
+            "format": "darrow-reviewer-route-selection-v3",
+            "record": str(path),
+            "selected_route": route.as_object(),
+            "route_source": route.source,
+            "model": route.model,
+            "reasoning_effort": route.effort,
+        }
     )
 
 
@@ -213,14 +229,14 @@ def claude_agent(route: Route) -> str:
         )
     validate_overrides(route)
     return serialize(
-        [
-            ["format", "darrow-review-claude-agent-v1"],
-            ["selected_route", *route.fields()],
-            ["subagent_type", "darrow-review:" + name],
-            ["model", route.model],
-            ["effort", route.effort],
-            ["agent_file", str(path)],
-        ]
+        {
+            "format": "darrow-review-claude-agent-v3",
+            "selected_route": route.as_object(),
+            "subagent_type": "darrow-review:" + name,
+            "model": route.model,
+            "effort": route.effort,
+            "agent_file": str(path),
+        }
     )
 
 
@@ -237,36 +253,50 @@ def validate_overrides(route: Route) -> None:
 
 
 def observed(path: str) -> tuple[Route, str]:
-    records = unique_records(record_file(path), "observed-route")
+    records = document(record_file(path))
     require(
         set(records)
         == {"format", "agent_id", "transcript", "provider_evidence", "observed_route"},
         f"incomplete or duplicate observed-route record: {path}",
     )
     require(
-        records["format"] == ["darrow-review-claude-route-v1"],
+        records["format"] == "darrow-review-claude-route-v3",
         f"invalid observed-route format: {path}",
     )
     for field in ("agent_id", "transcript", "provider_evidence"):
-        require(len(records[field]) == 1, f"invalid observed {field} record: {path}")
-    require(
-        re.fullmatch("[A-Za-z0-9]+", records["agent_id"][0]), "unsafe observed agent ID"
-    )
-    transcript = records["transcript"][0]
+        require(
+            isinstance(records[field], str) and records[field],
+            f"invalid observed {field} record: {path}",
+        )
+    agent_id = cast(str, records["agent_id"])
+    require(re.fullmatch("[A-Za-z0-9]+", agent_id), "unsafe observed agent ID")
+    transcript = cast(str, records["transcript"])
     require(
         Path(transcript).is_absolute(),
         f"observed transcript path is not absolute: {path}",
     )
     read_text(transcript, "observed transcript")
     require(
-        records["provider_evidence"] == ["current-host-environment-default"],
+        records["provider_evidence"] == "current-host-environment-default",
         f"invalid observed provider evidence: {path}",
     )
-    require(len(records["observed_route"]) == 4, f"invalid observed route: {path}")
-    route = Route(*records["observed_route"])
+    observed_route = records["observed_route"]
+    require(
+        isinstance(observed_route, dict)
+        and set(observed_route) == {"host", "provider", "model", "effort"}
+        and all(isinstance(value, str) and value for value in observed_route.values()),
+        f"invalid observed route: {path}",
+    )
+    fields = cast(dict[str, str], observed_route)
+    route = Route(
+        fields["host"],
+        fields["provider"],
+        fields["model"],
+        fields["effort"],
+    )
     route.validate()
     require(route.host == "claude", "observed route is not a Claude route")
-    return route, records["agent_id"][0]
+    return route, agent_id
 
 
 def confirm(
@@ -279,37 +309,33 @@ def confirm(
 ) -> str:
     require(axis in ("standards", "spec"), f"unsupported review axis: {axis}")
     route = load_route(route_path, "claude" if observed_path else "codex")
-    records = [
-        ["format", "darrow-reviewer-route-application-v1"],
-        ["selected_route", *route.fields()],
-    ]
+    records: dict[str, object] = {
+        "format": "darrow-reviewer-route-application-v3",
+        "selected_route": route.as_object(),
+    }
     if observed_path:
         actual, agent = observed(observed_path)
         require(
             actual.fields() == route.fields(),
             "selected reviewer route does not match transcript-observed route",
         )
-        records.extend(
-            [
-                ["observed_route", *actual.fields()],
-                ["provider_evidence", "current-host-environment-default"],
-            ]
-        )
+        records["observed_route"] = actual.as_object()
+        records["provider_evidence"] = "current-host-environment-default"
     else:
         require(
             re.fullmatch("[A-Za-z0-9._/@:-]+", agent),
             f"unsafe reviewer agent ID: {agent}",
         )
-        records.append(["requested_route", *route.fields()])
-    records.extend(
-        [
-            ["route_applied_by", "native-subagent"],
-            ["route_bound", "true"],
-            ["axis", axis],
-            ["agent_id", agent],
-        ]
+        records["requested_route"] = route.as_object()
+    records.update(
+        {
+            "route_applied_by": "native-subagent",
+            "route_bound": "true",
+            "axis": axis,
+            "agent_id": agent,
+        }
     )
     path = new_record(application, serialize(records))
     return serialize(
-        [["format", "darrow-reviewer-record-location-v1"], ["record", str(path)]]
+        {"format": "darrow-reviewer-record-location-v3", "record": str(path)}
     )
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/schema.py b/plugins/capability/darrow-review/backend/src/darrow_review/schema.py
new file mode 100644
index 00000000..53449a5a
--- /dev/null
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/schema.py
@@ -0,0 +1,324 @@
+"""Structural schemas for review judgments, checked with a small stdlib validator."""
+
+from __future__ import annotations
+
+import re
+from typing import Any, NoReturn
+
+from .common import ReviewError
+
+AXIS = "standards|spec"
+STATUS = "pass|fail|blocked"
+SEVERITY = "critical|high|medium|low"
+DISPOSITION = "blocking|advisory"
+
+
+def string(pattern: str = "") -> dict[str, Any]:
+    result: dict[str, Any] = {"type": "string", "minLength": 1}
+    if pattern:
+        result["pattern"] = f"^(?:{pattern})$"
+    return result
+
+
+def object_schema(
+    fields: tuple[str, ...],
+    *,
+    required: tuple[str, ...] | None = None,
+    patterns: dict[str, str] | None = None,
+    guidance: bool = False,
+) -> dict[str, Any]:
+    patterns = patterns or {}
+    result: dict[str, Any] = {
+        "type": "object",
+        "properties": {name: string(patterns.get(name, "")) for name in fields},
+        "required": list(required if required is not None else fields),
+        "additionalProperties": False,
+    }
+    if guidance:
+        result["dependentRequired"] = {
+            "repair_guidance": ["resolution_evidence"],
+            "resolution_evidence": ["repair_guidance"],
+        }
+    return result
+
+
+def array(item: dict[str, Any], minimum: int = 0) -> dict[str, Any]:
+    return {"type": "array", "items": item, "minItems": minimum}
+
+
+def document(
+    format_name: str,
+    properties: dict[str, dict[str, Any]],
+    required: tuple[str, ...],
+) -> dict[str, Any]:
+    return {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "type": "object",
+        "properties": {"format": {"const": format_name}, **properties},
+        "required": ["format", *required],
+        "additionalProperties": False,
+    }
+
+
+FINDING = object_schema(
+    (
+        "axis",
+        "severity",
+        "disposition",
+        "location",
+        "source",
+        "evidence",
+        "repair_guidance",
+        "resolution_evidence",
+    ),
+    required=("axis", "severity", "disposition", "location", "source", "evidence"),
+    patterns={"axis": AXIS, "severity": SEVERITY, "disposition": DISPOSITION},
+    guidance=True,
+)
+AXIS_FINDING = object_schema(
+    (
+        "severity",
+        "disposition",
+        "location",
+        "source",
+        "evidence",
+        "repair_guidance",
+        "resolution_evidence",
+    ),
+    required=("severity", "disposition", "location", "source", "evidence"),
+    patterns={"severity": SEVERITY, "disposition": DISPOSITION},
+    guidance=True,
+)
+ORIGINAL_FINDING = object_schema(
+    (
+        "key",
+        "axis",
+        "order",
+        "severity",
+        "disposition",
+        "location",
+        "source",
+        "evidence",
+        "repair_guidance",
+        "resolution_evidence",
+    ),
+    required=(
+        "key",
+        "axis",
+        "order",
+        "severity",
+        "disposition",
+        "location",
+        "source",
+        "evidence",
+    ),
+    patterns={
+        "axis": AXIS,
+        "order": "[1-9][0-9]*",
+        "severity": SEVERITY,
+        "disposition": DISPOSITION,
+    },
+    guidance=True,
+)
+CHECK = object_schema(
+    ("command", "applicability", "status", "evidence"),
+    patterns={"applicability": "applicable|not_applicable"},
+)
+ATTEMPT = object_schema(("key", "status", "progress", "evidence"))
+VERIFICATION_REGRESSION = object_schema(
+    (
+        "key",
+        "caused_by",
+        "order",
+        "axis",
+        "severity",
+        "status",
+        "progress",
+        "location",
+        "source",
+        "evidence",
+        "repair_guidance",
+        "resolution_evidence",
+    ),
+    required=(
+        "key",
+        "caused_by",
+        "order",
+        "axis",
+        "severity",
+        "status",
+        "progress",
+        "location",
+        "source",
+        "evidence",
+    ),
+    patterns={"order": "[1-9][0-9]*", "axis": AXIS, "severity": SEVERITY},
+    guidance=True,
+)
+
+SCHEMAS = {
+    "darrow-review-axis-v3": document(
+        "darrow-review-axis-v3",
+        {
+            "axis": string(AXIS),
+            "status": string(STATUS),
+            "sources": array(string(), 1),
+            "findings": array(AXIS_FINDING),
+        },
+        ("axis", "status", "sources"),
+    ),
+    "darrow-review-result-v3": document(
+        "darrow-review-result-v3",
+        {
+            "base": string(),
+            "target": string(),
+            "changed_files": array(string()),
+            "standards_sources": array(string(), 1),
+            "spec_source": string(),
+            "standards": string(STATUS),
+            "spec": string(STATUS + "|not_available"),
+            "verdict": string(STATUS),
+            "findings": array(FINDING),
+            "checks": array(CHECK, 1),
+            "risks": array(string(), 1),
+            "next_action": string(),
+        },
+        (
+            "base",
+            "target",
+            "standards_sources",
+            "spec_source",
+            "standards",
+            "spec",
+            "verdict",
+            "checks",
+            "risks",
+            "next_action",
+        ),
+    ),
+    "darrow-review-fix-axis-v3": document(
+        "darrow-review-fix-axis-v3",
+        {
+            "axis": string(AXIS),
+            "originals": array(string()),
+            "prior_regressions": array(object_schema(("key", "caused_by"))),
+            "attempts": array(ATTEMPT),
+            "regression_attempts": array(ATTEMPT),
+            "evidence_gaps": array(string()),
+            "regressions": array(
+                object_schema(
+                    (
+                        "caused_by",
+                        "severity",
+                        "location",
+                        "source",
+                        "evidence",
+                        "repair_guidance",
+                        "resolution_evidence",
+                    ),
+                    required=(
+                        "caused_by",
+                        "severity",
+                        "location",
+                        "source",
+                        "evidence",
+                    ),
+                    patterns={"severity": SEVERITY},
+                    guidance=True,
+                )
+            ),
+        },
+        ("axis",),
+    ),
+    "darrow-review-verification-v3": document(
+        "darrow-review-verification-v3",
+        {
+            "original_target": string(),
+            "prior_target": string(),
+            "current_target": string(),
+            "history_targets": array(string()),
+            "previous_verification": object_schema(("checksum", "path")),
+            "original_findings": array(ORIGINAL_FINDING),
+            "attempts": array(ATTEMPT),
+            "regressions": array(VERIFICATION_REGRESSION),
+            "checks": array(CHECK, 1),
+            "evidence_gaps": array(string()),
+            "outcome": string("clear|continue|no_progress|blocked"),
+            "next_action": string(),
+        },
+        (
+            "original_target",
+            "prior_target",
+            "current_target",
+            "previous_verification",
+            "checks",
+            "outcome",
+            "next_action",
+        ),
+    ),
+}
+
+
+def invalid(path: str, message: str) -> NoReturn:
+    raise ReviewError(f"invalid review JSON at {path}: {message}", 4)
+
+
+def validate_node(value: object, schema: dict[str, Any], path: str) -> None:
+    if "const" in schema and value != schema["const"]:
+        invalid(path, f"expected {schema['const']}")
+    kind = schema.get("type")
+    if kind == "string":
+        validate_string(value, schema, path)
+    elif kind == "array":
+        validate_array(value, schema, path)
+    elif kind == "object":
+        validate_object(value, schema, path)
+
+
+def validate_string(value: object, schema: dict[str, Any], path: str) -> None:
+    if not isinstance(value, str) or (schema.get("minLength") and not value):
+        invalid(path, "must be a nonempty string")
+    if "pattern" in schema and not re.fullmatch(schema["pattern"], value):
+        invalid(path, "value is not allowed")
+
+
+def validate_array(value: object, schema: dict[str, Any], path: str) -> None:
+    if not isinstance(value, list) or len(value) < schema.get("minItems", 0):
+        invalid(path, "must be an array of the required size")
+    for index, item in enumerate(value):
+        validate_node(item, schema["items"], f"{path}[{index}]")
+
+
+def validate_object(value: object, schema: dict[str, Any], path: str) -> None:
+    if not isinstance(value, dict):
+        invalid(path, "must be an object")
+    validate_required(value, schema["required"], path)
+    validate_properties(value, schema["properties"], path)
+    validate_dependencies(value, schema.get("dependentRequired", {}), path)
+
+
+def validate_required(value: dict[str, object], required: list[str], path: str) -> None:
+    for name in required:
+        if name not in value:
+            invalid(path, f"missing {name}")
+
+
+def validate_properties(
+    value: dict[str, object], properties: dict[str, dict[str, Any]], path: str
+) -> None:
+    for name, item in value.items():
+        if name not in properties:
+            invalid(path, f"unknown field {name}")
+        validate_node(item, properties[name], f"{path}.{name}")
+
+
+def validate_dependencies(
+    value: dict[str, object], dependencies: dict[str, list[str]], path: str
+) -> None:
+    for name, required in dependencies.items():
+        if name in value:
+            validate_required(value, required, path)
+
+
+def validate(value: dict[str, object], format_name: str) -> None:
+    validate_node(value, SCHEMAS[format_name], format_name)
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/scope.py b/plugins/capability/darrow-review/backend/src/darrow_review/scope.py
index 49fb58bd..e3610830 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/scope.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/scope.py
@@ -11,13 +11,13 @@
 from . import storage
 from .common import (
     command_line,
+    document,
     entrypoint,
     git,
     git_environment,
     read_text,
     require,
     root_directory,
-    rows,
     run,
     safe_line,
     serialize,
@@ -39,10 +39,10 @@ class ScopeOptions:
 
 def manifest(path: str) -> dict[str, str]:
     require(Path(path).is_absolute(), "manifest path must be absolute")
-    records = rows(read_text(path, "manifest"))
-    values = {row[0]: row[1] for row in records if len(row) == 2}
+    records = document(read_text(path, "manifest"))
+    values = {key: value for key, value in records.items() if isinstance(value, str)}
     require(
-        values.get("format") == "darrow-review-scope-v1",
+        values.get("format") == "darrow-review-scope-v3",
         "unsupported scope manifest format",
     )
     for key in ("repository", "diff"):
@@ -87,14 +87,14 @@ def compare(prior: str, current: str) -> str:
         "repair scope manifests do not share the same effective base",
     )
     header = serialize(
-        [
-            ["format", "darrow-review-repair-delta-v1"],
-            ["repository", old["repository"]],
-            ["prior_target", old["target"]],
-            ["current_target", new["target"]],
-            ["prior_manifest", prior],
-            ["current_manifest", current],
-        ]
+        {
+            "format": "darrow-review-repair-delta-v3",
+            "repository": old["repository"],
+            "prior_target": old["target"],
+            "current_target": new["target"],
+            "prior_manifest": prior,
+            "current_manifest": current,
+        }
     )
     delta = difflib.unified_diff(
         before.decode("utf-8", errors="replace").splitlines(True),
@@ -330,48 +330,38 @@ def write_scope(
     label = target
     if any((options.staged, options.unstaged, options.untracked)):
         label = f"WORKTREE@{target}+{checksum}"
-    path = str(artifact / "scope.tsv")
-    records = [
-        ["format", "darrow-review-scope-v1"],
-        ["repository", str(repo)],
-        ["base_input", options.base],
-        ["base", base],
-        ["target_input", options.target],
-        ["target_commit", target],
-        ["target", label],
-        ["merge_base", str(int(options.merge_base))],
-        ["layers", " ".join(layers)],
-        ["diff", str(diff)],
-        ["scope_checksum", checksum],
-        ["changed_count", str(len(names))],
-    ]
-    records.extend(["changed_file", str(repo / name)] for name in names)
-    records.append(
-        [
-            "show_command",
-            command_line(entrypoint("review-scope", "show", "--manifest", path)),
-        ]
-    )
+    path = str(artifact / "scope.json")
+    records: dict[str, object] = {
+        "format": "darrow-review-scope-v3",
+        "repository": str(repo),
+        "base_input": options.base,
+        "base": base,
+        "target_input": options.target,
+        "target_commit": target,
+        "target": label,
+        "merge_base": str(int(options.merge_base)),
+        "layers": " ".join(layers),
+        "diff": str(diff),
+        "scope_checksum": checksum,
+        "changed_count": str(len(names)),
+        "changed_files": [str(repo / name) for name in names],
+        "show_command": command_line(
+            entrypoint("review-scope", "show", "--manifest", path)
+        ),
+    }
     if options.prior_manifest:
-        records.extend(
-            [
-                ["prior_manifest", options.prior_manifest],
-                [
-                    "repair_show_command",
-                    command_line(
-                        entrypoint(
-                            "review-scope",
-                            "compare",
-                            "--prior-manifest",
-                            options.prior_manifest,
-                            "--current-manifest",
-                            path,
-                        )
-                    ),
-                ],
-            ]
+        records["prior_manifest"] = options.prior_manifest
+        records["repair_show_command"] = command_line(
+            entrypoint(
+                "review-scope",
+                "compare",
+                "--prior-manifest",
+                options.prior_manifest,
+                "--current-manifest",
+                path,
+            )
         )
-    records.append(["manifest", path])
+    records["manifest"] = path
     body = serialize(records)
     descriptor = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
     with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as stream:
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/storage.py b/plugins/capability/darrow-review/backend/src/darrow_review/storage.py
index 251ad386..1d5d6ffd 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/storage.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/storage.py
@@ -15,7 +15,7 @@
 from contextlib import contextmanager
 from pathlib import Path
 
-from .common import ReviewError, require, rows, safe_line
+from .common import ReviewError, document, require, safe_line, serialize
 
 RETENTION_DAYS = 30
 RUN_PREFIX = "darrow-review."
@@ -106,8 +106,10 @@ def allocate_terminal(repo: Path) -> Path:
     safe_line(str(repo), "repository path")
     run = allocate(repo)
     try:
-        manifest = run / "scope.tsv"
-        body = f"format\tdarrow-review-terminal-v1\nrepository\t{repo}\n"
+        manifest = run / "scope.json"
+        body = serialize(
+            {"format": "darrow-review-terminal-v3", "repository": str(repo)}
+        )
         descriptor = os.open(manifest, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
         with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as stream:
             stream.write(body)
@@ -120,10 +122,10 @@ def allocate_terminal(repo: Path) -> Path:
 
 def run_for_manifest(manifest: Path) -> Path:
     require(manifest.is_absolute(), "review manifest path must be absolute")
-    require(manifest.name == "scope.tsv", "review manifest must name scope.tsv")
+    require(manifest.name == "scope.json", "review manifest must name scope.json")
     fields = fields_at(manifest)
     require(
-        fields.get("format") in ("darrow-review-scope-v1", "darrow-review-terminal-v1"),
+        fields.get("format") in ("darrow-review-scope-v3", "darrow-review-terminal-v3"),
         "invalid review manifest",
     )
     repo = Path(fields.get("repository", ""))
@@ -144,7 +146,7 @@ def check_output(repo: Path, output: Path) -> Path:
     require(output.is_absolute(), "output must be an absolute path")
     require(output.name not in ("", ".", ".."), "output must name a file")
     path = output.parent.resolve(strict=True) / output.name
-    run = run_for_manifest(path.parent / "scope.tsv")
+    run = run_for_manifest(path.parent / "scope.json")
     require(
         run.parent == repository_state(repo, create=False),
         "output must be beneath this repository's review-state directory",
@@ -157,7 +159,9 @@ def fields_at(path: Path) -> dict[str, str]:
         content = path.read_text(encoding="utf-8")
     except (OSError, UnicodeError) as exc:
         raise ReviewError(f"review state is unreadable: {path}") from exc
-    return {row[0]: row[1] for row in rows(content) if len(row) == 2}
+    return {
+        key: value for key, value in document(content).items() if isinstance(value, str)
+    }
 
 
 def runs(bucket: Path) -> list[Path]:
@@ -168,6 +172,15 @@ def runs(bucket: Path) -> list[Path]:
     )
 
 
+def matches_v3_scope(candidate: Path, repo: Path, target: str) -> bool:
+    fields = fields_at(candidate)
+    return (
+        fields.get("format") == "darrow-review-scope-v3"
+        and fields.get("repository") == str(repo)
+        and fields.get("target") == target
+    )
+
+
 def locate(repo: Path, target: str) -> Path | None:
     root = Path(resolve_root(os.environ, os.name))
     if not root.exists() or not (root / repository_digest(repo)).exists():
@@ -177,11 +190,10 @@ def locate(repo: Path, target: str) -> Path | None:
     from . import scope
 
     for run in runs(bucket):
-        candidate = run / "scope.tsv"
+        candidate = run / "scope.json"
         if not candidate.is_file() or candidate.is_symlink():
             continue
-        fields = fields_at(candidate)
-        if fields.get("repository") != str(repo) or fields.get("target") != target:
+        if not matches_v3_scope(candidate, repo, target):
             continue
         scope.show(str(candidate))
         matches.append(candidate)
@@ -191,36 +203,34 @@ def locate(repo: Path, target: str) -> Path | None:
 
 def dependencies(run: Path, by_file: dict[Path, Path]) -> set[Path]:
     result: set[Path] = set()
-    for file, field, index in (
-        (run / "scope.tsv", "prior_manifest", 1),
-        (run / "verification.tsv", "previous_verification", 2),
+    for file, field in (
+        (run / "scope.json", "prior_manifest"),
+        (run / "verification.json", "previous_verification"),
     ):
-        result.update(references(file, field, index, by_file))
+        result.update(references(file, field, by_file))
     return result
 
 
-def references(
-    file: Path, field: str, index: int, by_file: dict[Path, Path]
-) -> set[Path]:
+def references(file: Path, field: str, by_file: dict[Path, Path]) -> set[Path]:
     if not file.is_file() or file.is_symlink():
         return set()
     try:
-        lines = rows(file.read_text(encoding="utf-8"))
+        data = document(file.read_text(encoding="utf-8"))
     except (OSError, UnicodeError) as exc:
         raise ReviewError(f"review dependency is unreadable: {file}") from exc
-    paths = (
-        by_file.get(Path(row[index]).resolve())
-        for row in lines
-        if len(row) > index and row[0] == field
-    )
-    return {path for path in paths if path is not None}
+    value = data.get(field)
+    path = value.get("path") if isinstance(value, dict) else value
+    if not isinstance(path, str) or path == "none":
+        return set()
+    owner = by_file.get(Path(path).resolve())
+    return {owner} if owner is not None else set()
 
 
 def retained_runs(all_runs: list[Path], cutoff: float) -> set[Path]:
     by_file = {
         run / name: run
         for run in all_runs
-        for name in ("scope.tsv", "verification.tsv")
+        for name in ("scope.json", "verification.json")
     }
     keep = {
         run
diff --git a/plugins/capability/darrow-review/backend/src/darrow_review/verification.py b/plugins/capability/darrow-review/backend/src/darrow_review/verification.py
index 215ac1c5..9f749ad9 100644
--- a/plugins/capability/darrow-review/backend/src/darrow_review/verification.py
+++ b/plugins/capability/darrow-review/backend/src/darrow_review/verification.py
@@ -5,14 +5,14 @@
 from pathlib import Path
 
 from .common import ReviewError, blob_hash, read_text, require
-from .records import VERIFICATION_SHAPES, Records, check_records, state
+from .records import Record, Records, check_records, state
 
 
-def originals(result: Records) -> dict[str, list[str]]:
-    findings = result.keyed("original_finding", label="original finding key")
-    result.keyed("original_finding", 3, "original finding order")
+def originals(result: Records) -> dict[str, Record]:
+    findings = result.keyed("original_findings", label="original finding key")
+    result.keyed("original_findings", "order", "original finding order")
     for key, row in findings.items():
-        expected = f"{row[2]}:{row[3]}:{result.value('original_target')}"
+        expected = f"{row['axis']}:{row['order']}:{result.value('original_target')}"
         result.check(
             key == expected,
             f"original finding key must be derived as axis:order:original_target: {expected}",
@@ -20,28 +20,30 @@ def originals(result: Records) -> dict[str, list[str]]:
     return findings
 
 
-def attempts(result: Records, findings: dict[str, list[str]]) -> dict[str, list[str]]:
-    actions = result.keyed("attempt", label="attempt finding key")
+def attempts(result: Records, findings: dict[str, Record]) -> dict[str, Record]:
+    actions = result.keyed("attempts", label="attempt finding key")
     for key, row in actions.items():
         result.check(
             key in findings, f"attempt references an unknown original finding: {key}"
         )
-        state(result, row[2], row[3], "attempt")
+        state(result, row["status"], row["progress"], "attempt")
     for key, finding in findings.items():
         result.check(
-            finding[5] != "blocking" or key in actions or result.get("evidence_gap"),
+            finding["disposition"] != "blocking"
+            or key in actions
+            or result.strings("evidence_gaps"),
             f"every blocking original finding requires one attempt: {key}",
         )
     return actions
 
 
 def regressions(
-    result: Records, findings: dict[str, list[str]], actions: dict[str, list[str]]
+    result: Records, findings: dict[str, Record], actions: dict[str, Record]
 ) -> None:
-    carried = result.keyed("regression", label="regression key")
-    result.keyed("regression", 3, "regression order")
+    carried = result.keyed("regressions", label="regression key")
+    result.keyed("regressions", "order", "regression order")
     for key, row in carried.items():
-        cause = row[2]
+        cause = row["caused_by"]
         result.check(
             cause in findings,
             f"regression caused_by references an unknown original finding: {cause}",
@@ -51,39 +53,41 @@ def regressions(
             f"regression caused_by references an unattempted original finding: {cause}",
         )
         result.check(
-            cause in findings and row[4] == findings[cause][2],
+            cause in findings and row["axis"] == findings[cause]["axis"],
             f"regression axis must match its causing original finding: {key}",
         )
-        expected = f"regression:{row[3]}:{cause}"
+        expected = f"regression:{row['order']}:{cause}"
         result.check(
             key == expected,
             f"regression key must be derived as regression:order:caused_by: {expected}",
         )
-        state(result, row[6], row[7], "regression")
+        state(result, row["status"], row["progress"], "regression")
 
 
 def outcome(
-    result: Records, findings: dict[str, list[str]], actions: dict[str, list[str]]
+    result: Records, findings: dict[str, Record], actions: dict[str, Record]
 ) -> str:
     states = [
-        (row[2], row[3])
+        (row["status"], row["progress"])
         for key, row in actions.items()
-        if key in findings and findings[key][5] == "blocking"
+        if key in findings and findings[key]["disposition"] == "blocking"
+    ]
+    regression_states = [
+        (row["status"], row["progress"]) for row in result.items("regressions")
     ]
-    regression_states = [(row[6], row[7]) for row in result.get("regression")]
     states += regression_states
-    checks = [row[3] for row in result.get("check")]
+    checks = [row["status"] for row in result.items("checks")]
     result.check(
         "fail" not in checks
         or any(status != "resolved" for status, _ in regression_states),
         "a failing deterministic check requires an unresolved or blocked repair-caused regression",
     )
     blocked = (
-        bool(result.get("evidence_gap"))
+        bool(result.strings("evidence_gaps"))
         or "blocked" in checks
         or any(s == "blocked" for s, _ in states)
     )
-    history = {row[1] for row in result.get("history_target")}
+    history = set(result.strings("history_targets"))
     history.update((result.value("prior_target"), result.value("original_target")))
     stagnant = (
         result.value("current_target") in history
@@ -102,19 +106,11 @@ def derive_outcome(blocked: bool, stagnant: bool, active: bool) -> str:
 
 def validate_verification(text: str, path: str = "-", depth: int = 0) -> Records:
     result = Records(text)
-    result.shape("darrow-review-verification-v1", VERIFICATION_SHAPES, "verification ")
-    result.exactly(
-        "original_target",
-        "prior_target",
-        "current_target",
-        "previous_verification",
-        "outcome",
-        "next_action",
-    )
+    result.shape("darrow-review-verification-v3")
     check_records(result)
-    result.keyed("history_target", label="history target")
+    result.unique_strings("history_targets", "history target")
     result.check(
-        result.get("original_finding") or result.get("evidence_gap"),
+        result.items("original_findings") or result.strings("evidence_gaps"),
         "at least one original_finding or evidence_gap is required",
     )
     findings = originals(result)
@@ -131,10 +127,8 @@ def validate_verification(text: str, path: str = "-", depth: int = 0) -> Records
 
 
 def validate_previous(result: Records, path: str, depth: int) -> None:
-    checksum, previous = (
-        result.value("previous_verification"),
-        result.value("previous_verification", 2),
-    )
+    previous_record = result.object("previous_verification")
+    checksum, previous = previous_record["checksum"], previous_record["path"]
     if "none" in (checksum, previous):
         first_verification(result, checksum, previous)
         return
@@ -180,7 +174,7 @@ def first_verification(result: Records, checksum: str, previous: str) -> None:
         4,
     )
     require(
-        not result.get("history_target"),
+        not result.strings("history_targets"),
         "first verification must not contain repair target history",
         4,
     )
@@ -191,8 +185,8 @@ def preserve_history(result: Records, prior: Records) -> None:
         result.value("original_target") == prior.value("original_target"),
         "original_target changed across verification artifacts",
     )
-    old = prior.keyed("original_finding")
-    current = result.keyed("original_finding")
+    old = prior.keyed("original_findings")
+    current = result.keyed("original_findings")
     for key, row in current.items():
         result.check(
             key in old, f"new original finding appeared in later verification: {key}"
@@ -210,13 +204,17 @@ def preserve_history(result: Records, prior: Records) -> None:
     preserve_targets(result, prior)
 
 
-def immutable_regression(row: list[str]) -> list[str]:
-    return row[2:6] + row[8:10] + row[11:]
+def immutable_regression(row: Record) -> Record:
+    return {
+        key: value
+        for key, value in row.items()
+        if key not in ("status", "progress", "evidence")
+    }
 
 
 def preserve_regressions(result: Records, prior: Records) -> None:
-    current = result.keyed("regression")
-    for key, row in prior.keyed("regression").items():
+    current = result.keyed("regressions")
+    for key, row in prior.keyed("regressions").items():
         result.check(
             key in current,
             f"prior regression is missing from current verification: {key}",
@@ -229,10 +227,8 @@ def preserve_regressions(result: Records, prior: Records) -> None:
 
 
 def preserve_targets(result: Records, prior: Records) -> None:
-    expected = {row[1] for row in prior.get("history_target")} | {
-        prior.value("prior_target")
-    }
-    current = {row[1] for row in result.get("history_target")}
+    expected = set(prior.strings("history_targets")) | {prior.value("prior_target")}
+    current = set(result.strings("history_targets"))
     for target in expected - current:
         result.check(
             False, f"prior repair target is missing from target history: {target}"
diff --git a/plugins/capability/darrow-review/backend/tests/evals/assert_guidance.py b/plugins/capability/darrow-review/backend/tests/evals/assert_guidance.py
new file mode 100644
index 00000000..8f67d92d
--- /dev/null
+++ b/plugins/capability/darrow-review/backend/tests/evals/assert_guidance.py
@@ -0,0 +1,94 @@
+"""Compare aggregate guidance with reader-authored JSON fields."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from assert_records import load
+
+GUIDANCE = ("repair_guidance", "resolution_evidence")
+REGRESSION_FIELDS = (
+    "caused_by",
+    "severity",
+    "location",
+    "source",
+    "evidence",
+    *GUIDANCE,
+)
+
+
+def shape(kind: str) -> tuple[str, str, tuple[str, ...]]:
+    if kind == "finding":
+        return (
+            "darrow-review-axis-v3",
+            "findings",
+            (
+                "axis",
+                "severity",
+                "disposition",
+                "location",
+                "source",
+                "evidence",
+                *GUIDANCE,
+            ),
+        )
+    if kind == "regression":
+        return "darrow-review-fix-axis-v3", "regressions", REGRESSION_FIELDS
+    raise ValueError(f"unknown guidance kind: {kind}")
+
+
+def entries(record: dict[str, object], name: str) -> list[dict[str, object]]:
+    value = record.get(name)
+    if not isinstance(value, list) or any(not isinstance(item, dict) for item in value):
+        raise ValueError(f"invalid {name} array")
+    return value
+
+
+def projected(item: dict[str, object], fields: tuple[str, ...]) -> dict[str, object]:
+    return {name: item.get(name) for name in fields}
+
+
+def complete(aggregate: list[dict[str, object]], kind: str) -> None:
+    if not aggregate or any(
+        any(
+            not isinstance(item.get(field), str) or not item[field]
+            for field in GUIDANCE
+        )
+        for item in aggregate
+    ):
+        raise ValueError(f"aggregate has incomplete {kind} guidance")
+
+
+def reader_entries(
+    aggregate_path: Path, name: str, format_name: str
+) -> list[dict[str, object]]:
+    readers = []
+    for path in aggregate_path.parent.glob("*.json"):
+        candidate = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(candidate, dict) or candidate.get("format") != format_name:
+            continue
+        for item in entries(candidate, name):
+            readers.append({"axis": candidate.get("axis"), **item})
+    return readers
+
+
+def check(aggregate_path: Path, kind: str) -> None:
+    format_name, name, fields = shape(kind)
+    aggregate = entries(load(aggregate_path), name)
+    complete(aggregate, kind)
+    readers = [
+        projected(item, fields)
+        for item in reader_entries(aggregate_path, name, format_name)
+    ]
+    for item in aggregate:
+        if projected(item, fields) not in readers:
+            raise ValueError(f"aggregate {kind} guidance differs from a reader")
+
+
+if __name__ == "__main__":
+    try:
+        check(Path(sys.argv[1]), sys.argv[2])
+    except (IndexError, OSError, ValueError) as exc:
+        raise SystemExit(str(exc)) from exc
diff --git a/plugins/capability/darrow-review/backend/tests/evals/assert_records.py b/plugins/capability/darrow-review/backend/tests/evals/assert_records.py
new file mode 100644
index 00000000..6f450072
--- /dev/null
+++ b/plugins/capability/darrow-review/backend/tests/evals/assert_records.py
@@ -0,0 +1,88 @@
+"""Check named fields in hidden review eval JSON artifacts."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROUTE_FIELDS = ("host", "provider", "model", "effort")
+
+
+def load(path: Path) -> dict[str, object]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict) or not value:
+        raise ValueError(f"{path} must contain a JSON object")
+    return value
+
+
+def expected(fields: list[str]) -> tuple[str, object]:
+    if len(fields) == 2:
+        return fields[0], fields[1]
+    if len(fields) == 5 and fields[0].endswith("_route"):
+        return fields[0], {
+            field: fields[index + 1] for index, field in enumerate(ROUTE_FIELDS)
+        }
+    raise ValueError(f"invalid field assertion: {fields!r}")
+
+
+def exact(record: dict[str, object], operation: str, fields: list[str]) -> None:
+    key, value = expected(fields)
+    if (record.get(key) == value) != (operation == "has"):
+        raise ValueError(f"{operation} failed for {fields!r}")
+
+
+def lacks_key(record: dict[str, object], fields: list[str]) -> None:
+    if len(fields) != 1:
+        raise ValueError("lacks-key needs one field")
+    name = fields[0]
+    if name in record and record[name] != []:
+        raise ValueError(f"unexpected field: {name}")
+
+
+def strings(value: object) -> list[str]:
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, dict):
+        return [part for item in value.values() for part in strings(item)]
+    if isinstance(value, list):
+        return [part for item in value for part in strings(item)]
+    return []
+
+
+def contains(record: dict[str, object], operation: str, fields: list[str]) -> None:
+    if len(fields) != 1:
+        raise ValueError(f"{operation} needs one field")
+    present = any(fields[0] in field for field in strings(record))
+    if present != (operation == "contains"):
+        raise ValueError(f"{operation} failed for {fields[0]!r}")
+
+
+def value(record: dict[str, object], fields: list[str]) -> str:
+    if len(fields) != 1 or not isinstance(record.get(fields[0]), str):
+        raise ValueError(f"expected one string field: {fields!r}")
+    return str(record[fields[0]])
+
+
+def check(path: Path, operation: str, fields: list[str]) -> str | None:
+    record = load(path)
+    if operation in ("has", "lacks"):
+        exact(record, operation, fields)
+    elif operation == "lacks-key":
+        lacks_key(record, fields)
+    elif operation in ("contains", "not-contains"):
+        contains(record, operation, fields)
+    elif operation == "value":
+        return value(record, fields)
+    else:
+        raise ValueError(f"invalid record operation: {operation} {fields!r}")
+    return None
+
+
+if __name__ == "__main__":
+    try:
+        result = check(Path(sys.argv[1]), sys.argv[2], sys.argv[3:])
+        if result is not None:
+            print(result)
+    except (IndexError, OSError, ValueError) as exc:
+        raise SystemExit(str(exc)) from exc
diff --git a/plugins/capability/darrow-review/backend/tests/evals/eval_routes.py b/plugins/capability/darrow-review/backend/tests/evals/eval_routes.py
index 608d6fc3..d9dfeba8 100644
--- a/plugins/capability/darrow-review/backend/tests/evals/eval_routes.py
+++ b/plugins/capability/darrow-review/backend/tests/evals/eval_routes.py
@@ -8,14 +8,29 @@
 from typing import Any
 
 
+def unique(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for name, value in pairs:
+        assert name not in result, f"duplicate JSON field: {name}"
+        result[name] = value
+    return result
+
+
 def row(path: Path, key: str) -> list[str]:
-    matches = [
-        line.split("\t")[1:]
-        for line in path.read_text(encoding="utf-8").splitlines()
-        if line.split("\t")[0] == key
-    ]
-    assert len(matches) == 1, f"{path}: expected one {key}"
-    return matches[0]
+    record = json.loads(path.read_text(encoding="utf-8"), object_pairs_hook=unique)
+    assert isinstance(record, dict) and key in record, f"{path}: expected one {key}"
+    value = record[key]
+    if isinstance(value, str):
+        return [value]
+    assert isinstance(value, dict) and set(value) == {
+        "host",
+        "provider",
+        "model",
+        "effort",
+    }, f"{path}: invalid {key}"
+    fields = [value[name] for name in ("host", "provider", "model", "effort")]
+    assert all(isinstance(field, str) for field in fields)
+    return fields
 
 
 def route(host: str, profile: str) -> list[str]:
@@ -32,7 +47,7 @@ def identities(directory: Path, axes: list[str], expected: list[str]) -> dict[st
     field = "requested_route" if expected[0] == "codex" else "observed_route"
     result = {}
     for axis in axes:
-        path = directory / f"{axis}-route.tsv"
+        path = directory / f"{axis}-route.json"
         assert row(path, "axis") == [axis]
         assert row(path, field) == expected
         assert row(path, "route_bound") == ["true"]
@@ -41,7 +56,7 @@ def identities(directory: Path, axes: list[str], expected: list[str]) -> dict[st
         result[axis] = agent[0]
     assert len(set(result.values())) == len(axes), "reader identities must be distinct"
     if axes == ["standards"]:
-        assert not (directory / "spec-route.tsv").exists()
+        assert not (directory / "spec-route.json").exists()
     return result
 
 
@@ -126,7 +141,7 @@ def claude_evidence(
     assert len(launches) == len(agents)
     batches = []
     for axis, agent in agents.items():
-        observed = directory / f"{axis}-observed-route.tsv"
+        observed = directory / f"{axis}-observed-route.json"
         assert row(observed, "agent_id") == [agent]
         assert row(observed, "observed_route") == expected
         verify_provider(directory, axis, len(agents))
@@ -144,7 +159,7 @@ def claude_evidence(
 def verify_provider(directory: Path, axis: str, count: int) -> None:
     if count > 1:
         for suffix in ("route", "observed-route"):
-            assert row(directory / f"{axis}-{suffix}.tsv", "provider_evidence") == [
+            assert row(directory / f"{axis}-{suffix}.json", "provider_evidence") == [
                 "current-host-environment-default"
             ]
 
@@ -157,7 +172,7 @@ def verify(
     review_state: Path | None = None,
 ) -> None:
     review_root = review_state if review_state is not None else git_dir
-    selections = sorted(review_root.glob("**/darrow-review.*/reviewer-route.tsv"))
+    selections = sorted(review_root.glob("**/darrow-review.*/reviewer-route.json"))
     assert selections, "missing reviewer route"
     directory = selections[-1].parent
     expected = route(host, profile)
diff --git a/plugins/capability/darrow-review/backend/tests/evals/test_assert_guidance.py b/plugins/capability/darrow-review/backend/tests/evals/test_assert_guidance.py
new file mode 100644
index 00000000..9b87c323
--- /dev/null
+++ b/plugins/capability/darrow-review/backend/tests/evals/test_assert_guidance.py
@@ -0,0 +1,72 @@
+"""Aggregate guidance comparisons preserve full JSON field values."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+from assert_guidance import check
+
+
+def test_finding_guidance_distinguishes_newline_from_escape(tmp_path: Path) -> None:
+    finding = {
+        "severity": "high",
+        "disposition": "blocking",
+        "location": "src/a:1",
+        "source": "requirement",
+        "evidence": "evidence",
+        "repair_guidance": "repair\nstep",
+        "resolution_evidence": "resolved",
+    }
+    reader = {"format": "darrow-review-axis-v3", "axis": "spec", "findings": [finding]}
+    aggregate_finding = {"axis": "spec", **finding}
+    aggregate = {"format": "darrow-review-result-v3", "findings": [aggregate_finding]}
+    (tmp_path / "spec-axis.json").write_text(json.dumps(reader), encoding="utf-8")
+    (tmp_path / "proof.json").write_text(
+        json.dumps({"format": "other"}), encoding="utf-8"
+    )
+    result = tmp_path / "result.json"
+    result.write_text(json.dumps(aggregate), encoding="utf-8")
+    check(result, "finding")
+    aggregate_finding["repair_guidance"] = "repair\\nstep"
+    result.write_text(json.dumps(aggregate), encoding="utf-8")
+    with pytest.raises(ValueError, match="differs from a reader"):
+        check(result, "finding")
+
+
+def test_regression_guidance_keeps_reader_fields(tmp_path: Path) -> None:
+    regression = {
+        "caused_by": "spec:1:T",
+        "severity": "high",
+        "location": "src/a:2",
+        "source": "source",
+        "evidence": "evidence",
+        "repair_guidance": "fix\tstep",
+        "resolution_evidence": "resolution",
+    }
+    reader = {
+        "format": "darrow-review-fix-axis-v3",
+        "axis": "spec",
+        "regressions": [regression],
+    }
+    aggregate_regression = {
+        "key": "regression:1:spec:1:T",
+        "order": "1",
+        "axis": "spec",
+        "status": "unresolved",
+        "progress": "progressing",
+        **regression,
+    }
+    aggregate = {
+        "format": "darrow-review-verification-v3",
+        "regressions": [aggregate_regression],
+    }
+    (tmp_path / "spec-fix-axis.json").write_text(json.dumps(reader), encoding="utf-8")
+    result = tmp_path / "verification.json"
+    result.write_text(json.dumps(aggregate), encoding="utf-8")
+    check(result, "regression")
+    aggregate_regression["repair_guidance"] = "fix\\tstep"
+    result.write_text(json.dumps(aggregate), encoding="utf-8")
+    with pytest.raises(ValueError, match="differs from a reader"):
+        check(result, "regression")
diff --git a/plugins/capability/darrow-review/backend/tests/evals/test_assert_records.py b/plugins/capability/darrow-review/backend/tests/evals/test_assert_records.py
new file mode 100644
index 00000000..d05fd338
--- /dev/null
+++ b/plugins/capability/darrow-review/backend/tests/evals/test_assert_records.py
@@ -0,0 +1,39 @@
+"""Eval checks preserve control characters in JSON fields."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+from assert_records import check, load
+
+
+def test_exact_records_distinguish_control_characters(tmp_path: Path) -> None:
+    artifact = tmp_path / "record.json"
+    record = {"evidence": "line\nnext", "next_action": "line\\nnext"}
+    artifact.write_text(json.dumps(record), encoding="utf-8")
+    assert load(artifact) == record
+    check(artifact, "has", ["evidence", "line\nnext"])
+    check(artifact, "has", ["next_action", "line\\nnext"])
+    check(artifact, "lacks", ["evidence", "line\tnext"])
+    with pytest.raises(ValueError, match="has failed"):
+        check(artifact, "has", ["evidence", "line\tnext"])
+
+
+def test_route_assertion_reads_named_fields(tmp_path: Path) -> None:
+    artifact = tmp_path / "route.json"
+    artifact.write_text(
+        json.dumps(
+            {
+                "selected_route": {
+                    "host": "codex",
+                    "provider": "openai",
+                    "model": "gpt-6-astra",
+                    "effort": "high",
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+    check(artifact, "has", ["selected_route", "codex", "openai", "gpt-6-astra", "high"])
diff --git a/plugins/capability/darrow-review/backend/tests/evals/test_eval_routes.py b/plugins/capability/darrow-review/backend/tests/evals/test_eval_routes.py
index e7efb670..1be91dc6 100644
--- a/plugins/capability/darrow-review/backend/tests/evals/test_eval_routes.py
+++ b/plugins/capability/darrow-review/backend/tests/evals/test_eval_routes.py
@@ -11,22 +11,27 @@
 def evidence(root: Path, host: str, axes: list[str]) -> list[dict[str, Any]]:
     directory = root / "darrow-review.fixture"
     directory.mkdir()
-    (directory / "reviewer-route.tsv").write_text("fixture\n")
+    (directory / "reviewer-route.json").write_text("fixture\n")
     model, provider = (
         ("gpt-6-sol", "openai") if host == "codex" else ("claude-opus-5", "anthropic")
     )
-    route = f"{host}\t{provider}\t{model}\txhigh"
+    route = {"host": host, "provider": provider, "model": model, "effort": "xhigh"}
     subagent = f"darrow-review:review-reader-{model}-xhigh"
     events: list[dict[str, Any]] = []
     calls = []
     for index, axis in enumerate(axes, 1):
-        record = (
-            f"axis\t{axis}\nagent_id\t{axis}-child\n"
-            f"requested_route\t{route}\nobserved_route\t{route}\nroute_bound\ttrue\n"
-            "provider_evidence\tcurrent-host-environment-default\n"
+        record = json.dumps(
+            {
+                "axis": axis,
+                "agent_id": f"{axis}-child",
+                "requested_route": route,
+                "observed_route": route,
+                "route_bound": "true",
+                "provider_evidence": "current-host-environment-default",
+            }
         )
         for suffix in ("route", "observed-route"):
-            (directory / f"{axis}-{suffix}.tsv").write_text(record)
+            (directory / f"{axis}-{suffix}.json").write_text(record)
         if host == "codex":
             events.append(
                 {
@@ -109,10 +114,10 @@ def test_single_axis_rejects_uncorrelated_launches(
         verify(tmp_path, host, "default", ["standards"])
 
 
-def test_duplicate_tsv_identity_is_not_evidence(tmp_path: Path) -> None:
-    path = tmp_path / "route.tsv"
-    path.write_text("agent_id\tfirst\nagent_id\tsecond\n")
-    with pytest.raises(AssertionError, match="expected one agent_id"):
+def test_duplicate_json_identity_is_not_evidence(tmp_path: Path) -> None:
+    path = tmp_path / "route.json"
+    path.write_text('{"agent_id":"first","agent_id":"second"}')
+    with pytest.raises(AssertionError, match="duplicate JSON field"):
         row(path, "agent_id")
 
 
diff --git a/plugins/capability/darrow-review/backend/tests/fixtures.py b/plugins/capability/darrow-review/backend/tests/fixtures.py
index 95aef5ef..2b796d81 100644
--- a/plugins/capability/darrow-review/backend/tests/fixtures.py
+++ b/plugins/capability/darrow-review/backend/tests/fixtures.py
@@ -1,69 +1,91 @@
+"""Named JSON fixtures for the review protocols."""
+
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Any
 
 from darrow_review.common import serialize
 
 
-def result_rows() -> list[list[str]]:
-    return [
-        ["format", "darrow-review-result-v1"],
-        ["base", "base"],
-        ["target", "original"],
-        ["changed_file", str(Path.cwd() / "file.txt")],
-        ["standards", "pass"],
-        ["standards_source", "AGENTS.md"],
-        ["spec", "fail"],
-        ["spec_source", "request"],
-        [
-            "finding",
-            "spec",
-            "high",
-            "blocking",
-            "file.txt:1",
-            "request",
-            "wrong value",
-            "restore value",
-            "test value",
+def result_record() -> dict[str, Any]:
+    return {
+        "format": "darrow-review-result-v3",
+        "base": "base",
+        "target": "original",
+        "changed_files": [str(Path.cwd() / "file.txt")],
+        "standards": "pass",
+        "standards_sources": ["AGENTS.md"],
+        "spec": "fail",
+        "spec_source": "request",
+        "findings": [
+            {
+                "axis": "spec",
+                "severity": "high",
+                "disposition": "blocking",
+                "location": "file.txt:1",
+                "source": "request",
+                "evidence": "wrong value",
+                "repair_guidance": "restore value",
+                "resolution_evidence": "test value",
+            }
+        ],
+        "checks": [
+            {
+                "command": "test",
+                "applicability": "applicable",
+                "status": "pass",
+                "evidence": "exited 0",
+            }
         ],
-        ["check", "test", "applicable", "pass", "exited 0"],
-        ["verdict", "fail"],
-        ["risk", "none"],
-        ["next_action", "repair"],
-    ]
+        "verdict": "fail",
+        "risks": ["none"],
+        "next_action": "repair",
+    }
 
 
-def verification_rows() -> list[list[str]]:
-    return [
-        ["format", "darrow-review-verification-v1"],
-        ["original_target", "original"],
-        ["prior_target", "original"],
-        ["current_target", "repaired"],
-        ["previous_verification", "none", "none"],
-        [
-            "original_finding",
-            "spec:1:original",
-            "spec",
-            "1",
-            "high",
-            "blocking",
-            "file.txt:1",
-            "request",
-            "wrong value",
-            "restore value",
-            "test value",
+def verification_record() -> dict[str, Any]:
+    return {
+        "format": "darrow-review-verification-v3",
+        "original_target": "original",
+        "prior_target": "original",
+        "current_target": "repaired",
+        "previous_verification": {"checksum": "none", "path": "none"},
+        "original_findings": [
+            {
+                "key": "spec:1:original",
+                "axis": "spec",
+                "order": "1",
+                "severity": "high",
+                "disposition": "blocking",
+                "location": "file.txt:1",
+                "source": "request",
+                "evidence": "wrong value",
+                "repair_guidance": "restore value",
+                "resolution_evidence": "test value",
+            }
+        ],
+        "attempts": [
+            {
+                "key": "spec:1:original",
+                "status": "resolved",
+                "progress": "resolved",
+                "evidence": "value restored",
+            }
         ],
-        ["attempt", "spec:1:original", "resolved", "resolved", "value restored"],
-        ["check", "test", "applicable", "pass", "exited 0"],
-        ["outcome", "clear"],
-        ["next_action", "return"],
-    ]
+        "checks": [
+            {
+                "command": "test",
+                "applicability": "applicable",
+                "status": "pass",
+                "evidence": "exited 0",
+            }
+        ],
+        "outcome": "clear",
+        "next_action": "return",
+    }
 
 
-def write(path: Path, records: list[list[str]]) -> str:
-    path.write_text(serialize(records), encoding="utf-8", newline="\n")
+def write(path: Path, value: dict[str, Any]) -> str:
+    path.write_text(serialize(value), encoding="utf-8", newline="\n")
     return str(path)
-
-
-def change(records: list[list[str]], kind: str, *fields: str) -> list[list[str]]:
-    return [[kind, *fields] if row[0] == kind else row[:] for row in records]
diff --git a/plugins/capability/darrow-review/backend/tests/fresh_install.py b/plugins/capability/darrow-review/backend/tests/fresh_install.py
index 5e58ec99..da1f909e 100644
--- a/plugins/capability/darrow-review/backend/tests/fresh_install.py
+++ b/plugins/capability/darrow-review/backend/tests/fresh_install.py
@@ -48,11 +48,9 @@ def repository(path: Path) -> None:
 
 
 def field(text: str, name: str) -> str:
-    return next(
-        row.split("\t", 1)[1]
-        for row in text.splitlines()
-        if row.startswith(name + "\t")
-    )
+    value = json.loads(text)[name]
+    assert isinstance(value, str)
+    return value
 
 
 def verify_scope(backend: Path, repo: Path) -> None:
@@ -85,24 +83,29 @@ def verify_scope(backend: Path, repo: Path) -> None:
         "review-check",
         "run",
         "--output",
-        str(artifact / "check.tsv"),
+        str(artifact / "check.json"),
         "--command",
         literal,
     )
-    check = next(
-        line
-        for line in (artifact / "check.tsv").read_text(encoding="utf-8").splitlines()
-        if line.startswith("check\t")
-    )
-    records = runtime(backend, repo, "review-result", "scope-records", manifest)
-    text = (
-        "format\tdarrow-review-result-v1\n"
-        + records
-        + "standards\tpass\nstandards_source\tfixture\nspec\tnot_available\nspec_source\tnot_available\n"
-        + check
-        + "\nverdict\tpass\nrisk\tnone\nnext_action\treturn\n"
-    )
-    result = artifact / "result.tsv"
+    check = json.loads((artifact / "check.json").read_text())["checks"][0]
+    scope_records = json.loads(
+        runtime(backend, repo, "review-result", "scope-records", manifest)
+    )
+    text = json.dumps(
+        {
+            "format": "darrow-review-result-v3",
+            **scope_records,
+            "standards": "pass",
+            "standards_sources": ["fixture"],
+            "spec": "not_available",
+            "spec_source": "not_available",
+            "checks": [check],
+            "verdict": "pass",
+            "risks": ["none"],
+            "next_action": "return",
+        }
+    )
+    result = artifact / "result.json"
     result.write_text(text, encoding="utf-8", newline="\n")
     runtime(backend, repo, "review-result", "validate-scope", manifest, str(result))
     assert "# Code review — PASS" in runtime(
@@ -111,7 +114,7 @@ def verify_scope(backend: Path, repo: Path) -> None:
 
 
 def verify_routes(backend: Path, repo: Path) -> None:
-    route = repo / ".git/route.tsv"
+    route = repo / ".git/route.json"
     runtime(
         backend,
         repo,
@@ -127,9 +130,9 @@ def verify_routes(backend: Path, repo: Path) -> None:
     assert "claude-opus-5" in runtime(
         backend, repo, "review-route", "claude-agent", "--route-record", str(route)
     )
-    assert "provider\tclaude\tanthropic" in runtime(
-        backend, repo, "claude-provider", "observe-direct"
-    )
+    assert json.loads(runtime(backend, repo, "claude-provider", "observe-direct"))[
+        "provider"
+    ] == {"host": "claude", "provider": "anthropic"}
     projects = repo.parent / "mock-provider/projects"
     slug = (
         re.sub(r"[^A-Za-z0-9]", "-", str(repo))
@@ -150,7 +153,7 @@ def verify_routes(backend: Path, repo: Path) -> None:
         + "\n",
         encoding="utf-8",
     )
-    observed = repo / ".git/observed.tsv"
+    observed = repo / ".git/observed.json"
     runtime(
         backend,
         repo,
@@ -164,7 +167,7 @@ def verify_routes(backend: Path, repo: Path) -> None:
         "--record",
         str(observed),
     )
-    application = repo / ".git/application.tsv"
+    application = repo / ".git/application.json"
     runtime(
         backend,
         repo,
@@ -179,7 +182,7 @@ def verify_routes(backend: Path, repo: Path) -> None:
         "--application-record",
         str(application),
     )
-    assert "route_bound\ttrue" in application.read_text(encoding="utf-8")
+    assert json.loads(application.read_text(encoding="utf-8"))["route_bound"] == "true"
 
 
 def validate(copy: Path, fixture: Path) -> None:
diff --git a/plugins/capability/darrow-review/backend/tests/golden/comprehensive.json b/plugins/capability/darrow-review/backend/tests/golden/comprehensive.json
new file mode 100644
index 00000000..16a0752a
--- /dev/null
+++ b/plugins/capability/darrow-review/backend/tests/golden/comprehensive.json
@@ -0,0 +1,48 @@
+{
+  "format": "darrow-review-result-v3",
+  "base": "base-oid",
+  "target": "target-fingerprint",
+  "changed_files": [
+    "/workspace/src/one.js",
+    "/workspace/C:\\(draft\\) file.js"
+  ],
+  "standards": "fail",
+  "standards_sources": ["/workspace/AGENTS.md"],
+  "spec": "pass",
+  "spec_source": "objective <v1> & details",
+  "findings": [
+    {
+      "axis": "standards",
+      "severity": "high",
+      "disposition": "blocking",
+      "location": "src/one.js:1",
+      "source": "/workspace/AGENTS.md",
+      "evidence": "Avoid `debug` output"
+    },
+    {
+      "axis": "spec",
+      "severity": "medium",
+      "disposition": "advisory",
+      "location": "src/two_file.js:2",
+      "source": "objective <v1> & details",
+      "evidence": "Keep [evidence] intact"
+    }
+  ],
+  "checks": [
+    {
+      "command": "bash check_[review].sh --label `nightly`",
+      "applicability": "applicable",
+      "status": "pass",
+      "evidence": "All tests passed"
+    },
+    {
+      "command": "none",
+      "applicability": "not_applicable",
+      "status": "not_applicable",
+      "evidence": "No typecheck applies"
+    }
+  ],
+  "verdict": "fail",
+  "risks": ["Risk <one> & two", "Second risk"],
+  "next_action": "Return `findings` to owner"
+}
diff --git a/plugins/capability/darrow-review/backend/tests/golden/comprehensive.tsv b/plugins/capability/darrow-review/backend/tests/golden/comprehensive.tsv
deleted file mode 100644
index f9a4766a..00000000
--- a/plugins/capability/darrow-review/backend/tests/golden/comprehensive.tsv
+++ /dev/null
@@ -1,17 +0,0 @@
-format	darrow-review-result-v1
-base	base-oid
-target	target-fingerprint
-changed_file	/workspace/src/one.js
-changed_file	/workspace/C:\(draft\) file.js
-standards	fail
-standards_source	/workspace/AGENTS.md
-spec	pass
-spec_source	objective <v1> & details
-finding	standards	high	blocking	src/one.js:1	/workspace/AGENTS.md	Avoid `debug` output
-finding	spec	medium	advisory	src/two_file.js:2	objective <v1> & details	Keep [evidence] intact
-check	bash check_[review].sh --label `nightly`	applicable	pass	All tests passed
-check	none	not_applicable	not_applicable	No typecheck applies
-verdict	fail
-risk	Risk <one> & two
-risk	Second risk
-next_action	Return `findings` to owner
diff --git a/plugins/capability/darrow-review/backend/tests/golden/verification-next.txt b/plugins/capability/darrow-review/backend/tests/golden/verification-next.txt
index c704c7ec..28add587 100644
--- a/plugins/capability/darrow-review/backend/tests/golden/verification-next.txt
+++ b/plugins/capability/darrow-review/backend/tests/golden/verification-next.txt
@@ -38,7 +38,7 @@ No evidence gaps.
 - **Original target:** WORKTREE@base+original
 - **Prior target:** WORKTREE@base+repair-one
 - **Current target:** WORKTREE@base+repair-two
-- **Previous verification checksum:** e8bb6e5a862e67c2af0c0c997fc7e4ecdde176a5
+- **Previous verification checksum:** PREVIOUS_CHECKSUM
 - **Previous verification artifact:** PREVIOUS_ARTIFACT
 - **Earlier targets:**
   - WORKTREE@base+original
diff --git a/plugins/capability/darrow-review/backend/tests/golden/verification.json b/plugins/capability/darrow-review/backend/tests/golden/verification.json
new file mode 100644
index 00000000..5d5acc16
--- /dev/null
+++ b/plugins/capability/darrow-review/backend/tests/golden/verification.json
@@ -0,0 +1,70 @@
+{
+  "format": "darrow-review-verification-v3",
+  "original_target": "WORKTREE@base+original",
+  "prior_target": "WORKTREE@base+original",
+  "current_target": "WORKTREE@base+repair-one",
+  "previous_verification": {
+    "checksum": "none",
+    "path": "none"
+  },
+  "original_findings": [
+    {
+      "key": "standards:1:WORKTREE@base+original",
+      "axis": "standards",
+      "order": "1",
+      "severity": "high",
+      "disposition": "blocking",
+      "location": "src/value.txt:1",
+      "source": "/workspace/AGENTS.md#Review",
+      "evidence": "Original standards evidence"
+    },
+    {
+      "key": "spec:2:WORKTREE@base+original",
+      "axis": "spec",
+      "order": "2",
+      "severity": "low",
+      "disposition": "advisory",
+      "location": "src/value with spaces.txt:2",
+      "source": "user objective <v1> & [details]",
+      "evidence": "Original advisory evidence"
+    }
+  ],
+  "attempts": [
+    {
+      "key": "standards:1:WORKTREE@base+original",
+      "status": "resolved",
+      "progress": "resolved",
+      "evidence": "The violation is absent from the repair"
+    },
+    {
+      "key": "spec:2:WORKTREE@base+original",
+      "status": "unresolved",
+      "progress": "unchanged",
+      "evidence": "The advisory remains"
+    }
+  ],
+  "regressions": [
+    {
+      "key": "regression:1:standards:1:WORKTREE@base+original",
+      "caused_by": "standards:1:WORKTREE@base+original",
+      "order": "1",
+      "axis": "standards",
+      "severity": "high",
+      "status": "resolved",
+      "progress": "resolved",
+      "location": "src/C:\\(repair\\) value_[repair].txt:3",
+      "source": "/workspace/AGENTS_<repair>.md",
+      "evidence": "The repair-caused regression is fixed"
+    }
+  ],
+  "checks": [
+    {
+      "command": "bash verify_[repair].sh --label `fast`",
+      "applicability": "applicable",
+      "status": "pass",
+      "evidence": "All tests passed"
+    }
+  ],
+  "outcome": "clear",
+  "next_action": "return control to enclosing goal"
+}
diff --git a/plugins/capability/darrow-review/backend/tests/golden/verification.tsv b/plugins/capability/darrow-review/backend/tests/golden/verification.tsv
deleted file mode 100644
index e8bb6e5a..00000000
--- a/plugins/capability/darrow-review/backend/tests/golden/verification.tsv
+++ /dev/null
@@ -1,13 +0,0 @@
-format	darrow-review-verification-v1
-original_target	WORKTREE@base+original
-prior_target	WORKTREE@base+original
-current_target	WORKTREE@base+repair-one
-previous_verification	none	none
-original_finding	standards:1:WORKTREE@base+original	standards	1	high	blocking	src/value.txt:1	/workspace/AGENTS.md#Review	Original standards evidence
-original_finding	spec:2:WORKTREE@base+original	spec	2	low	advisory	src/value with spaces.txt:2	user objective <v1> & [details]	Original advisory evidence
-attempt	standards:1:WORKTREE@base+original	resolved	resolved	The violation is absent from the repair
-attempt	spec:2:WORKTREE@base+original	unresolved	unchanged	The advisory remains
-regression	regression:1:standards:1:WORKTREE@base+original	standards:1:WORKTREE@base+original	1	standards	high	resolved	resolved	src/C:\(repair\) value_[repair].txt:3	/workspace/AGENTS_<repair>.md	The repair-caused regression is fixed
-check	bash verify_[repair].sh --label `fast`	applicable	pass	All tests passed
-outcome	clear
-next_action	return control to enclosing goal
diff --git a/plugins/capability/darrow-review/backend/tests/test_boundaries.py b/plugins/capability/darrow-review/backend/tests/test_boundaries.py
index 47c945da..a3b6161c 100644
--- a/plugins/capability/darrow-review/backend/tests/test_boundaries.py
+++ b/plugins/capability/darrow-review/backend/tests/test_boundaries.py
@@ -21,16 +21,23 @@ def test_check_capture_and_refusals(
     command = 'Write-Output "checked"' if os.name == "nt" else 'printf "checked\\n"'
     (repo / "file.txt").write_text("changed", encoding="utf-8")
     manifest = Records(scope.prepare(scope.ScopeOptions(str(repo), "HEAD", "WORKTREE")))
-    path = Path(manifest.value("manifest")).parent / "check.tsv"
+    path = Path(manifest.value("manifest")).parent / "check.json"
     output = cli.check_command(["run", "--output", str(path), "--command", command])
-    assert str(path) in output
-    assert "applicable\tpass\texited 0: checked" in path.read_text(encoding="utf-8")
+    assert Records(output).value("check_record") == str(path)
+    assert Records(path.read_text(encoding="utf-8")).items("checks") == [
+        {
+            "command": command,
+            "applicability": "applicable",
+            "status": "pass",
+            "evidence": f"exited 0: checked{os.linesep}",
+        }
+    ]
     with pytest.raises(ReviewError, match="already exists"):
         check.capture(str(path), command)
     for output_path, value in (
         (str(tmp_path / "outside"), command),
         ("relative", command),
-        (str(path), "bad\ncommand"),
+        (str(path), "bad\0command"),
     ):
         with pytest.raises(ReviewError):
             check.capture(output_path, value)
@@ -46,7 +53,7 @@ def test_check_capture_and_refusals(
 def test_ordered_check_output_and_signal_status() -> None:
     assert check.execute('printf "first\\tline\\r\\n" >&2; printf "second\\n"') == (
         0,
-        "first line",
+        "first\tline\r\nsecond\n",
     )
     assert check.execute("kill -TERM $$")[0] == 143
 
diff --git a/plugins/capability/darrow-review/backend/tests/test_cli_contract.py b/plugins/capability/darrow-review/backend/tests/test_cli_contract.py
index 6d6b78b6..931f2176 100644
--- a/plugins/capability/darrow-review/backend/tests/test_cli_contract.py
+++ b/plugins/capability/darrow-review/backend/tests/test_cli_contract.py
@@ -8,7 +8,7 @@
 
 import pytest
 
-from darrow_review.common import entrypoint
+from darrow_review.common import entrypoint, serialize
 from darrow_review.records import Records
 
 
@@ -37,7 +37,7 @@ def check_destination(repo: Path) -> Path:
         "WORKTREE",
     )
     assert prepared.returncode == 0, prepared.stderr
-    return Path(Records(prepared.stdout).value("manifest")).parent / "check.tsv"
+    return Path(Records(prepared.stdout).value("manifest")).parent / "check.json"
 
 
 @pytest.mark.parametrize(
@@ -96,10 +96,15 @@ def test_check_capture_preserves_status_and_exit_code(
         repo, "review-check", "run", "--output", str(destination), "--command", command
     )
     assert process.returncode == 0, process.stderr
-    assert process.stdout == f"check_record\t{destination}\n"
+    assert process.stdout == serialize({"check_record": str(destination)})
     evidence = Records(destination.read_text(encoding="utf-8"))
-    assert evidence.get("check") == [
-        ["check", command, "applicable", status, f"exited {code}: observed"]
+    assert evidence.items("checks") == [
+        {
+            "command": command,
+            "applicability": "applicable",
+            "status": status,
+            "evidence": f"exited {code}: observed{os.linesep}",
+        }
     ]
     assert evidence.value("exit_code") == str(code)
 
@@ -113,9 +118,11 @@ def test_unavailable_command_retains_real_diagnostic(repo: Path) -> None:
     assert process.returncode == 0, process.stderr
     evidence = Records(destination.read_text(encoding="utf-8"))
     assert evidence.value("exit_code") == "127"
-    check = evidence.get("check")[0]
-    assert check[1:4] == [command, "applicable", "blocked"]
-    assert command in check[4]
+    check = evidence.items("checks")[0]
+    assert check["command"] == command
+    assert check["applicability"] == "applicable"
+    assert check["status"] == "blocked"
+    assert command in check["evidence"]
 
 
 def test_review_state_lifecycle_commands(repo: Path) -> None:
@@ -149,13 +156,13 @@ def test_review_state_lifecycle_commands(repo: Path) -> None:
         "--target",
         packet.value("target"),
     )
-    assert located.stdout == f"manifest\t{manifest}\n"
+    assert located.stdout == serialize({"manifest": manifest})
 
     assert invoke(repo, "review-scope", "pin", "--manifest", manifest).returncode == 0
     pinned_prune = invoke(
         repo, "review-scope", "prune", "--all", "--older-than-days", "0"
     )
-    assert pinned_prune.stdout == "pruned\t0\n"
+    assert pinned_prune.stdout == serialize({"pruned": "0", "removed": []})
     assert Path(manifest).exists()
 
     assert invoke(repo, "review-scope", "unpin", "--manifest", manifest).returncode == 0
@@ -172,10 +179,10 @@ def test_terminal_scope_has_private_artifact_directory(repo: Path) -> None:
     assert run.parent.parent == Path(os.environ["DARROW_REVIEW_STATE_DIR"])
     assert not run.is_relative_to(repo)
     manifest = Records(terminal.stdout).value("manifest")
-    assert manifest == str(run / "scope.tsv")
+    assert manifest == str(run / "scope.json")
     assert invoke(repo, "review-scope", "pin", "--manifest", manifest).returncode == 0
     preserved = invoke(repo, "review-scope", "prune", "--all", "--older-than-days", "0")
-    assert preserved.stdout == "pruned\t0\n"
+    assert preserved.stdout == serialize({"pruned": "0", "removed": []})
     assert run.exists()
     assert invoke(repo, "review-scope", "unpin", "--manifest", manifest).returncode == 0
     pruned = invoke(repo, "review-scope", "prune", "--all", "--older-than-days", "0")
diff --git a/plugins/capability/darrow-review/backend/tests/test_golden_reports.py b/plugins/capability/darrow-review/backend/tests/test_golden_reports.py
index 4a19e26d..8f235b0f 100644
--- a/plugins/capability/darrow-review/backend/tests/test_golden_reports.py
+++ b/plugins/capability/darrow-review/backend/tests/test_golden_reports.py
@@ -7,8 +7,7 @@
 import pytest
 
 from darrow_review import cli, report
-from darrow_review.common import blob_hash, rows
-from fixtures import change, write
+from darrow_review.common import blob_hash, document, serialize
 
 GOLDEN = Path(__file__).with_name("golden")
 
@@ -20,8 +19,8 @@
 def test_complete_report_bytes(name: str, operation: str, tmp_path: Path) -> None:
     # Preserve the original Unix goldens; qualify their absolute root on Windows.
     root = f"{tmp_path.drive}/workspace/"
-    source = (GOLDEN / f"{name}.tsv").read_text(encoding="utf-8")
-    record = tmp_path / "result.tsv"
+    source = (GOLDEN / f"{name}.json").read_text(encoding="utf-8")
+    record = tmp_path / "result.json"
     record.write_text(source.replace("/workspace/", root), encoding="utf-8")
     actual = cli.report_command([operation, str(record)])
     expected = (GOLDEN / f"{name}.txt").read_text(encoding="utf-8")
@@ -29,19 +28,24 @@ def test_complete_report_bytes(name: str, operation: str, tmp_path: Path) -> Non
 
 
 def test_checksum_bound_report_bytes(tmp_path: Path) -> None:
-    original = rows((GOLDEN / "verification.tsv").read_text(encoding="utf-8"))
-    previous = Path(write(tmp_path / "previous.tsv", original))
-    current = change(original, "prior_target", "WORKTREE@base+repair-one")
-    current = change(current, "current_target", "WORKTREE@base+repair-two")
-    current = change(
-        current,
-        "previous_verification",
-        blob_hash(previous.read_bytes()),
-        str(previous),
-    )
-    current.append(["history_target", "WORKTREE@base+original"])
-    path = write(tmp_path / "current.tsv", current)
-    actual = cli.report_command(["render-verification", path])
+    original = document((GOLDEN / "verification.json").read_text(encoding="utf-8"))
+    previous = tmp_path / "previous.json"
+    previous.write_text(serialize(original), encoding="utf-8")
+    current = {
+        **original,
+        "prior_target": "WORKTREE@base+repair-one",
+        "current_target": "WORKTREE@base+repair-two",
+        "previous_verification": {
+            "checksum": blob_hash(previous.read_bytes()),
+            "path": str(previous),
+        },
+        "history_targets": ["WORKTREE@base+original"],
+    }
+    path = tmp_path / "current.json"
+    path.write_text(serialize(current), encoding="utf-8")
+    actual = cli.report_command(["render-verification", str(path)])
     assert actual.replace(report.escape(str(previous)), "PREVIOUS_ARTIFACT") == (
         GOLDEN / "verification-next.txt"
-    ).read_text(encoding="utf-8")
+    ).read_text(encoding="utf-8").replace(
+        "PREVIOUS_CHECKSUM", blob_hash(previous.read_bytes())
+    )
diff --git a/plugins/capability/darrow-review/backend/tests/test_original_binding.py b/plugins/capability/darrow-review/backend/tests/test_original_binding.py
index 348bbf86..5160c4ce 100644
--- a/plugins/capability/darrow-review/backend/tests/test_original_binding.py
+++ b/plugins/capability/darrow-review/backend/tests/test_original_binding.py
@@ -1,126 +1,150 @@
 from __future__ import annotations
 
 from pathlib import Path
+from typing import cast
 
 import pytest
 
 from darrow_review import cli, result
 from darrow_review.common import ReviewError, serialize
-from darrow_review.records import validate_result
+from darrow_review.records import Record, validate_result
 from darrow_review.verification import validate_verification
-from fixtures import change, result_rows, verification_rows, write
-
-
-def original_rows() -> list[list[str]]:
-    records = result_rows()
-    records.insert(
-        8,
-        ["finding", "standards", "low", "advisory", "file.txt:2", "rule", r"C:\path"],
+from fixtures import result_record, verification_record
+
+
+def original_doc() -> dict[str, object]:
+    data = result_record()
+    findings = cast(list[Record], data["findings"])
+    findings.insert(
+        0,
+        {
+            "axis": "standards",
+            "severity": "low",
+            "disposition": "advisory",
+            "location": "file.txt:2",
+            "source": "rule",
+            "evidence": r"C:\path",
+        },
     )
-    return records
+    return data
 
 
-def followup_rows() -> list[list[str]]:
-    records = [row for row in verification_rows() if row[0] != "original_finding"]
-    records = change(
-        records, "attempt", "spec:2:original", "resolved", "resolved", "fixed"
+def followup_doc() -> dict[str, object]:
+    data = verification_record()
+    data["original_findings"] = result.original_findings(
+        validate_result(serialize(original_doc()))
     )
-    return [
-        *records,
-        *result.original_findings(validate_result(serialize(original_rows()))),
+    data["attempts"] = [
+        {
+            "key": "spec:2:original",
+            "status": "resolved",
+            "progress": "resolved",
+            "evidence": "fixed",
+        }
     ]
+    return data
+
+
+def write_json(path: Path, value: dict[str, object]) -> str:
+    path.write_text(serialize(value), encoding="utf-8")
+    return str(path)
 
 
 def test_original_order_and_mixed_guidance(tmp_path: Path) -> None:
-    original = write(tmp_path / "original.tsv", original_rows())
-    current = write(tmp_path / "current.tsv", followup_rows())
-    expected = (
-        "original_finding\tstandards:1:original\tstandards\t1\tlow\tadvisory\tfile.txt:2\trule\tC:\\path\n"
-        "original_finding\tspec:2:original\tspec\t2\thigh\tblocking\tfile.txt:1\trequest\twrong value\trestore value\ttest value\n"
+    original = write_json(tmp_path / "original.json", original_doc())
+    current = write_json(tmp_path / "current.json", followup_doc())
+    expected = serialize(
+        {
+            "original_findings": result.original_findings(
+                validate_result(serialize(original_doc()))
+            )
+        }
     )
     assert cli.result_command(["original-findings", original]) == expected
     assert "preserved" in cli.result_command(["validate-original", original, current])
 
 
-@pytest.mark.parametrize("field", [4, 5, 6, 7, 8, 9, 10])
-def test_immutable_original_fields(tmp_path: Path, field: int) -> None:
-    original = write(tmp_path / "original.tsv", original_rows())
-    records = followup_rows()
+@pytest.mark.parametrize(
+    "field",
+    [
+        "severity",
+        "disposition",
+        "location",
+        "source",
+        "evidence",
+        "repair_guidance",
+        "resolution_evidence",
+    ],
+)
+def test_immutable_original_fields(tmp_path: Path, field: str) -> None:
+    original = write_json(tmp_path / "original.json", original_doc())
+    data = followup_doc()
     finding = next(
-        row for row in records if row[:2] == ["original_finding", "spec:2:original"]
+        item
+        for item in cast(list[Record], data["original_findings"])
+        if item["key"] == "spec:2:original"
     )
-    replacements = {4: "medium", 5: "advisory"}
-    finding[field] = replacements.get(field, "changed")
-    # A valid record can still misrepresent its authoritative original.
-    validate_verification(serialize(records))
-    changed = write(tmp_path / "changed.tsv", records)
+    finding[field] = {
+        "severity": "medium",
+        "disposition": "advisory",
+    }.get(field, "changed")
+    validate_verification(serialize(data))
+    changed = write_json(tmp_path / "changed.json", data)
     with pytest.raises(ReviewError, match="complete ordered finding set"):
         result.validate_original(original, changed)
 
 
 @pytest.mark.parametrize("mutation", ["omitted", "renumbered", "target"])
 def test_original_membership_and_target(tmp_path: Path, mutation: str) -> None:
-    original = write(tmp_path / "original.tsv", original_rows())
-    records = mutated_original(mutation)
-    validate_verification(serialize(records))
-    changed = write(tmp_path / "changed.tsv", records)
-    with pytest.raises(ReviewError):
-        result.validate_original(original, changed)
-
-
-def mutated_original(mutation: str) -> list[list[str]]:
-    records = followup_rows()
+    original = write_json(tmp_path / "original.json", original_doc())
+    data = followup_doc()
+    findings = cast(list[Record], data["original_findings"])
     if mutation == "omitted":
-        return [
-            row
-            for row in records
-            if row[:2] != ["original_finding", "standards:1:original"]
-        ]
-    if mutation == "target":
-        return [
-            [
-                value.replace("original", "wrong") if index else value
-                for index, value in enumerate(row)
-            ]
-            for row in records
+        data["original_findings"] = [
+            item for item in findings if item["key"] != "standards:1:original"
         ]
-    for row in records:
-        renumber(row)
-    return records
-
-
-def renumber(row: list[str]) -> None:
-    if row[0] == "original_finding":
-        row[3] = str(3 - int(row[3]))
-        row[1] = f"{row[2]}:{row[3]}:original"
-    if row[0] == "attempt":
-        row[1] = "spec:1:original"
+    elif mutation == "renumbered":
+        for item in findings:
+            item["order"] = str(3 - int(item["order"]))
+            item["key"] = f"{item['axis']}:{item['order']}:original"
+        cast(list[Record], data["attempts"])[0]["key"] = "spec:1:original"
+    else:
+        data["original_target"] = data["prior_target"] = "wrong"
+        for item in findings:
+            item["key"] = item["key"].replace("original", "wrong")
+        cast(list[Record], data["attempts"])[0]["key"] = "spec:2:wrong"
+    validate_verification(serialize(data))
+    changed = write_json(tmp_path / "changed.json", data)
+    with pytest.raises(ReviewError):
+        result.validate_original(original, changed)
 
 
-@pytest.mark.parametrize("field", [7, 8])
+@pytest.mark.parametrize("field", ["repair_guidance", "resolution_evidence"])
 @pytest.mark.parametrize("mutation", ["empty", "missing"])
-def test_guidance_is_an_atomic_nonempty_pair(field: int, mutation: str) -> None:
-    records = result_rows()
-    finding = next(row for row in records if row[0] == "finding")
+def test_guidance_is_an_atomic_nonempty_pair(field: str, mutation: str) -> None:
+    data = result_record()
+    finding = cast(list[Record], data["findings"])[0]
     if mutation == "empty":
         finding[field] = ""
     else:
         del finding[field]
     with pytest.raises(ReviewError):
-        validate_result(serialize(records))
+        validate_result(serialize(data))
 
 
 def test_exact_guidance_survives_both_presentations(tmp_path: Path) -> None:
-    records = result_rows()
-    finding = next(row for row in records if row[0] == "finding")
-    finding[7:] = [
-        r"Restore <3>; preserve C:\path and avoid [new API](url) changes",
-        "Calling retry must make exactly 3 attempts",
-    ]
-    original = write(tmp_path / "original.tsv", records)
-    followup = [row for row in verification_rows() if row[0] != "original_finding"]
-    followup += result.original_findings(validate_result(serialize(records)))
-    current = write(tmp_path / "current.tsv", followup)
+    data = result_record()
+    finding = cast(list[Record], data["findings"])[0]
+    finding["repair_guidance"] = (
+        r"Restore <3>; preserve C:\path and avoid [new API](url) changes"
+    )
+    finding["resolution_evidence"] = "Calling retry must make exactly 3 attempts"
+    original = write_json(tmp_path / "original.json", data)
+    followup = verification_record()
+    followup["original_findings"] = result.original_findings(
+        validate_result(serialize(data))
+    )
+    current = write_json(tmp_path / "current.json", followup)
     comprehensive = cli.report_command(["render", original])
     verification = cli.report_command(["render-verification", current])
     attempted, closed = verification.split("## Closed original finding set", 1)
diff --git a/plugins/capability/darrow-review/backend/tests/test_records.py b/plugins/capability/darrow-review/backend/tests/test_records.py
index 0ced1e65..c9c7324e 100644
--- a/plugins/capability/darrow-review/backend/tests/test_records.py
+++ b/plugins/capability/darrow-review/backend/tests/test_records.py
@@ -1,118 +1,210 @@
 from __future__ import annotations
 
 import io
+from copy import deepcopy
 from pathlib import Path
+from typing import Any
 
 import pytest
 from hypothesis import given, settings
 from hypothesis import strategies as st
 
 from darrow_review import cli, report, result
-from darrow_review.common import ReviewError, serialize
-from darrow_review.records import validate_axis, validate_fix_axis, validate_result
+from darrow_review.common import ReviewError, document, serialize
+from darrow_review.records import (
+    Records,
+    validate_axis,
+    validate_fix_axis,
+    validate_result,
+)
 from darrow_review.verification import validate_verification
-from fixtures import change, result_rows, verification_rows, write
+from fixtures import result_record, verification_record, write
+
+
+def axis_record(status: str = "pass", disposition: str = "advisory") -> dict[str, Any]:
+    return {
+        "format": "darrow-review-axis-v3",
+        "axis": "spec",
+        "status": status,
+        "sources": ["request"],
+        "findings": [
+            {
+                "severity": "high",
+                "disposition": disposition,
+                "location": "f:1",
+                "source": "request",
+                "evidence": "evidence",
+            }
+        ],
+    }
+
+
+def fix_axis_record() -> dict[str, Any]:
+    return {
+        "format": "darrow-review-fix-axis-v3",
+        "axis": "spec",
+        "originals": ["key"],
+        "prior_regressions": [{"key": "prior", "caused_by": "key"}],
+        "attempts": [
+            {
+                "key": "key",
+                "status": "resolved",
+                "progress": "resolved",
+                "evidence": "fixed",
+            }
+        ],
+        "regression_attempts": [
+            {
+                "key": "prior",
+                "status": "unresolved",
+                "progress": "progressing",
+                "evidence": "improved",
+            }
+        ],
+        "regressions": [
+            {
+                "caused_by": "key",
+                "severity": "high",
+                "location": "f:1",
+                "source": "request",
+                "evidence": "new failure",
+                "repair_guidance": "repair",
+                "resolution_evidence": "test",
+            }
+        ],
+    }
+
+
+def test_result_wire_format_uses_named_objects() -> None:
+    data = result_record()
+    assert document(serialize(data)) == data
+    assert data["format"] == "darrow-review-result-v3"
+    assert data["changed_files"] == [str(Path.cwd() / "file.txt")]
+    assert data["findings"][0]["repair_guidance"] == "restore value"
+    assert data["checks"][0]["status"] == "pass"
 
 
 def test_original_report_and_handoff(tmp_path: Path) -> None:
-    original = write(tmp_path / "original.tsv", result_rows())
-    verification = write(tmp_path / "verification.tsv", verification_rows())
+    original = write(tmp_path / "original.json", result_record())
+    verification = write(tmp_path / "verification.json", verification_record())
     assert "preserved" in cli.result_command(
         ["validate-original", original, verification]
     )
-    assert "original_finding\tspec:1:original" in cli.result_command(
-        ["original-findings", original]
-    )
+    packet = Records(cli.result_command(["original-findings", original]))
+    assert packet.items("original_findings")[0]["key"] == "spec:1:original"
     assert "valid:" in cli.result_command(["validate", original])
     assert "valid:" in cli.result_command(["validate-verification", verification])
-    text = cli.report_command(["render", original])
-    assert "# Code review — FAIL" in text
-    assert "Repair guidance (advisory)" in text
+    rendered = cli.report_command(["render", original])
+    assert "# Code review — FAIL" in rendered
+    assert "Repair guidance (advisory)" in rendered
     assert (
-        text.index("## Next action")
-        < text.index("## Findings")
-        < text.index("## Scope")
-        < text.index("## Sources")
-    )
-    rendered = cli.report_command(["render-verification", verification])
-    assert "# Repair verification — CLEAR" in rendered
-    assert "Original evidence" in rendered and "Closed original finding set" in rendered
-    assert rendered.index("## Next action") < rendered.index("## Attempted findings")
-    changed = write(
-        tmp_path / "changed.tsv",
-        change(
-            verification_rows(),
-            "original_finding",
-            "spec:1:original",
-            "spec",
-            "1",
-            "high",
-            "blocking",
-            "file.txt:1",
-            "request",
-            "rewritten",
-            "restore value",
-            "test value",
-        ),
+        rendered.index("## Next action")
+        < rendered.index("## Findings")
+        < rendered.index("## Scope")
+        < rendered.index("## Sources")
     )
+    verified = cli.report_command(["render-verification", verification])
+    assert "# Repair verification — CLEAR" in verified
+    assert "Original evidence" in verified and "Closed original finding set" in verified
+    assert verified.index("## Next action") < verified.index("## Attempted findings")
+    changed = verification_record()
+    changed["original_findings"][0]["evidence"] = "rewritten"
+    path = write(tmp_path / "changed.json", changed)
     with pytest.raises(ReviewError, match="complete ordered finding set"):
-        result.validate_original(original, changed)
+        result.validate_original(original, path)
 
 
-@pytest.mark.parametrize("row_index", range(len(result_rows())))
-def test_required_result_records_reject_extra_fields(row_index: int) -> None:
-    records = result_rows()
-    records[row_index].append("unexpected")
+@pytest.mark.parametrize("container", ["root", "finding", "check"])
+def test_result_schema_rejects_extra_fields(container: str) -> None:
+    data = result_record()
+    target = (
+        data
+        if container == "root"
+        else data["findings" if container == "finding" else "checks"][0]
+    )
+    target["unexpected"] = "value"
+    with pytest.raises(ReviewError):
+        validate_result(serialize(data))
+
+
+@pytest.mark.parametrize(
+    "field",
+    [
+        "format",
+        "original_target",
+        "prior_target",
+        "current_target",
+        "previous_verification",
+        "checks",
+        "outcome",
+        "next_action",
+    ],
+)
+def test_verification_rejects_missing_required_fields(field: str) -> None:
+    data = verification_record()
+    del data[field]
     with pytest.raises(ReviewError):
-        validate_result(serialize(records))
+        validate_verification(serialize(data))
 
 
-@pytest.mark.parametrize("row_index", range(len(verification_rows())))
-def test_verification_records_reject_missing_fields(row_index: int) -> None:
-    records = verification_rows()
-    records[row_index] = records[row_index][:1]
+@pytest.mark.parametrize(
+    ("field", "value"),
+    [
+        ("format", "other"),
+        ("base", ""),
+        ("changed_files", ["relative"]),
+        ("standards", "unknown"),
+        ("spec", "not_available"),
+        ("spec_source", "not_available"),
+        ("verdict", "pass"),
+    ],
+)
+def test_invalid_result_fields(field: str, value: object) -> None:
+    data = result_record()
+    data[field] = value
     with pytest.raises(ReviewError):
-        validate_verification(serialize(records))
+        validate_result(serialize(data))
 
 
 @pytest.mark.parametrize(
-    ("kind", "fields"),
+    ("field", "value"),
     [
-        ("format", ["other"]),
-        ("base", [""]),
-        ("changed_file", ["relative"]),
-        ("standards", ["unknown"]),
-        ("spec", ["not_available"]),
-        ("spec_source", ["not_available"]),
-        ("verdict", ["pass"]),
-        ("finding", ["spec", "high", "blocking", "f:1", "heuristic:guess", "bad"]),
-        ("check", ["test", "unknown", "pass", "evidence"]),
-        ("check", ["test", "not_applicable", "pass", "evidence"]),
-        ("check", ["test", "applicable", "unknown", "evidence"]),
+        ("source", "heuristic:guess"),
+        ("applicability", "unknown"),
+        ("status", "unknown"),
     ],
 )
-def test_invalid_result_records(kind: str, fields: list[str]) -> None:
+def test_invalid_nested_result_fields(field: str, value: str) -> None:
+    data = result_record()
+    target = data["findings"][0] if field == "source" else data["checks"][0]
+    target[field] = value
     with pytest.raises(ReviewError):
-        validate_result(serialize(change(result_rows(), kind, *fields)))
+        validate_result(serialize(data))
 
 
 def test_unavailable_spec_and_blocked_scope() -> None:
-    records = [
-        row for row in result_rows() if row[0] not in ("finding", "changed_file")
-    ]
-    records = change(records, "standards", "blocked")
-    records = change(records, "spec", "not_available")
-    records = change(records, "spec_source", "not_available")
-    records = change(records, "verdict", "blocked")
-    records = change(
-        records, "check", "none", "not_applicable", "not_applicable", "no check"
+    data = result_record()
+    data.update(
+        standards="blocked",
+        spec="not_available",
+        spec_source="not_available",
+        verdict="blocked",
+        findings=[],
+        changed_files=[],
+        checks=[
+            {
+                "command": "none",
+                "applicability": "not_applicable",
+                "status": "not_applicable",
+                "evidence": "no check",
+            }
+        ],
     )
-    text = report.comprehensive(validate_result(serialize(records)))
-    assert "No findings." in text
+    rendered = report.comprehensive(validate_result(serialize(data)))
+    assert "No findings." in rendered
+    data.update(standards="pass", verdict="pass")
     with pytest.raises(ReviewError, match="non-blocked result"):
-        validate_result(
-            serialize(change(change(records, "standards", "pass"), "verdict", "pass"))
-        )
+        validate_result(serialize(data))
 
 
 @pytest.mark.parametrize(
@@ -126,87 +218,66 @@ def test_unavailable_spec_and_blocked_scope() -> None:
     ],
 )
 def test_axis_verdicts(status: str, disposition: str, valid: bool) -> None:
-    text = serialize(
-        [
-            ["format", "darrow-review-axis-v1"],
-            ["axis", "spec"],
-            ["status", status],
-            ["source", "request"],
-            ["finding", "high", disposition, "f:1", "request", "evidence"],
-        ]
-    )
+    data = axis_record(status, disposition)
     if valid:
-        assert validate_axis(text, "spec").value("status") == status
+        assert validate_axis(serialize(data), "spec").value("status") == status
     else:
         with pytest.raises(ReviewError):
-            validate_axis(text, "spec")
+            validate_axis(serialize(data), "spec")
 
 
 def test_fix_axis_closed_membership(tmp_path: Path) -> None:
-    records = [
-        ["format", "darrow-review-fix-axis-v1"],
-        ["axis", "spec"],
-        ["original", "key"],
-        ["prior_regression", "prior", "key"],
-        ["attempt", "key", "resolved", "resolved", "fixed"],
-        ["regression_attempt", "prior", "unresolved", "progressing", "improved"],
-        [
-            "regression",
-            "key",
-            "high",
-            "f:1",
-            "request",
-            "new failure",
-            "repair",
-            "test",
-        ],
-    ]
-    path = write(tmp_path / "axis.tsv", records)
+    data = fix_axis_record()
+    path = write(tmp_path / "axis.json", data)
     assert "(spec)" in cli.result_command(["validate-fix-axis", "spec", path])
-    for kind in ("original", "attempt", "prior_regression", "regression_attempt"):
+    for field in ("originals", "attempts", "prior_regressions", "regression_attempts"):
+        variant = deepcopy(data)
+        del variant[field]
         with pytest.raises(ReviewError):
-            validate_fix_axis(
-                serialize([row for row in records if row[0] != kind]), "spec"
-            )
+            validate_fix_axis(serialize(variant), "spec")
     with pytest.raises(ReviewError, match="axis does not match"):
-        validate_fix_axis(serialize(records), "standards")
+        validate_fix_axis(serialize(data), "standards")
     for status, progress in (
         ("wrong", "wrong"),
         ("resolved", "unavailable"),
         ("blocked", "resolved"),
         ("unresolved", "resolved"),
     ):
+        variant = deepcopy(data)
+        variant["attempts"][0].update(status=status, progress=progress)
         with pytest.raises(ReviewError):
-            validate_fix_axis(
-                serialize(
-                    change(records, "attempt", "key", status, progress, "evidence")
-                ),
-                "spec",
-            )
-    gaps = [*records[:4], ["evidence_gap", "missing repair"]]
-    validate_fix_axis(serialize(gaps), "spec")
+            validate_fix_axis(serialize(variant), "spec")
+    gap = {
+        "format": data["format"],
+        "axis": "spec",
+        "originals": ["key"],
+        "prior_regressions": data["prior_regressions"],
+        "evidence_gaps": ["missing repair"],
+    }
+    validate_fix_axis(serialize(gap), "spec")
     with pytest.raises(ReviewError, match="action or evidence gap"):
-        validate_fix_axis(serialize(records[:2]), "spec")
+        validate_fix_axis(serialize({"format": data["format"], "axis": "spec"}), "spec")
 
 
-def test_stdin_and_legacy_guidance(
+def test_stdin_and_optional_guidance(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    records = result_rows()
-    records = [row[:7] if row[0] == "finding" else row for row in records]
-    monkeypatch.setattr("sys.stdin", io.StringIO(serialize(records)))
-    assert "result-v1" in cli.result_command(["validate", "-"])
-    original = validate_result(serialize(records))
-    assert len(result.original_findings(original)[0]) == 9
+    data = result_record()
+    del data["findings"][0]["repair_guidance"]
+    del data["findings"][0]["resolution_evidence"]
+    monkeypatch.setattr("sys.stdin", io.StringIO(serialize(data)))
+    assert "result-v3" in cli.result_command(["validate", "-"])
+    original = validate_result(serialize(data))
+    assert len(result.original_findings(original)[0]) == 8
     assert "Repair guidance" not in report.comprehensive(original)
     axis = write(
-        tmp_path / "axis.tsv",
-        [
-            ["format", "darrow-review-axis-v1"],
-            ["axis", "spec"],
-            ["status", "pass"],
-            ["source", "request"],
-        ],
+        tmp_path / "axis.json",
+        {
+            "format": "darrow-review-axis-v3",
+            "axis": "spec",
+            "status": "pass",
+            "sources": ["request"],
+        },
     )
     assert "(spec)" in cli.result_command(["validate-axis", "spec", axis])
     with pytest.raises(ReviewError):
@@ -216,25 +287,66 @@ def test_stdin_and_legacy_guidance(
 @settings(max_examples=80, derandomize=True)
 @given(
     st.text(
-        alphabet=st.characters(blacklist_categories=("Cs", "Cc", "Zl", "Zp")),
+        alphabet=st.one_of(
+            st.characters(blacklist_categories=("Cs", "Cc", "Zl", "Zp")),
+            st.sampled_from(["\t", "\n", "\r"]),
+        ),
         min_size=1,
         max_size=100,
     )
 )
 def test_evidence_round_trip(evidence: str) -> None:
-    records = result_rows()
-    records[8][6] = evidence
-    parsed = validate_result(serialize(records))
-    assert parsed.get("finding")[0][6] == evidence
+    data = result_record()
+    data["findings"][0]["evidence"] = evidence
+    parsed = validate_result(serialize(data))
+    assert parsed.items("findings")[0]["evidence"] == evidence
     assert report.escape(evidence) in report.comprehensive(parsed)
 
 
-def test_unknown_duplicate_and_absent_records() -> None:
-    for records in (
-        [*result_rows(), ["unexpected", "value"]],
-        [*result_rows(), ["base", "extra"]],
-        [],
-        [row for row in result_rows() if row[0] != "risk"],
-    ):
+def test_json_preserves_multiline_fields() -> None:
+    data = result_record()
+    data["findings"][0]["evidence"] = "first\tcolumn\nsecond line\rthird"
+    data["checks"][0]["command"] = "printf 'one\ntwo\tthree'"
+    serialized = serialize(data)
+    assert document(serialized) == data
+    validate_result(serialized)
+    rendered = report.comprehensive(validate_result(serialized))
+    assert "first\\tcolumn\\nsecond line\\rthird" in rendered
+
+
+@pytest.mark.parametrize(
+    "content",
+    [
+        "",
+        "{}",
+        "null",
+        "[[]]",
+        '[["format", 2]]',
+        '{"format":"a","format":"b"}',
+        '{"format":["darrow-review-result-v3"]}',
+        '{"format":"darrow-review-result-v3","changed_file":"file.txt"}',
+        '{"format":"darrow-review-result-v3","changed_files":"file.txt"}',
+        '{"format":"darrow-review-result-v3","base":{"_fields":["x"]}}',
+        '{"format":"darrow-review-result-v3","checks":[{"command":"x","_extra":["y"]}]}',
+        '{"format":"darrow-review-result-v3","checks":["x"]}',
+        '{"format":"darrow-review-result-v3","checks":[{"status":"pass"}]}',
+        '{"format":"darrow-review-result-v3","checks":[{"command":2}]}',
+    ],
+)
+def test_json_schema_rejects_malformed_shapes(content: str) -> None:
+    with pytest.raises(ReviewError):
+        validate_result(content)
+
+
+def test_unknown_duplicate_and_absent_fields() -> None:
+    variants = [
+        result_record() | {"unexpected": "value"},
+        result_record() | {"base": ["base", "extra"]},
+        {},
+    ]
+    missing_risk = result_record()
+    del missing_risk["risks"]
+    variants.append(missing_risk)
+    for data in variants:
         with pytest.raises(ReviewError):
-            validate_result(serialize(records))
+            validate_result(serialize(data))
diff --git a/plugins/capability/darrow-review/backend/tests/test_routes.py b/plugins/capability/darrow-review/backend/tests/test_routes.py
index 03897d89..b1243848 100644
--- a/plugins/capability/darrow-review/backend/tests/test_routes.py
+++ b/plugins/capability/darrow-review/backend/tests/test_routes.py
@@ -7,7 +7,8 @@
 import pytest
 
 from darrow_review import cli, provider, routing
-from darrow_review.common import ReviewError, new_record, serialize
+from darrow_review.common import ReviewError, document, new_record, serialize
+from darrow_review.records import Records
 
 
 def reviewer(
@@ -31,17 +32,19 @@ def config(repo: Path, value: object) -> Path:
 
 def test_bundled_override_and_application(repo: Path, tmp_path: Path) -> None:
     default = cli.route_command(["resolve", "--repo", str(repo), "--host", "codex"])
-    assert "gpt-6-sol\txhigh" in default
+    assert Records(default).object("selected_route")["model"] == "gpt-6-sol"
+    assert Records(default).object("selected_route")["effort"] == "xhigh"
     config(
         repo,
         {"routes": [{"unrelated": [False, None, 12.5]}], "reviewers": [reviewer()]},
     )
-    selected = tmp_path / "route.tsv"
+    selected = tmp_path / "route.json"
     output = cli.route_command(
         ["select", "--repo", str(repo), "--host", "codex", "--record", str(selected)]
     )
-    assert "route_source\trepository" in output and "model\tgpt-5.5" in output
-    applied = tmp_path / "applied.tsv"
+    assert Records(output).value("route_source") == "repository"
+    assert Records(output).value("model") == "gpt-5.5"
+    applied = tmp_path / "applied.json"
     cli.route_command(
         [
             "confirm-codex",
@@ -55,9 +58,14 @@ def test_bundled_override_and_application(repo: Path, tmp_path: Path) -> None:
             str(applied),
         ]
     )
-    body = applied.read_text(encoding="utf-8")
-    assert "route_bound\ttrue" in body and "route_verified" not in body
-    assert "requested_route\tcodex\topenai\tgpt-5.5\thigh" in body
+    body = Records(applied.read_text(encoding="utf-8"))
+    assert body.value("route_bound") == "true" and "route_verified" not in body.data
+    assert body.object("requested_route") == {
+        "host": "codex",
+        "provider": "openai",
+        "model": "gpt-5.5",
+        "effort": "high",
+    }
     assert "claude-opus-5" in routing.resolve(str(repo), "claude").body()
     config(repo, {})
     assert routing.resolve(str(repo), "codex").source == "bundled"
@@ -148,7 +156,7 @@ def test_custom_endpoint_and_route_fields(monkeypatch: pytest.MonkeyPatch) -> No
 def test_claude_native_agent(
     repo: Path, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    route = tmp_path / "claude.tsv"
+    route = tmp_path / "claude.json"
     routing.select(str(repo), "claude", str(route))
     assert "darrow-review:review-reader-claude-opus-5-xhigh" in cli.route_command(
         ["claude-agent", "--route-record", str(route)]
@@ -211,7 +219,7 @@ def test_transcript_native_application(
     repo: Path, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     projects, path = transcript(repo, tmp_path)
-    record = tmp_path / "observed.tsv"
+    record = tmp_path / "observed.json"
     arguments = [
         "--repo",
         str(repo),
@@ -220,14 +228,16 @@ def test_transcript_native_application(
         "--projects-dir",
         str(projects),
     ]
-    assert (
-        "observed_route\tclaude\tanthropic\tclaude-opus-5\txhigh"
-        in cli.verify_command(arguments)
-    )
+    assert Records(cli.verify_command(arguments)).object("observed_route") == {
+        "host": "claude",
+        "provider": "anthropic",
+        "model": "claude-opus-5",
+        "effort": "xhigh",
+    }
     cli.verify_command([*arguments, "--record", str(record)])
-    route = tmp_path / "route.tsv"
+    route = tmp_path / "route.json"
     routing.select(str(repo), "claude", str(route))
-    application = tmp_path / "application.tsv"
+    application = tmp_path / "application.json"
     cli.route_command(
         [
             "confirm-claude",
@@ -241,9 +251,9 @@ def test_transcript_native_application(
             str(application),
         ]
     )
-    assert "agent_id\tabc1" in application.read_text(encoding="utf-8")
+    assert Records(application.read_text(encoding="utf-8")).value("agent_id") == "abc1"
     monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(projects.parent))
-    assert str(path) in provider.verify(str(repo), "abc1")
+    assert Records(provider.verify(str(repo), "abc1")).value("transcript") == str(path)
     route.write_text(
         route.read_text(encoding="utf-8").replace("claude-opus-5", "claude-sonnet-5"),
         encoding="utf-8",
@@ -252,7 +262,7 @@ def test_transcript_native_application(
         routing.confirm(
             str(route),
             "spec",
-            str(tmp_path / "mismatch.tsv"),
+            str(tmp_path / "mismatch.json"),
             observed_path=str(record),
         )
 
@@ -297,13 +307,13 @@ def test_transcript_cardinality_and_route_changes(repo: Path, tmp_path: Path) ->
 
 def test_records_refuse_duplicates_unknown_and_incomplete(tmp_path: Path) -> None:
     route = routing.Route("codex", "openai", "gpt-5.5", "high")
-    path = tmp_path / "route.tsv"
+    path = tmp_path / "route.json"
     variants = [
-        route.body() + "format\tdarrow-reviewer-route-v1\n",
-        route.body() + "unknown\tvalue\n",
+        route.body().replace('  "format":', '  "format": "duplicate",\n  "format":', 1),
+        serialize(document(route.body()) | {"unknown": "value"}),
         route.body().replace("repository", "other").replace("bundled", "other"),
-        route.body().replace("darrow-reviewer-route-v1", "wrong"),
-        route.body().replace("\txhigh", "").replace("\thigh", ""),
+        route.body().replace("darrow-reviewer-route-v3", "wrong"),
+        serialize(document(route.body()) | {"selected_route": {"host": "codex"}}),
     ]
     for text in variants:
         path.write_text(text, encoding="utf-8")
@@ -325,17 +335,17 @@ def test_records_refuse_duplicates_unknown_and_incomplete(tmp_path: Path) -> Non
 def test_observed_record_validation(repo: Path, tmp_path: Path) -> None:
     projects, _ = transcript(repo, tmp_path)
     text = provider.verify(str(repo), "abc1", str(projects))
-    path = tmp_path / "record.tsv"
+    path = tmp_path / "record.json"
     for old, new in (
-        ("agent_id\tabc1", "agent_id\tunsafe/id"),
+        ('"abc1"', '"unsafe/id"'),
         ("current-host-environment-default", "invented"),
-        ("darrow-review-claude-route-v1", "wrong"),
-        ("observed_route\tclaude", "observed_route\tcodex"),
+        ("darrow-review-claude-route-v3", "wrong"),
+        ('"host": "claude"', '"host": "codex"'),
     ):
         path.write_text(text.replace(old, new), encoding="utf-8")
         with pytest.raises(ReviewError):
             routing.observed(str(path))
-    path.write_text(serialize([["format", "wrong"]]), encoding="utf-8")
+    path.write_text(serialize({"format": "wrong"}), encoding="utf-8")
     with pytest.raises(ReviewError):
         routing.observed(str(path))
 
@@ -354,7 +364,8 @@ def test_empty_or_unrelated_policy_uses_bundled_route(repo: Path, text: str) ->
     path.write_text(text, encoding="utf-8")
     selected = routing.resolve(str(repo), "codex")
     assert selected.source == "bundled"
-    assert "gpt-6-sol\txhigh" in selected.body()
+    assert Records(selected.body()).object("selected_route")["model"] == "gpt-6-sol"
+    assert Records(selected.body()).object("selected_route")["effort"] == "xhigh"
 
 
 def test_partial_transcript_and_substring_identity_are_rejected(
@@ -383,7 +394,7 @@ def test_transcript_verification_refuses_third_party_provider(
     repo: Path, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, selector: str
 ) -> None:
     projects, _ = transcript(repo, tmp_path)
-    record = tmp_path / "observed.tsv"
+    record = tmp_path / "observed.json"
     monkeypatch.setenv(selector, "1")
     with pytest.raises(ReviewError, match=selector):
         cli.verify_command(
diff --git a/plugins/capability/darrow-review/backend/tests/test_scope.py b/plugins/capability/darrow-review/backend/tests/test_scope.py
index 3055f617..63c56fbc 100644
--- a/plugins/capability/darrow-review/backend/tests/test_scope.py
+++ b/plugins/capability/darrow-review/backend/tests/test_scope.py
@@ -2,14 +2,20 @@
 
 import os
 from pathlib import Path
+from typing import cast
 
 import pytest
 
 from conftest import git
 from darrow_review import cli, result, scope
-from darrow_review.common import ReviewError, command_line, entrypoint, run
+from darrow_review.common import ReviewError, command_line, entrypoint, run, serialize
 from darrow_review.records import Records
-from fixtures import change, result_rows, write
+from fixtures import result_record
+
+
+def write_json(path: Path, value: dict[str, object]) -> str:
+    path.write_text(serialize(value), encoding="utf-8")
+    return str(path)
 
 
 def prepared(repo: Path, *extra: str) -> Records:
@@ -54,18 +60,18 @@ def test_all_layers_and_scope_binding(
     assert manifest.value("changed_count") == "2"
     patch = cli.scope_command(["show", "--manifest", manifest.value("manifest")])
     assert isinstance(patch, bytes) and b"+untracked" in patch and b"+unstaged" in patch
-    source = [
-        row for row in result_rows() if row[0] not in ("base", "target", "changed_file")
-    ]
-    source += result.scope_records(manifest.value("manifest"))
-    path = write(tmp_path / "result.tsv", source)
+    source = result_record()
+    source.update(result.scope_records(manifest.value("manifest")))
+    path = write_json(tmp_path / "result.json", source)
     assert "matches pinned scope" in cli.result_command(
         ["validate-scope", manifest.value("manifest"), path]
     )
-    wrong = write(tmp_path / "wrong.tsv", change(source, "target", "wrong"))
+    wrong = write_json(tmp_path / "wrong.json", source | {"target": "wrong"})
     with pytest.raises(ReviewError, match="differs from pinned scope"):
         result.validate_scope(manifest.value("manifest"), wrong)
-    assert "base\t" in cli.result_command(["scope-records", manifest.value("manifest")])
+    assert Records(
+        cli.result_command(["scope-records", manifest.value("manifest")])
+    ).value("base")
     for key in tuple(os.environ):
         if key.startswith("GIT_"):
             monkeypatch.delenv(key)
@@ -127,21 +133,32 @@ def test_scope_refusals_and_tampering(repo: Path, tmp_path: Path) -> None:
 
 def test_scope_identity_records(repo: Path, tmp_path: Path) -> None:
     (repo / "file.txt").write_text("changed", encoding="utf-8")
-    records = prepared(repo)
+    records = prepared(repo).data
+    files = cast(list[str], records["changed_files"])
     variants = [
-        change(records.rows, "changed_count", "2"),
-        change(records.rows, "changed_count", "0"),
-        change(records.rows, "changed_file", "relative"),
-        records.rows + records.get("base"),
-        records.rows + records.get("changed_file"),
-        change(records.rows, "format", "wrong"),
-        change(records.rows, "repository", "relative"),
-        change(records.rows, "diff", "relative"),
+        records | {"changed_count": "2"},
+        records | {"changed_count": "0"},
+        records | {"changed_count": "01"},
+        records | {"changed_files": ["relative"]},
+        records,
+        records | {"changed_files": [*files, *files]},
+        records | {"format": "wrong"},
+        records | {"repository": "relative"},
+        records | {"diff": "relative"},
     ]
     for index, variant in enumerate(variants):
-        path = write(tmp_path / f"scope-{index}.tsv", variant)
+        path = tmp_path / f"scope-{index}.json"
+        if variant is records:
+            path.write_text(
+                serialize(variant).replace(
+                    '  "base":', '  "base": "duplicate",\n  "base":', 1
+                ),
+                encoding="utf-8",
+            )
+        else:
+            write_json(path, variant)
         with pytest.raises(ReviewError):
-            result.scope_records(path)
+            result.scope_records(str(path))
 
 
 def test_fixed_command_from_unrelated_directory(repo: Path, tmp_path: Path) -> None:
@@ -165,24 +182,23 @@ def test_scope_set_requires_exact_binding(
     (repo / "file.txt").write_text("changed", encoding="utf-8")
     (repo / "extra.txt").write_text("untracked", encoding="utf-8")
     manifest = prepared(repo).value("manifest")
-    records = [
-        row for row in result_rows() if row[0] not in ("base", "target", "changed_file")
-    ]
-    records += result.scope_records(manifest)
-    original = write(tmp_path / "original.tsv", [records[0], *reversed(records[1:])])
+    records = result_record()
+    records.update(result.scope_records(manifest))
+    original = write_json(tmp_path / "original.json", records)
     result.validate_scope(manifest, original)
     variants = {
-        "base": change(records, "base", "wrong"),
-        "target": change(records, "target", "wrong"),
-        "omitted": [
-            row for row in records if row != ["changed_file", str(repo / "extra.txt")]
-        ],
-        "duplicate": [*records, ["changed_file", str(repo / "extra.txt")]],
-        "extra": [*records, ["changed_file", str(tmp_path / "unrelated")]],
+        "base": records | {"base": "wrong"},
+        "target": records | {"target": "wrong"},
+        "omitted": records | {"changed_files": [str(repo / "file.txt")]},
+        "duplicate": records
+        | {"changed_files": [*records["changed_files"], str(repo / "extra.txt")]},
+        "extra": records
+        | {"changed_files": [*records["changed_files"], str(tmp_path / "unrelated")]},
     }
-    path = write(tmp_path / "changed.tsv", variants[mutation])
+    path = write_json(tmp_path / "changed.json", variants[mutation])
     # Format validity alone cannot prove the scope identity or full file set.
-    cli.result_command(["validate", path])
+    if mutation != "duplicate":
+        cli.result_command(["validate", path])
     with pytest.raises(ReviewError) as error:
         result.validate_scope(manifest, path)
     assert error.value.code == 4
@@ -196,19 +212,30 @@ def test_incomplete_manifests_never_emit_scope_records(
 ) -> None:
     (repo / "file.txt").write_text("changed", encoding="utf-8")
     (repo / "extra.txt").write_text("untracked", encoding="utf-8")
-    records = prepared(repo).rows
+    records = prepared(repo).data
     variants = {
-        "target": [row for row in records if row[0] != "target"],
-        "count": [row for row in records if row[0] != "changed_count"],
-        "duplicate": [*records, ["changed_count", "2"]],
-        "invalid": change(records, "changed_count", "invalid"),
-        "file": [
-            row for row in records if row != ["changed_file", str(repo / "extra.txt")]
-        ],
+        "target": {key: value for key, value in records.items() if key != "target"},
+        "count": {
+            key: value for key, value in records.items() if key != "changed_count"
+        },
+        "duplicate": records,
+        "invalid": records | {"changed_count": "invalid"},
+        "file": records | {"changed_files": [str(repo / "file.txt")]},
     }
-    path = write(tmp_path / "bad.tsv", variants[mutation])
+    path = tmp_path / "bad.json"
+    if mutation == "duplicate":
+        path.write_text(
+            serialize(records).replace(
+                '  "changed_count":',
+                '  "changed_count": "2",\n  "changed_count":',
+                1,
+            ),
+            encoding="utf-8",
+        )
+    else:
+        write_json(path, variants[mutation])
     with pytest.raises(ReviewError):
-        cli.result_command(["scope-records", path])
+        cli.result_command(["scope-records", str(path)])
 
 
 def test_merge_base_excludes_main_only_paths(repo: Path) -> None:
@@ -227,4 +254,4 @@ def test_merge_base_excludes_main_only_paths(repo: Path) -> None:
     )
     assert packet.value("base") == base
     assert packet.value("target") == target
-    assert packet.get("changed_file") == [["changed_file", str(repo / "feature.txt")]]
+    assert packet.strings("changed_files") == [str(repo / "feature.txt")]
diff --git a/plugins/capability/darrow-review/backend/tests/test_storage.py b/plugins/capability/darrow-review/backend/tests/test_storage.py
index d1a3adad..2c1b5745 100644
--- a/plugins/capability/darrow-review/backend/tests/test_storage.py
+++ b/plugins/capability/darrow-review/backend/tests/test_storage.py
@@ -14,7 +14,7 @@
 
 from conftest import git
 from darrow_review import scope, storage
-from darrow_review.common import ReviewError
+from darrow_review.common import ReviewError, serialize
 from darrow_review.records import Records
 
 
@@ -76,9 +76,14 @@ def test_scope_is_private_user_state_and_worktrees_are_distinct(repo: Path) -> N
     assert storage.locate(linked, Records(second.read_text()).value("target")) == second
 
 
-def test_terminal_manifest_refuses_tsv_unsafe_repository_path(repo: Path) -> None:
-    with pytest.raises(ReviewError, match="tab or newline"):
-        storage.allocate_terminal(repo.parent / "unsafe\tpath")
+def test_terminal_manifest_accepts_tab_and_newline_in_repository_path(
+    repo: Path,
+) -> None:
+    unusual = repo.parent / "tab\tand\nnewline"
+    run = storage.allocate_terminal(unusual)
+    assert storage.fields_at(run / "scope.json")["repository"] == str(unusual)
+    with pytest.raises(ReviewError, match="NUL byte"):
+        storage.allocate_terminal(repo.parent / "unsafe\0path")
 
 
 def test_locate_returns_none_before_any_review(repo: Path) -> None:
@@ -127,7 +132,7 @@ def test_prune_ignores_unrelated_entries(repo: Path) -> None:
 def test_prune_refuses_corrupt_retained_dependency(repo: Path) -> None:
     original = packet(repo, content="first")
     current = packet(repo, content="second", prior_manifest=str(original))
-    (current.parent / "verification.tsv").write_bytes(b"\xff")
+    (current.parent / "verification.json").write_bytes(b"\xff")
     old = 1_600_000_000
     os.utime(original.parent, (old, old))
     with pytest.raises(ReviewError, match="dependency is unreadable"):
@@ -244,11 +249,16 @@ def test_prune_preserves_referenced_history_then_removes_whole_chain(
 
 def test_prune_preserves_prior_verification_record(repo: Path) -> None:
     original = packet(repo, content="first")
-    previous = original.parent / "verification.tsv"
-    previous.write_text("format\tdarrow-review-verification-v1\n", encoding="utf-8")
+    previous = original.parent / "verification.json"
+    previous.write_text(
+        serialize({"format": "darrow-review-verification-v3"}), encoding="utf-8"
+    )
     current = packet(repo, content="second")
-    (current.parent / "verification.tsv").write_text(
-        f"previous_verification\thash\t{previous}\n", encoding="utf-8"
+    (current.parent / "verification.json").write_text(
+        serialize(
+            {"previous_verification": {"checksum": "hash", "path": str(previous)}}
+        ),
+        encoding="utf-8",
     )
     old = 1_600_000_000
     os.utime(original.parent, (old, old))
diff --git a/plugins/capability/darrow-review/backend/tests/test_verification.py b/plugins/capability/darrow-review/backend/tests/test_verification.py
index 9a57b01c..7bf474f7 100644
--- a/plugins/capability/darrow-review/backend/tests/test_verification.py
+++ b/plugins/capability/darrow-review/backend/tests/test_verification.py
@@ -1,13 +1,19 @@
 from __future__ import annotations
 
+from copy import deepcopy
 from pathlib import Path
+from typing import Any
 
 import pytest
 
 from darrow_review import report
 from darrow_review.common import ReviewError, blob_hash, serialize
 from darrow_review.verification import validate_verification
-from fixtures import change, verification_rows, write
+from fixtures import verification_record, write
+
+
+def changed(value: dict[str, Any], **fields: Any) -> dict[str, Any]:
+    return deepcopy(value) | fields
 
 
 @pytest.mark.parametrize(
@@ -23,189 +29,198 @@
 def test_outcome_precedence(
     status: str, progress: str, target: str, outcome: str
 ) -> None:
-    records = change(
-        verification_rows(), "attempt", "spec:1:original", status, progress, "observed"
-    )
-    records = change(change(records, "current_target", target), "outcome", outcome)
-    assert validate_verification(serialize(records)).value("outcome") == outcome
-    with pytest.raises(ReviewError, match="outcome must be"):
-        validate_verification(
-            serialize(
-                change(records, "outcome", "wrong" if outcome == "clear" else "clear")
-            )
-        )
-
-
-def regression() -> list[str]:
-    return [
-        "regression",
-        "regression:1:spec:1:original",
-        "spec:1:original",
-        "1",
-        "spec",
-        "high",
-        "unresolved",
-        "progressing",
-        "f:2",
-        "request",
-        "new failure",
-        "repair it",
-        "regression test",
-    ]
-
-
-def first_round() -> list[list[str]]:
-    return change([*verification_rows(), regression()], "outcome", "continue")
-
-
-def later_round(tmp_path: Path) -> tuple[list[list[str]], str]:
-    previous = Path(write(tmp_path / "previous.tsv", first_round()))
-    later = change(
+    data = changed(verification_record(), current_target=target, outcome=outcome)
+    data["attempts"][0].update(status=status, progress=progress, evidence="observed")
+    assert validate_verification(serialize(data)).value("outcome") == outcome
+    data["outcome"] = "wrong" if outcome == "clear" else "clear"
+    with pytest.raises(ReviewError, match="outcome"):
+        validate_verification(serialize(data))
+
+
+def regression() -> dict[str, str]:
+    return {
+        "key": "regression:1:spec:1:original",
+        "caused_by": "spec:1:original",
+        "order": "1",
+        "axis": "spec",
+        "severity": "high",
+        "status": "unresolved",
+        "progress": "progressing",
+        "location": "f:2",
+        "source": "request",
+        "evidence": "new failure",
+        "repair_guidance": "repair it",
+        "resolution_evidence": "regression test",
+    }
+
+
+def first_round() -> dict[str, Any]:
+    data = verification_record()
+    data["regressions"] = [regression()]
+    data["outcome"] = "continue"
+    return data
+
+
+def later_round(tmp_path: Path) -> tuple[dict[str, Any], str]:
+    previous = Path(write(tmp_path / "previous.json", first_round()))
+    data = changed(
         first_round(),
-        "previous_verification",
-        blob_hash(previous.read_bytes()),
-        str(previous),
+        previous_verification={
+            "checksum": blob_hash(previous.read_bytes()),
+            "path": str(previous),
+        },
+        prior_target="repaired",
+        current_target="next",
+        history_targets=["original"],
     )
-    later = change(change(later, "prior_target", "repaired"), "current_target", "next")
-    later.append(["history_target", "original"])
-    return later, str(previous)
+    return data, str(previous)
 
 
 def test_later_history_and_rendering(tmp_path: Path) -> None:
-    records, _ = later_round(tmp_path)
-    parsed = validate_verification(serialize(records))
-    rendered = report.verification(parsed)
+    data, _ = later_round(tmp_path)
+    rendered = report.verification(validate_verification(serialize(data)))
     assert "Earlier targets" in rendered and "Repair-caused regressions" in rendered
     assert "repair it" in rendered and "regression test" in rendered
-    for kind in ("history_target", "regression", "original_finding"):
+    for field in ("history_targets", "regressions", "original_findings"):
+        variant = deepcopy(data)
+        del variant[field]
         with pytest.raises(ReviewError):
-            validate_verification(serialize([row for row in records if row[0] != kind]))
-    records.append(["history_target", "unbound"])
+            validate_verification(serialize(variant))
+    data["history_targets"].append("unbound")
     with pytest.raises(ReviewError, match="unbound target"):
-        validate_verification(serialize(records))
+        validate_verification(serialize(data))
 
 
-@pytest.mark.parametrize("field", [2, 3, 4, 5, 8, 9, 11, 12])
-def test_regression_immutable_fields(tmp_path: Path, field: int) -> None:
-    records, _ = later_round(tmp_path)
-    for row in records:
-        if row[0] == "regression":
-            row[field] += "changed"
+@pytest.mark.parametrize(
+    "field",
+    [
+        "caused_by",
+        "order",
+        "axis",
+        "severity",
+        "location",
+        "source",
+        "repair_guidance",
+        "resolution_evidence",
+    ],
+)
+def test_regression_immutable_fields(tmp_path: Path, field: str) -> None:
+    data, _ = later_round(tmp_path)
+    data["regressions"][0][field] += "changed"
     with pytest.raises(ReviewError):
-        validate_verification(serialize(records))
+        validate_verification(serialize(data))
 
 
 def test_closed_keys_and_checks() -> None:
-    records = verification_rows()
-    variants = [
-        [*records, records[6]],
-        [*records, records[5]],
-        change(records, "attempt", "unknown", "resolved", "resolved", "fixed"),
-        change(records, "check", "test", "applicable", "fail", "failed"),
-        [row for row in records if row[0] != "attempt"],
-        [*first_round(), regression()],
-        change(
-            records,
-            "original_finding",
-            "spec:2:original",
-            "spec",
-            "1",
-            "high",
-            "blocking",
-            "f:1",
-            "request",
-            "failure",
-        ),
-    ]
-    for variant in variants:
+    base = verification_record()
+    variants: list[dict[str, Any]] = []
+    for field in ("attempts", "original_findings"):
+        value = deepcopy(base)
+        value[field].append(deepcopy(value[field][0]))
+        variants.append(value)
+    unknown = deepcopy(base)
+    unknown["attempts"][0]["key"] = "unknown"
+    variants.append(unknown)
+    failed_check = deepcopy(base)
+    failed_check["checks"][0].update(status="fail", evidence="failed")
+    variants.append(failed_check)
+    missing_attempt = deepcopy(base)
+    del missing_attempt["attempts"]
+    variants.append(missing_attempt)
+    duplicate_regression = first_round()
+    duplicate_regression["regressions"].append(regression())
+    variants.append(duplicate_regression)
+    wrong_finding = deepcopy(base)
+    wrong_finding["original_findings"][0].update(key="spec:2:original")
+    variants.append(wrong_finding)
+    for value in variants:
         with pytest.raises(ReviewError):
-            validate_verification(serialize(variant))
-    failed = change(first_round(), "check", "test", "applicable", "fail", "failed")
+            validate_verification(serialize(value))
+    failed = first_round()
+    failed["checks"][0].update(status="fail", evidence="failed")
     validate_verification(serialize(failed))
-    blocked = change(
-        change(records, "check", "test", "applicable", "blocked", "unavailable"),
-        "outcome",
-        "blocked",
-    )
+    blocked = deepcopy(base)
+    blocked["checks"][0].update(status="blocked", evidence="unavailable")
+    blocked["outcome"] = "blocked"
     validate_verification(serialize(blocked))
 
 
 def test_advisory_and_evidence_gap() -> None:
-    records = verification_rows()
-    records[5][5] = "advisory"
-    records = change(
-        records, "attempt", "spec:1:original", "unresolved", "unchanged", "advisory"
+    data = verification_record()
+    data["original_findings"][0]["disposition"] = "advisory"
+    data["attempts"][0].update(
+        status="unresolved", progress="unchanged", evidence="advisory"
     )
-    validate_verification(serialize(records))
-    records = [
-        row
-        for row in verification_rows()
-        if row[0] not in ("original_finding", "attempt")
-    ]
-    records.append(["evidence_gap", "original unavailable"])
-    records = change(records, "outcome", "blocked")
-    parsed = validate_verification(serialize(records))
-    assert "No attempted findings" in report.verification(parsed)
-    assert "original unavailable" in report.verification(parsed)
+    validate_verification(serialize(data))
+    data = verification_record()
+    del data["original_findings"]
+    del data["attempts"]
+    data["evidence_gaps"] = ["original unavailable"]
+    data["outcome"] = "blocked"
+    rendered = report.verification(validate_verification(serialize(data)))
+    assert "No attempted findings" in rendered
+    assert "original unavailable" in rendered
+    del data["evidence_gaps"]
     with pytest.raises(ReviewError):
-        validate_verification(
-            serialize([row for row in records if row[0] != "evidence_gap"])
-        )
+        validate_verification(serialize(data))
 
 
 @pytest.mark.parametrize(
-    ("kind", "fields"),
+    ("field", "value"),
     [
-        ("previous_verification", ["none", "somewhere"]),
-        ("previous_verification", ["hash", "relative"]),
-        ("prior_target", ["not-original"]),
+        ("previous_verification", {"checksum": "none", "path": "somewhere"}),
+        ("previous_verification", {"checksum": "hash", "path": "relative"}),
+        ("prior_target", "not-original"),
     ],
 )
-def test_invalid_first_binding(kind: str, fields: list[str]) -> None:
+def test_invalid_first_binding(field: str, value: object) -> None:
     with pytest.raises(ReviewError):
-        validate_verification(serialize(change(verification_rows(), kind, *fields)))
+        validate_verification(
+            serialize(changed(verification_record(), **{field: value}))
+        )
     with pytest.raises(ReviewError):
         validate_verification(
-            serialize([*verification_rows(), ["history_target", "unexpected"]])
+            serialize(changed(verification_record(), history_targets=["unexpected"]))
         )
 
 
 def test_previous_artifact_integrity(tmp_path: Path) -> None:
-    records, previous = later_round(tmp_path)
+    data, previous = later_round(tmp_path)
     with pytest.raises(ReviewError, match="current artifact"):
-        validate_verification(serialize(records), previous)
+        validate_verification(serialize(data), previous)
     with pytest.raises(ReviewError, match="too deep"):
-        validate_verification(serialize(records), depth=50)
+        validate_verification(serialize(data), depth=50)
     with pytest.raises(ReviewError, match="does not match prior_target"):
-        validate_verification(serialize(change(records, "prior_target", "different")))
+        validate_verification(serialize(changed(data, prior_target="different")))
     Path(previous).write_text("tampered", encoding="utf-8")
     with pytest.raises(ReviewError, match="checksum"):
-        validate_verification(serialize(records))
+        validate_verification(serialize(data))
     Path(previous).unlink()
     with pytest.raises(ReviewError, match="invalid"):
-        validate_verification(serialize(records))
+        validate_verification(serialize(data))
 
 
 def test_original_immutability_and_history_duplicates(tmp_path: Path) -> None:
-    records, _ = later_round(tmp_path)
-    records[5][8] = "rewritten evidence"
+    data, _ = later_round(tmp_path)
+    data["original_findings"][0]["evidence"] = "rewritten evidence"
     with pytest.raises(ReviewError, match="original finding changed"):
-        validate_verification(serialize(records))
-    records, _ = later_round(tmp_path)
+        validate_verification(serialize(data))
+    data, _ = later_round(tmp_path)
+    data["history_targets"].append("original")
     with pytest.raises(ReviewError, match="duplicate history target"):
-        validate_verification(serialize([*records, ["history_target", "original"]]))
-    records.append(
-        [
-            "original_finding",
-            "spec:2:original",
-            "spec",
-            "2",
-            "low",
-            "advisory",
-            "f:3",
-            "request",
-            "unrelated",
-        ]
+        validate_verification(serialize(data))
+    data, _ = later_round(tmp_path)
+    data["original_findings"].append(
+        {
+            "key": "spec:2:original",
+            "axis": "spec",
+            "order": "2",
+            "severity": "low",
+            "disposition": "advisory",
+            "location": "f:3",
+            "source": "request",
+            "evidence": "unrelated",
+        }
     )
     with pytest.raises(ReviewError, match="new original finding"):
-        validate_verification(serialize(records))
+        validate_verification(serialize(data))
diff --git a/plugins/capability/darrow-review/backend/uv.lock b/plugins/capability/darrow-review/backend/uv.lock
index 542f190e..a867b7c5 100644
--- a/plugins/capability/darrow-review/backend/uv.lock
+++ b/plugins/capability/darrow-review/backend/uv.lock
@@ -1,6 +1,10 @@
 version = 1
 revision = 3
 requires-python = ">=3.10, <3.14"
+resolution-markers = [
+    "python_full_version >= '3.11'",
+    "python_full_version < '3.11'",
+]
 
 [[package]]
 name = "colorama"
@@ -86,7 +90,7 @@ toml = [
 
 [[package]]
 name = "darrow-review"
-version = "0.5.1"
+version = "0.7.2"
 source = { editable = "." }
 
 [package.dev-dependencies]
@@ -114,7 +118,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
diff --git a/plugins/capability/darrow-review/skills/code-review/SKILL.md b/plugins/capability/darrow-review/skills/code-review/SKILL.md
index 7f696491..3df53858 100644
--- a/plugins/capability/darrow-review/skills/code-review/SKILL.md
+++ b/plugins/capability/darrow-review/skills/code-review/SKILL.md
@@ -7,10 +7,10 @@ description: Review bounded code changes and verify attempted repairs against pr
 
 Return one independent, read-only comprehensive review or fix verification of
 a pinned change. Comprehensive mode preserves the existing
-`darrow-review-result-v1`; fix-verification mode uses the additive
-`darrow-review-verification-v1`. By default return one complete Markdown report.
-Return only the applicable validated TSV when the requester explicitly asks for
-raw TSV, the named protocol, or machine format. Never emit both forms. For an
+`darrow-review-result-v3`; fix-verification mode uses the additive
+`darrow-review-verification-v3`. By default return one complete Markdown report.
+Return only the applicable validated JSON when the requester explicitly asks for
+raw JSON, the named protocol, or machine format. Never emit both forms. For an
 explicit clause inside a larger goal, return the same normal report to the
 current goal owner, then exit this capability so the enclosing contract can
 apply its continuation rule.
@@ -19,14 +19,14 @@ apply its continuation rule.
 
 The final response is a protocol output, not a conversational summary. In
 human mode, first materialize the bundled renderer's complete stdout as the
-named Markdown artifact beside the TSV and confirm that artifact is readable
+named Markdown artifact beside the JSON and confirm that artifact is readable
 and nonempty. Then invoke the renderer once more as a standalone final tool
 call. Copy that last invocation's stdout in full as the entire final response,
 including every section through Scope and Sources. Do not reconstruct the
-report from the TSV or reader findings. After that final renderer invocation,
+report from the JSON or reader findings. After that final renderer invocation,
 issue no more tool calls and add no preface, recap, interpretation, or
 follow-up. This applies equally to standalone and composed review. In machine
-mode, apply the same rule to the validated TSV bytes.
+mode, apply the same rule to the validated JSON bytes.
 
 The human renderer leads with the verdict or outcome and the next action, then
 retains findings, checks, risks, scope, sources, and binding evidence in later
@@ -115,8 +115,8 @@ them.
 
 In either mode, the final presentation comes from the bundled renderer, not
 coordinator prose. Materialize comprehensive output as `review.md` beside
-`result.tsv` and fix-verification output as `verification.md` beside
-`verification.tsv`. A shortened response that preserves the heading or outcome
+`result.json` and fix-verification output as `verification.md` beside
+`verification.json`. A shortened response that preserves the heading or outcome
 but omits a rendered section is incomplete.
 
 ### 1. Pin the comprehensive scope
@@ -153,7 +153,7 @@ Exit 2 means invalid/unreadable scope, exit 3 an empty declared diff, and exit
 4 an ambiguous merge base. For one of these terminal outcomes, read
 [`references/result-protocol.md`](references/result-protocol.md) completely,
 run `review-scope allocate-terminal --repo <bound-repo>` to obtain an absolute
-`artifact_dir`, then write and validate its blocked result TSV there,
+`artifact_dir`, then write and validate its blocked result JSON there,
 then return the selected presentation without invoking a reader.
 
 Otherwise treat the returned absolute manifest, changed paths, target
@@ -187,14 +187,13 @@ from implementation.
 Discover applicable, deterministic, non-destructive format, lint, type, build,
 and test commands from repository guidance and configuration. Run the narrowest
 commands that settle the changed scope. For every applicable command, choose a
-unique `check-N.tsv` beneath the scope artifact directory and run:
+unique `check-N.json` beneath the scope artifact directory and run:
 
 ```sh
 uv run --quiet --no-project "$backend/scripts/run_locked.py" review-check run --output "$check_record" --command "$literal_command"
 ```
 
-Read the retained `darrow-review-check-v1` record and copy its `check` row
-byte-for-byte into the aggregate result and reader evidence. Never infer,
+Read the retained `darrow-review-check-v3` object and preserve its `checks` entry values exactly in the aggregate result and reader evidence. Never infer,
 restate, or override its status from memory. Never execute an applicable
 command directly: `review-check` is its sole execution boundary. Exit 0 is
 `pass`, an ordinary nonzero exit is `fail`, and an unavailable command is
@@ -255,8 +254,8 @@ Different repair advice is not a reason to merge two findings and synthesize a
 third recommendation. For a duplicate, retain one complete reader-authored
 record. Legacy records may lack guidance; do not manufacture it.
 
-Assemble the TSV result beneath the scope artifact directory. Copy its base,
-target, and changed-file records using `scope-records`; never retype their
+Assemble the JSON result beneath the scope artifact directory. Copy its base,
+target, and `changed_files` fields using `scope-records`; never retype their
 identifiers. Run `validate-scope` with the pinned manifest and result before
 rendering, as specified in the result protocol. A schema-only pass cannot
 establish scope binding.
@@ -277,10 +276,10 @@ uv run --quiet --no-project "$backend/scripts/run_locked.py" review-report rende
 ```
 
 Copy its complete stdout as the entire response. The renderer validates the
-TSV, preserves every semantic field, and escapes hostile Markdown content. Only
-when the requester explicitly asked for raw TSV, v1, or machine format, copy
-the validated TSV bytes verbatim instead. Never concatenate the Markdown and
-TSV forms.
+JSON, preserves every semantic field, and escapes hostile Markdown content. Only
+when the requester explicitly asked for raw JSON, v3, or machine format, copy
+the validated JSON bytes verbatim instead. Never concatenate the Markdown and
+JSON forms.
 
 For a composed invocation with `verdict=pass`, set `next_action` to return
 control to the enclosing goal, return the selected review presentation, and exit this
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/both-axes.yaml b/plugins/capability/darrow-review/skills/code-review/evals/both-axes.yaml
index aee79973..f9ed0dad 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/both-axes.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/both-axes.yaml
@@ -26,42 +26,30 @@ fixture:
         console.log("parsing", value);
         return Number(value);
       }
-  setup: git status --porcelain --untracked-files=all >.git/status-before
+  setup: |
+    git status --porcelain --untracked-files=all >.git/status-before
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
+    cp "{{case_dir}}/../../../backend/tests/evals/assert_guidance.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: each finding retains guidance from its originating reader
     run: |
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n 1)
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n 1)
       test -n "$record" || exit 1
-      artifact_dir=$(dirname "$record")
-      awk -F '\t' 'BEGIN { OFS="\t" }
-        $1 == "finding" { if (NF != 9 || $8 == "" || $9 == "") exit 1; print $2,$3,$4,$5,$6,$7,$8,$9; n++ }
-        END { if (!n) exit 1 }' "$record" >.git/aggregate-guidance || exit 1
-      : >.git/reader-guidance
-      for file in "$artifact_dir"/*; do
-        test -f "$file" || continue
-        if test "$(sed -n 1p "$file")" = "$(printf 'format\tdarrow-review-axis-v1')"; then
-          awk -F '\t' 'BEGIN { OFS="\t" }
-            $1 == "axis" { axis=$2 }
-            $1 == "finding" { print axis,$2,$3,$4,$5,$6,$7,$8 }' "$file" >>.git/reader-guidance
-        fi
-      done
-      while IFS= read -r finding; do
-        grep -Fx -- "$finding" .git/reader-guidance >/dev/null || exit 1
-      done <.git/aggregate-guidance
+      python3 .git/eval-checks/review/tests/evals/assert_guidance.py "$record" finding
   - name: review is read-only
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
-  - name: canonical Markdown handoff is materialized beside the TSV
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
+  - name: canonical Markdown handoff is materialized beside the JSON
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       report=$(dirname "$record")/review.md;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
@@ -70,7 +58,7 @@ checks:
       cmp .git/expected-review.md "$report"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/empty-diff.yaml b/plugins/capability/darrow-review/skills/code-review/evals/empty-diff.yaml
index 3d5955e4..f9895473 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/empty-diff.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/empty-diff.yaml
@@ -9,35 +9,38 @@ fixture:
     - message: "chore: init"
       files:
         README.md: "# Clean fixture\n"
+  setup: |
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: clean repository remains clean
     run: test -z "$(git status --porcelain --untracked-files=all)"
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: empty scope blocks without changed files or findings
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      grep -F 'standards	blocked' "$record" >/dev/null &&
-      grep -F 'spec	not_available' "$record" >/dev/null &&
-      grep -F 'verdict	blocked' "$record" >/dev/null &&
-      ! grep -E '^(changed_file|finding)	' "$record" >/dev/null
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has standards blocked &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has spec not_available &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict blocked &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key changed_files &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key findings
   - name: terminal scope failure invokes no reviewer
     run: >-
       case "$DARROW_EVAL_HARNESS" in
       codex) ! grep -F '"type":"darrow.codex_native_spawn"' .git/retained-harness.jsonl >/dev/null ;;
       claude) ! grep -F '"type":"darrow.review_agent_launch"' .git/retained-harness.jsonl >/dev/null ;;
       *) exit 2 ;; esac
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-progress-advisory.yaml b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-progress-advisory.yaml
index 3af3dbd8..04b18235 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-progress-advisory.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-progress-advisory.yaml
@@ -32,21 +32,27 @@ fixture:
     set -eu
     backend=$(cd "{{case_dir}}/../../../backend" && pwd -P)
     prior_output=$(uv run --quiet --frozen --no-dev --project "$backend" review-scope prepare --repo "$PWD" --base HEAD^ --target HEAD)
-    prior_manifest=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "manifest" { print $2 }')
-    original_target=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "target" { print $2 }')
-    {
-      printf 'original_target\t%s\n' "$original_target"
-      printf 'prior_target\t%s\n' "$original_target"
-      printf 'prior_manifest\t%s\n' "$prior_manifest"
-      printf 'previous_verification\tnone\tnone\n'
-      printf 'original_finding\tspec:1:%s\tspec\t1\thigh\tblocking\tsrc/value.js:1\trequirement: value must be numeric and at least 2\tvalue was non-numeric\n' "$original_target"
-      printf 'original_finding\tstandards:2:%s\tstandards\t2\tlow\tadvisory\tsrc/value.js:2\t%s/AGENTS.md\tthe legacy comment remained\n' "$original_target" "$PWD"
-      printf 'attempted\tspec:1:%s\n' "$original_target"
-      printf 'attempted\tstandards:2:%s\n' "$original_target"
-    } >.git/verification-input
+    prior_manifest=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' manifest)
+    original_target=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' target)
+    python3 - "$original_target" "$prior_manifest" "$PWD" <<'PY' >.git/verification-input
+    import json, sys
+    target, manifest, repo = sys.argv[1:]
+    json.dump({
+        "original_target": target,
+        "prior_target": target,
+        "prior_manifest": manifest,
+        "previous_verification": {"checksum": "none", "path": "none"},
+        "original_findings": [
+            {"key": f"spec:1:{target}", "axis": "spec", "order": "1", "severity": "high", "disposition": "blocking", "location": "src/value.js:1", "source": "requirement: value must be numeric and at least 2", "evidence": "value was non-numeric"},
+            {"key": f"standards:2:{target}", "axis": "standards", "order": "2", "severity": "low", "disposition": "advisory", "location": "src/value.js:2", "source": f"{repo}/AGENTS.md", "evidence": "the legacy comment remained"},
+        ],
+        "attempted": [f"spec:1:{target}", f"standards:2:{target}"],
+    }, sys.stdout)
+    PY
     printf '%s\n' "$backend" >.git/review-backend
     git status --porcelain --untracked-files=all >.git/status-before
     git hash-object src/value.js >.git/value-before
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: progress verification remains read only
     run: >-
@@ -56,21 +62,21 @@ checks:
       cmp .git/value-before .git/value-after
   - name: progressing blocker keeps convergence open
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1') &&
       test -n "$tool" &&
       test -n "$record" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record" &&
-      grep -F 'outcome	continue' "$record" >/dev/null &&
-      original_target=$(awk -F '\t' '$1 == "original_target" { print $2 }' .git/verification-input) &&
-      awk -F '\t' -v key="spec:1:$original_target" '$1 == "attempt" && $2 == key && $3 == "unresolved" && $4 == "progressing" { found=1 } END { exit found ? 0 : 1 }' "$record"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has outcome continue &&
+      original_target=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["original_target"])') &&
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); assert any(item["key"]==sys.argv[2] and item["status"]=="unresolved" and item["progress"]=="progressing" for item in record["attempts"])' "$record" "spec:1:$original_target"
   - name: unresolved advisory does not become a blocker
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
-      original_target=$(awk -F '\t' '$1 == "original_target" { print $2 }' .git/verification-input) &&
-      awk -F '\t' -v key="standards:2:$original_target" '$1 == "attempt" && $2 == key && $3 == "unresolved" && $4 == "unchanged" { found=1 } END { exit found ? 0 : 1 }' "$record"
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
+      original_target=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["original_target"])') &&
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); assert any(item["key"]==sys.argv[2] and item["status"]=="unresolved" and item["progress"]=="unchanged" for item in record["attempts"])' "$record" "standards:2:$original_target"
   - name: final response is the complete rendered verification report
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
       test -n "$record" &&
       report=$(dirname "$record")/verification.md &&
       test -r "$report" && test -s "$report" &&
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-regression-scope.yaml b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-regression-scope.yaml
index f9c13ad3..f870cd53 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-regression-scope.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-regression-scope.yaml
@@ -44,39 +44,37 @@ fixture:
     set -eu
     backend=$(cd "{{case_dir}}/../../../backend" && pwd -P)
     prior_output=$(uv run --quiet --frozen --no-dev --project "$backend" review-scope prepare --repo "$PWD" --base HEAD^ --target HEAD)
-    prior_manifest=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "manifest" { print $2 }')
-    original_target=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "target" { print $2 }')
-    {
-      printf 'original_target\t%s\n' "$original_target"
-      printf 'prior_target\t%s\n' "$original_target"
-      printf 'prior_manifest\t%s\n' "$prior_manifest"
-      printf 'previous_verification\tnone\tnone\n'
-      printf 'original_finding\tspec:1:%s\tspec\t1\thigh\tblocking\tsrc/math.js:1\trequirement: multiplier must be 2\tmultiplier was 1\n' "$original_target"
-      printf 'attempted\tspec:1:%s\n' "$original_target"
-    } >.git/verification-input
+    prior_manifest=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' manifest)
+    original_target=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' target)
+    python3 - "$original_target" "$prior_manifest" <<'PY' >.git/verification-input
+    import json, sys
+    target, manifest = sys.argv[1:]
+    json.dump({
+        "original_target": target,
+        "prior_target": target,
+        "prior_manifest": manifest,
+        "previous_verification": {"checksum": "none", "path": "none"},
+        "original_findings": [{
+            "key": f"spec:1:{target}", "axis": "spec", "order": "1",
+            "severity": "high", "disposition": "blocking",
+            "location": "src/math.js:1",
+            "source": "requirement: multiplier must be 2",
+            "evidence": "multiplier was 1",
+        }],
+        "attempted": [f"spec:1:{target}"],
+    }, sys.stdout)
+    PY
     printf '%s\n' "$backend" >.git/review-backend
     git status --porcelain --untracked-files=all >.git/status-before
     git hash-object src/math.js >.git/math-before
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
+    cp "{{case_dir}}/../../../backend/tests/evals/assert_guidance.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: new repair regression carries verifier-authored guidance
     run: |
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1)
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1)
       test -n "$record" || exit 1
-      artifact_dir=$(dirname "$record")
-      awk -F '\t' 'BEGIN { OFS="\t" }
-        $1 == "regression" { n++; if (NF != 13 || $12 == "" || $13 == "") bad=1; print $3,$6,$9,$10,$11,$12,$13 }
-        END { exit !(n && !bad) }' "$record" >.git/aggregate-regression-guidance || exit 1
-      : >.git/reader-regression-guidance
-      for file in "$artifact_dir"/*; do
-        test -f "$file" || continue
-        if test "$(sed -n 1p "$file")" = "$(printf 'format\tdarrow-review-fix-axis-v1')"; then
-          awk -F '\t' 'BEGIN { OFS="\t" }
-            $1 == "regression" { print $2,$3,$4,$5,$6,$7,$8 }' "$file" >>.git/reader-regression-guidance
-        fi
-      done
-      while IFS= read -r finding; do
-        grep -Fx -- "$finding" .git/reader-regression-guidance >/dev/null || exit 1
-      done <.git/aggregate-regression-guidance
+      python3 .git/eval-checks/review/tests/evals/assert_guidance.py "$record" regression
   - name: regression verification remains read only
     run: >-
       git status --porcelain --untracked-files=all >.git/status-after &&
@@ -85,22 +83,21 @@ checks:
       cmp .git/math-before .git/math-after
   - name: direct regression enters the closed convergence set
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1') &&
       test -n "$tool" &&
       test -n "$record" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record" &&
-      awk -F '\t' '$1 == "check" && $2 == "bash check.sh" && $3 == "applicable" &&
-      $4 == "fail" && $5 ~ /scale\(-2\)/ { found=1 } END { exit found ? 0 : 1 }' "$record" &&
-      original_target=$(awk -F '\t' '$1 == "original_target" { print $2 }' .git/verification-input) &&
-      awk -F '\t' -v cause="spec:1:$original_target" '$1 == "regression" && $2 == "regression:1:" cause && $3 == cause && $4 == 1 { found=1 } END { exit found ? 0 : 1 }' "$record" &&
-      grep -F 'outcome	continue' "$record" >/dev/null
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); assert any(item["command"]=="bash check.sh" and item["applicability"]=="applicable" and item["status"]=="fail" and "scale(-2)" in item["evidence"] for item in record["checks"])' "$record" &&
+      original_target=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["original_target"])') &&
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); cause=sys.argv[2]; assert any(item["key"]=="regression:1:"+cause and item["caused_by"]==cause and item["order"]=="1" for item in record["regressions"])' "$record" "spec:1:$original_target" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has outcome continue
   - name: unrelated observation is excluded
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
-      ! grep -F 'renaming scale' "$record" >/dev/null
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" not-contains 'renaming scale'
   - name: final response is the complete rendered verification report
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
       test -n "$record" &&
       report=$(dirname "$record")/verification.md &&
       test -r "$report" && test -s "$report" &&
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-regression-second-round.yaml b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-regression-second-round.yaml
index fd747400..19c7c504 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-regression-second-round.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-regression-second-round.yaml
@@ -31,39 +31,65 @@ fixture:
     cp config.env .git/current-config
     printf 'MODE=good\n' >config.env
     prior_output=$(uv run --quiet --frozen --no-dev --project "$backend" review-scope prepare --repo "$PWD" --base HEAD --target WORKTREE)
-    prior_manifest=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "manifest" { print $2 }')
-    prior_target=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "target" { print $2 }')
-    prior_verification=$(dirname "$prior_manifest")/verification.tsv
+    prior_manifest=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' manifest)
+    prior_target=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' target)
+    prior_verification=$(dirname "$prior_manifest")/verification.json
     original_target=ORIGINAL-TARGET-SECOND-ROUND
     original_key=standards:1:$original_target
     regression_key=regression:1:$original_key
-    {
-      printf 'format\tdarrow-review-verification-v1\n'
-      printf 'original_target\t%s\n' "$original_target"
-      printf 'prior_target\t%s\n' "$original_target"
-      printf 'current_target\t%s\n' "$prior_target"
-      printf 'previous_verification\tnone\tnone\n'
-      printf 'original_finding\t%s\tstandards\t1\thigh\tblocking\tconfig.env:1\t%s/AGENTS.md\tMODE was bad\n' "$original_key" "$PWD"
-      printf 'attempt\t%s\tresolved\tresolved\tMODE is good\n' "$original_key"
-      printf 'regression\t%s\t%s\t1\tstandards\thigh\tunresolved\tprogressing\tconfig.env:2\t%s/AGENTS.md\tRESULT is missing after the repair\n' "$regression_key" "$original_key" "$PWD"
-      printf 'check\tbash check.sh\tapplicable\tfail\tRESULT is missing\n'
-      printf 'outcome\tcontinue\n'
-      printf 'next_action\trepair the carried regression\n'
-    } >"$prior_verification"
+    python3 - "$original_target" "$prior_target" "$original_key" "$regression_key" "$PWD" <<'PY' >"$prior_verification"
+    import json, sys
+    original, prior, original_key, regression_key, repo = sys.argv[1:]
+    json.dump({
+        "format": "darrow-review-verification-v3",
+        "original_target": original,
+        "prior_target": original,
+        "current_target": prior,
+        "previous_verification": {"checksum": "none", "path": "none"},
+        "original_findings": [{
+            "key": original_key, "axis": "standards", "order": "1",
+            "severity": "high", "disposition": "blocking",
+            "location": "config.env:1", "source": f"{repo}/AGENTS.md",
+            "evidence": "MODE was bad",
+        }],
+        "attempts": [{
+            "key": original_key, "status": "resolved",
+            "progress": "resolved", "evidence": "MODE is good",
+        }],
+        "regressions": [{
+            "key": regression_key, "caused_by": original_key, "order": "1",
+            "axis": "standards", "severity": "high",
+            "status": "unresolved", "progress": "progressing",
+            "location": "config.env:2", "source": f"{repo}/AGENTS.md",
+            "evidence": "RESULT is missing after the repair",
+        }],
+        "checks": [{
+            "command": "bash check.sh", "applicability": "applicable",
+            "status": "fail", "evidence": "RESULT is missing",
+        }],
+        "outcome": "continue",
+        "next_action": "repair the carried regression",
+    }, sys.stdout)
+    PY
     uv run --quiet --frozen --no-dev --project "$backend" review-result validate-verification "$prior_verification"
     prior_hash=$(git hash-object --no-filters "$prior_verification")
-    {
-      printf 'original_target\t%s\n' "$original_target"
-      printf 'prior_target\t%s\n' "$prior_target"
-      printf 'prior_manifest\t%s\n' "$prior_manifest"
-      printf 'previous_verification\t%s\t%s\n' "$prior_hash" "$prior_verification"
-      printf 'original_key\t%s\n' "$original_key"
-      printf 'regression_key\t%s\n' "$regression_key"
-    } >.git/verification-input
+    python3 - "$original_target" "$prior_target" "$prior_manifest" "$prior_hash" "$prior_verification" "$original_key" "$regression_key" <<'PY' >.git/verification-input
+    import json, sys
+    original, prior, manifest, prior_hash, verification, original_key, regression_key = sys.argv[1:]
+    json.dump({
+        "original_target": original,
+        "prior_target": prior,
+        "prior_manifest": manifest,
+        "previous_verification": {"checksum": prior_hash, "path": verification},
+        "original_key": original_key,
+        "regression_key": regression_key,
+    }, sys.stdout)
+    PY
     cp .git/current-config config.env
     git hash-object config.env >.git/config-before
     git status --porcelain --untracked-files=all >.git/status-before
     printf '%s\n' "$backend" >.git/review-backend
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: second verification remains read only
     run: >-
@@ -75,27 +101,25 @@ checks:
     run: >-
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1') &&
       test -n "$tool" &&
-      regression_key=$(awk -F '\t' '$1 == "regression_key" { print $2 }' .git/verification-input) &&
-      previous_path=$(awk -F '\t' '$1 == "previous_verification" { print $3 }' .git/verification-input) &&
+      regression_key=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["regression_key"])') &&
+      previous_path=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["previous_verification"]["path"])') &&
       previous_relative=${previous_path#"$PWD"/} &&
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' ! -path "$previous_relative" -name verification.tsv -type f -print) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' ! -path "$previous_relative" -name verification.json -type f -print) &&
       test -n "$record" && test "$record" != "$previous_path" &&
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record" &&
-      awk -F '\t' -v key="$regression_key" '$1 == "regression" && $2 == key && $7 == "resolved" && $8 == "resolved" { found=1 } END { exit found ? 0 : 1 }' "$record" &&
-      awk -F '\t' '$1 == "outcome" && $2 == "clear" { found=1 } END { exit found ? 0 : 1 }' "$record"
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); assert any(item["key"]==sys.argv[2] and item["status"]=="resolved" and item["progress"]=="resolved" for item in record["regressions"])' "$record" "$regression_key" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has outcome clear
   - name: verification binds the previous artifact
     run: >-
-      previous_path=$(awk -F '\t' '$1 == "previous_verification" { print $3 }' .git/verification-input) &&
+      previous_path=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["previous_verification"]["path"])') &&
       previous_relative=${previous_path#"$PWD"/} &&
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' ! -path "$previous_relative" -name verification.tsv -type f -print) &&
-      expected=$(awk -F '\t' '$1 == "previous_verification" { print $2 "\t" $3 }' .git/verification-input) &&
-      actual=$(awk -F '\t' '$1 == "previous_verification" { print $2 "\t" $3 }' "$record") &&
-      test "$actual" = "$expected"
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' ! -path "$previous_relative" -name verification.json -type f -print) &&
+      python3 -c 'import json,sys; expected=json.load(open(sys.argv[1]))["previous_verification"]; actual=json.load(open(sys.argv[2]))["previous_verification"]; assert expected==actual' .git/verification-input "$record"
   - name: final response is the complete rendered verification report
     run: >-
-      previous_path=$(awk -F '\t' '$1 == "previous_verification" { print $3 }' .git/verification-input) &&
+      previous_path=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["previous_verification"]["path"])') &&
       previous_relative=${previous_path#"$PWD"/} &&
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' ! -path "$previous_relative" -name verification.tsv -type f -print) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' ! -path "$previous_relative" -name verification.json -type f -print) &&
       test -n "$record" &&
       report=$(dirname "$record")/verification.md &&
       test -r "$report" && test -s "$report" &&
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-resolved.yaml b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-resolved.yaml
index 6c3d6ca7..71b0fef0 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-resolved.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-resolved.yaml
@@ -41,23 +41,30 @@ fixture:
     set -eu
     backend=$(cd "{{case_dir}}/../../../backend" && pwd -P)
     prior_output=$(uv run --quiet --frozen --no-dev --project "$backend" review-scope prepare --repo "$PWD" --base HEAD^ --target HEAD)
-    prior_manifest=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "manifest" { print $2 }')
-    original_target=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "target" { print $2 }')
-    {
-      printf 'original_target\t%s\n' "$original_target"
-      printf 'prior_target\t%s\n' "$original_target"
-      printf 'prior_manifest\t%s\n' "$prior_manifest"
-      printf 'previous_verification\tnone\tnone\n'
-      printf 'original_finding\tstandards:1:%s\tstandards\t1\thigh\tblocking\tsrc/config.js:1\t%s/AGENTS.md\tDEBUG remained enabled\n' "$original_target" "$PWD"
-      printf 'original_finding\tspec:2:%s\tspec\t2\thigh\tblocking\tsrc/config.js:2\trequirement: TIMEOUT_MS must be 2500\tTIMEOUT_MS was 1000\n' "$original_target"
-      printf 'original_finding\tspec:3:%s\tspec\t3\tlow\tadvisory\tsrc/config.js:3\tmaintenance note\tLEGACY was retained\n' "$original_target"
-      printf 'attempted\tstandards:1:%s\n' "$original_target"
-      printf 'attempted\tspec:2:%s\n' "$original_target"
-      printf 'attempted\tspec:3:%s\n' "$original_target"
-    } >.git/verification-input
+    prior_manifest=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' manifest)
+    original_target=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' target)
+    python3 - "$original_target" "$prior_manifest" "$PWD" <<'PY' >.git/verification-input
+    import json, sys
+    target, manifest, repo = sys.argv[1:]
+    json.dump({
+        "original_target": target,
+        "prior_target": target,
+        "prior_manifest": manifest,
+        "previous_verification": {"checksum": "none", "path": "none"},
+        "original_findings": [
+            {"key": f"standards:1:{target}", "axis": "standards", "order": "1", "severity": "high", "disposition": "blocking", "location": "src/config.js:1", "source": f"{repo}/AGENTS.md", "evidence": "DEBUG remained enabled"},
+            {"key": f"spec:2:{target}", "axis": "spec", "order": "2", "severity": "high", "disposition": "blocking", "location": "src/config.js:2", "source": "requirement: TIMEOUT_MS must be 2500", "evidence": "TIMEOUT_MS was 1000"},
+            {"key": f"spec:3:{target}", "axis": "spec", "order": "3", "severity": "low", "disposition": "advisory", "location": "src/config.js:3", "source": "maintenance note", "evidence": "LEGACY was retained"},
+        ],
+        "attempted": [
+            f"standards:1:{target}", f"spec:2:{target}", f"spec:3:{target}",
+        ],
+    }, sys.stdout)
+    PY
     git status --porcelain --untracked-files=all >.git/status-before
     git hash-object src/config.js >.git/config-before
     printf '%s\n' "$backend" >.git/review-backend
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: verification preserves the repair bytes
     run: git hash-object src/config.js >.git/config-after; cmp .git/config-before .git/config-after
@@ -65,25 +72,29 @@ checks:
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
   - name: current verification scope remains in the requested repository
     run: >-
-      verification=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
+      verification=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
       test -n "$verification" &&
       artifact_dir=$(cd "$(dirname "$verification")" && pwd -P) &&
-      manifest=$artifact_dir/scope.tsv &&
+      manifest=$artifact_dir/scope.json &&
       test -r "$manifest" &&
       expected_repo=$(pwd -P) &&
       git_dir=$(git rev-parse --absolute-git-dir) &&
       git_dir=$(cd "$git_dir" && pwd -P) &&
-      test "$(awk -F '\t' '$1 == "repository" { print $2 }' "$manifest")" = "$expected_repo" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$manifest" has repository "$expected_repo" &&
       case "$manifest" in "$git_dir"/*) ;; *) exit 1 ;; esac
   - name: additive verification artifact validates and clears
-    run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
-      tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1') &&
-      test -n "$tool" &&
-      test -n "$record" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record" &&
-      grep -F 'outcome	clear' "$record" >/dev/null &&
-      awk -F '\t' '$1 == "attempt" { count++; if ($3 != "resolved" || $4 != "resolved") invalid=1 }
-      END { exit !(count == 3 && !invalid) }' "$record"
+    run: |
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1)
+      tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n 1)
+      test -n "$tool" && test -n "$record" || exit 1
+      uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record" || exit 1
+      python3 - "$record" <<'PY'
+      import json, sys
+      record = json.load(open(sys.argv[1]))
+      attempts = record['attempts']
+      assert record['outcome'] == 'clear'
+      assert len(attempts) == 3 and all(item['status'] == item['progress'] == 'resolved' for item in attempts)
+      PY
   - name: both fix verifiers retain exact default route evidence
     run: >-
       uv run --quiet --frozen --no-dev --project .git/eval-checks/review
@@ -91,7 +102,7 @@ checks:
       --host "$DARROW_EVAL_HARNESS" --profile default --axes standards spec
   - name: final response is the complete rendered verification report
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
       test -n "$record" &&
       report=$(dirname "$record")/verification.md &&
       test -r "$report" && test -s "$report" &&
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-unavailable.yaml b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-unavailable.yaml
index 0f9117ba..3e8a3169 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-unavailable.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/fix-verification-unavailable.yaml
@@ -28,16 +28,25 @@ fixture:
     set -eu
     backend=$(cd "{{case_dir}}/../../../backend" && pwd -P)
     prior_output=$(uv run --quiet --frozen --no-dev --project "$backend" review-scope prepare --repo "$PWD" --base HEAD^ --target HEAD)
-    prior_manifest=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "manifest" { print $2 }')
-    original_target=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "target" { print $2 }')
-    {
-      printf 'original_target\t%s\n' "$original_target"
-      printf 'prior_target\t%s\n' "$original_target"
-      printf 'prior_manifest\t%s\n' "$prior_manifest"
-      printf 'previous_verification\tnone\tnone\n'
-      printf 'original_finding\tstandards:1:%s\tstandards\t1\thigh\tblocking\tendpoint.txt:1\t%s/AGENTS.md\tendpoint remained on v1\n' "$original_target" "$PWD"
-      printf 'attempted\tstandards:1:%s\n' "$original_target"
-    } >.git/verification-input
+    prior_manifest=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' manifest)
+    original_target=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' target)
+    python3 - "$original_target" "$prior_manifest" "$PWD" <<'PY' >.git/verification-input
+    import json, sys
+    target, manifest, repo = sys.argv[1:]
+    json.dump({
+        "original_target": target,
+        "prior_target": target,
+        "prior_manifest": manifest,
+        "previous_verification": {"checksum": "none", "path": "none"},
+        "original_findings": [{
+            "key": f"standards:1:{target}", "axis": "standards", "order": "1",
+            "severity": "high", "disposition": "blocking",
+            "location": "endpoint.txt:1", "source": f"{repo}/AGENTS.md",
+            "evidence": "endpoint remained on v1",
+        }],
+        "attempted": [f"standards:1:{target}"],
+    }, sys.stdout)
+    PY
     git status --porcelain --untracked-files=all >.git/status-before
     git hash-object endpoint.txt >.git/endpoint-before
     printf '%s\n' "$backend" >.git/review-backend
@@ -49,26 +58,28 @@ checks:
       git status --porcelain --untracked-files=all >.git/status-after &&
       cmp .git/status-before .git/status-after
   - name: unavailable evidence produces a valid blocked artifact
-    run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
-      tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1') &&
-      test -n "$tool" &&
-      test -n "$record" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record" &&
-      check_row=$(awk -F '\t' '$1 == "check" && $2 == "bash external-check.sh" &&
-      $3 == "applicable" && $4 == "blocked" { print; found++ }
-      END { exit found == 1 ? 0 : 1 }' "$record") &&
-      artifact_dir=$(dirname "$record") && captured=false &&
-      for capture in "$artifact_dir"/check-*.tsv; do
-      test -f "$capture" || continue;
-      if grep -F -x 'format	darrow-review-check-v1' "$capture" >/dev/null &&
-      grep -F -x "$check_row" "$capture" >/dev/null; then captured=true; fi;
-      done && test "$captured" = true &&
-      awk -F '\t' '$1 == "evidence_gap" { found=1 } END { exit found ? 0 : 1 }' "$record" &&
-      awk -F '\t' '$1 == "regression" { found=1 } END { exit found ? 1 : 0 }' "$record" &&
-      awk -F '\t' '$1 == "outcome" && $2 == "blocked" { found=1 } END { exit found ? 0 : 1 }' "$record"
+    run: |
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1)
+      tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n 1)
+      test -n "$tool" && test -n "$record" || exit 1
+      uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record" || exit 1
+      python3 - "$record" <<'PY'
+      import json, pathlib, sys
+      path = pathlib.Path(sys.argv[1])
+      record = json.loads(path.read_text())
+      checks = [item for item in record['checks'] if item['command'] == 'bash external-check.sh' and item['applicability'] == 'applicable' and item['status'] == 'blocked']
+      assert len(checks) == 1
+      assert any(
+          (capture := json.loads(file.read_text()))['format'] == 'darrow-review-check-v3' and checks[0] in capture['checks']
+          for file in path.parent.glob('check-*.json')
+      )
+      assert record['evidence_gaps']
+      assert not record.get('regressions')
+      assert record['outcome'] == 'blocked'
+      PY
   - name: final response is the complete rendered verification report
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1) &&
       test -n "$record" &&
       report=$(dirname "$record")/verification.md &&
       test -r "$report" && test -s "$report" &&
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/fixed-point.yaml b/plugins/capability/darrow-review/skills/code-review/evals/fixed-point.yaml
index 6406918d..a96ab1f5 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/fixed-point.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/fixed-point.yaml
@@ -12,31 +12,32 @@ fixture:
     - message: "feat: add after"
       files:
         after.txt: "after\n"
+  setup: |
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: fixed-point review remains clean
     run: test -z "$(git status --porcelain --untracked-files=all)"
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: review is pinned to the requested fixed points
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       base=$(git rev-parse HEAD~1) && target=$(git rev-parse HEAD) &&
-      grep -F "base	$base" "$record" >/dev/null &&
-      grep -F "target	$target" "$record" >/dev/null &&
-      grep -F 'spec	not_available' "$record" >/dev/null &&
-      awk -F '\t' '$1 == "changed_file" { count++; if ($2 ~ /\/after[.]txt$/) found = 1 }
-      END { exit !(count == 1 && found) }' "$record"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has "base" "$base" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has "target" "$target" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has spec not_available &&
+      python3 -c 'import json,sys; files=json.load(open(sys.argv[1]))["changed_files"]; assert len(files)==1 and files[0].endswith("/after.txt")' "$record"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/goal-contract-pass.yaml b/plugins/capability/darrow-review/skills/code-review/evals/goal-contract-pass.yaml
index d6f4f5d5..e6d57c56 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/goal-contract-pass.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/goal-contract-pass.yaml
@@ -30,35 +30,37 @@ fixture:
           #!/usr/bin/env bash
           set -eu
           git_dir=$(git rev-parse --git-dir)
-          record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n 1)
+          record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n 1)
           test -n "$record"
-          grep -F 'verdict	pass' "$record" >/dev/null
-          grep -F 'next_action	return control to enclosing goal' "$record" >/dev/null
+          python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict pass
+          python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has next_action 'return control to enclosing goal'
           printf '%s\n' complete >"$git_dir/goal-complete"
   files:
     src/rate.js: "export const RATE_LIMIT = 2;\n"
+  setup: |
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: passing review returns control to the enclosing goal
     run: test "$(cat .git/goal-complete)" = complete
   - name: candidate content remains unchanged
     run: bash check.sh
   - name: composed review pins one target
-    run: test "$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -maxdepth 3 -name scope.tsv -path '*/darrow-review.*/*' | wc -l | tr -d ' ')" -ge 1
+    run: test "$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -maxdepth 3 -name scope.json -path '*/darrow-review.*/*' | wc -l | tr -d ' ')" -ge 1
   - name: composed review creates no commit
     run: test "$(git rev-list --count HEAD)" -eq 1
   - name: composed review artifact is canonical and returns control
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record" &&
-      grep -F 'verdict	pass' "$record" >/dev/null &&
-      grep -F 'next_action	return control to enclosing goal' "$record" >/dev/null &&
-      ! grep -F 'finding	' "$record" >/dev/null
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict pass &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has next_action 'return control to enclosing goal' &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key findings
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
 semantic_output_checks:
   - name: enclosing goal reports completion
     proposition: The response says the bounded goal completed successfully.
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/goal-contract-repair-rereview.yaml b/plugins/capability/darrow-review/skills/code-review/evals/goal-contract-repair-rereview.yaml
index 703de548..bbbcee03 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/goal-contract-repair-rereview.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/goal-contract-repair-rereview.yaml
@@ -39,9 +39,9 @@ fixture:
           #!/usr/bin/env bash
           set -eu
           git_dir=$(git rev-parse --git-dir)
-          record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1)
+          record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1)
           test -n "$record"
-          grep -F 'outcome	clear' "$record" >/dev/null
+          python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has outcome clear
           printf '%s\n' complete >"$git_dir/goal-complete"
   files:
     src/config.js: |
@@ -51,39 +51,40 @@ fixture:
     set -eu
     backend=$(cd "{{case_dir}}/../../../backend" && pwd -P)
     printf '%s\n' "$backend" >.git/review-backend
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: original guidance survives the real review and repair chain
     run: |
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1)
-      original=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n 1)
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1)
+      original=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n 1)
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n 1)
       test -n "$record" && test -n "$original" && test -n "$tool" || exit 1
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-original "$original" "$record" || exit 1
-      awk -F '\t' '$1 == "original_finding" { n++; if (NF != 11 || $10 == "" || $11 == "") bad=1 }
-        END { exit !(n && !bad) }' "$record"
+      python3 -c 'import json,sys; findings=json.load(open(sys.argv[1]))["original_findings"]; assert findings and all(row["repair_guidance"] and row["resolution_evidence"] for row in findings)' "$record"
   - name: authorized repair reaches the originating requirement
     run: bash check.sh
   - name: clear fix verification returns control to the enclosing goal
     run: test "$(cat .git/goal-complete)" = complete
   - name: repair causes an initial scope and a fix-verification scope
-    run: test "$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -maxdepth 3 -name scope.tsv -path '*/darrow-review.*/*' | wc -l | tr -d ' ')" -ge 2
+    run: test "$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -maxdepth 3 -name scope.json -path '*/darrow-review.*/*' | wc -l | tr -d ' ')" -ge 2
   - name: fix verification uses a new target fingerprint
     run: >-
-      find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -maxdepth 3 -name scope.tsv -path '*/darrow-review.*/*' -exec
-      awk -F '\t' '$1 == "target" { print $2 }' {} + | sort -u >.git/review-targets &&
+      find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -maxdepth 3 -name scope.json -path '*/darrow-review.*/*' -exec
+      python3 .git/eval-checks/review/tests/evals/assert_records.py {} value target \; |
+      sort -u >.git/review-targets &&
       test "$(wc -l <.git/review-targets | tr -d ' ')" -ge 2
   - name: additive verification artifact validates beside the repaired scope
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -maxdepth 3 -name verification.tsv -path '*/darrow-review.*/*' | sort | tail -n 1) &&
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -maxdepth 3 -name verification.json -path '*/darrow-review.*/*' | sort | tail -n 1) &&
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1') &&
       test -n "$tool" &&
       test -n "$record" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record" &&
-      grep -F 'outcome	clear' "$record" >/dev/null &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has outcome clear &&
       grep -F 'RETRY_COUNT = 3' "$(dirname "$record")/diff.patch" >/dev/null
   - name: composed repair creates no commit
     run: test "$(git rev-list --count HEAD)" -eq 1
-  - name: default response does not expose raw verification TSV
-    run: "! grep -F 'format	darrow-review-verification-v1' .git/last-message.md"
+  - name: default response does not expose raw verification JSON
+    run: "! grep -F 'format	darrow-review-verification-v3' .git/last-message.md"
 semantic_output_checks:
   - name: enclosing goal reports completion
     proposition: The response says the bounded goal completed successfully.
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/invalid-base.yaml b/plugins/capability/darrow-review/skills/code-review/evals/invalid-base.yaml
index 6439cfed..a9e6cdd0 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/invalid-base.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/invalid-base.yaml
@@ -11,37 +11,40 @@ fixture:
         value.txt: "before\n"
   files:
     value.txt: "after\n"
-  setup: git status --porcelain --untracked-files=all >.git/status-before
+  setup: |
+    git status --porcelain --untracked-files=all >.git/status-before
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: invalid preflight preserves the working tree
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: invalid base is preserved and blocks without review findings
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      grep -F 'base	release/does-not-exist' "$record" >/dev/null &&
-      grep -F 'standards	blocked' "$record" >/dev/null &&
-      grep -F 'spec	not_available' "$record" >/dev/null &&
-      grep -F 'verdict	blocked' "$record" >/dev/null &&
-      ! grep -E '^(changed_file|finding)	' "$record" >/dev/null
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has base release/does-not-exist &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has standards blocked &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has spec not_available &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict blocked &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key changed_files &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key findings
   - name: invalid scope invokes no reviewer
     run: >-
       case "$DARROW_EVAL_HARNESS" in
       codex) ! grep -F '"type":"darrow.codex_native_spawn"' .git/retained-harness.jsonl >/dev/null ;;
       claude) ! grep -F '"type":"darrow.review_agent_launch"' .git/retained-harness.jsonl >/dev/null ;;
       *) exit 2 ;; esac
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/low-noise.yaml b/plugins/capability/darrow-review/skills/code-review/evals/low-noise.yaml
index b2f112cb..ed07529e 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/low-noise.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/low-noise.yaml
@@ -34,33 +34,33 @@ fixture:
         if (token !== "ok") return 403;
         return 204;
       }
-  setup: git status --porcelain --untracked-files=all >.git/status-before
+  setup: |
+    git status --porcelain --untracked-files=all >.git/status-before
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: review remains read-only despite failed check
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: failed formatter remains check evidence without prose findings
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      grep -F 'standards	pass' "$record" >/dev/null &&
-      grep -F 'spec	pass' "$record" >/dev/null &&
-      grep -F 'verdict	fail' "$record" >/dev/null &&
-      awk -F '\t' '$1 == "check" && $2 == "bash format-check.sh" &&
-      $3 == "applicable" && $4 == "fail" { found = 1 }
-      END { exit !found }' "$record" &&
-      ! grep -F 'finding	' "$record" >/dev/null
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has standards pass &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has spec pass &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict fail &&
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); assert any(check["command"]=="bash format-check.sh" and check["applicability"]=="applicable" and check["status"]=="fail" for check in record["checks"])' "$record" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key findings
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/merge-base-branch.yaml b/plugins/capability/darrow-review/skills/code-review/evals/merge-base-branch.yaml
index 47a9adbc..0d3456b4 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/merge-base-branch.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/merge-base-branch.yaml
@@ -19,32 +19,32 @@ fixture:
     git add main-only.txt
     git commit -qm 'feat: main side'
     git checkout -q feature
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: branch review remains read-only
     run: test -z "$(git status --porcelain --untracked-files=all)"
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: scope uses the branch merge base and excludes main-only changes
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       base=$(git merge-base main HEAD) && target=$(git rev-parse HEAD) &&
-      grep -F "base	$base" "$record" >/dev/null &&
-      grep -F "target	$target" "$record" >/dev/null &&
-      grep -F 'spec	not_available' "$record" >/dev/null &&
-      awk -F '\t' '$1 == "changed_file" { count++; if ($2 ~ /\/feature[.]txt$/) found = 1 }
-      END { exit !(count == 1 && found) }' "$record" &&
-      ! grep -F 'main-only.txt' "$record" >/dev/null
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has "base" "$base" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has "target" "$target" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has spec not_available &&
+      python3 -c 'import json,sys; files=json.load(open(sys.argv[1]))["changed_files"]; assert len(files)==1 and files[0].endswith("/feature.txt")' "$record" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" not-contains main-only.txt
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/neither-axis.yaml b/plugins/capability/darrow-review/skills/code-review/evals/neither-axis.yaml
index e6783fe0..1de5928b 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/neither-axis.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/neither-axis.yaml
@@ -27,30 +27,32 @@ fixture:
         const parsed = Number(value.trim());
         return Number.isFinite(parsed) ? parsed : null;
       }
-  setup: git status --porcelain --untracked-files=all >.git/status-before
+  setup: |
+    git status --porcelain --untracked-files=all >.git/status-before
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: review is read-only
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: both axes pass without findings
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      grep -F 'standards	pass' "$record" >/dev/null &&
-      grep -F 'spec	pass' "$record" >/dev/null &&
-      grep -F 'verdict	pass' "$record" >/dev/null &&
-      ! grep -F 'finding	' "$record" >/dev/null
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has standards pass &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has spec pass &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict pass &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key findings
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/no-trigger-after-edit.yaml b/plugins/capability/darrow-review/skills/code-review/evals/no-trigger-after-edit.yaml
index f98f7364..b459ee4f 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/no-trigger-after-edit.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/no-trigger-after-edit.yaml
@@ -13,7 +13,7 @@ checks:
   - name: ordinary edit intent is fulfilled
     run: grep -F 'DEFAULT_TIMEOUT_MS = 2500' src/config.js
   - name: no review artifact was returned
-    run: "! grep -F 'darrow-review-result-v1' .git/last-message.md"
+    run: "! grep -F 'darrow-review-result-v3' .git/last-message.md"
 output_checks:
   - name: skill does not claim a review
-    not_regex: "darrow-review-result-v1|^standards\\t|^spec\\t"
+    not_regex: "darrow-review-result-v3|^standards\\t|^spec\\t"
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/presentation-blocked.yaml b/plugins/capability/darrow-review/skills/code-review/evals/presentation-blocked.yaml
index c62276ee..d88ee772 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/presentation-blocked.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/presentation-blocked.yaml
@@ -9,23 +9,26 @@ fixture:
     - message: "chore: init"
       files:
         README.md: "# Clean fixture\n"
+  setup: |
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: terminal scope artifact is canonical and preserves the reason
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record" &&
-      grep -F 'verdict	blocked' "$record" >/dev/null &&
-      grep -F 'declared review scope is empty' "$record" >/dev/null &&
-      ! grep -E '^(changed_file|finding)	' "$record" >/dev/null
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: terminal scope response does not leak TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict blocked &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" contains 'declared review scope is empty' &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key changed_files &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks-key findings
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: terminal scope response does not leak JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/presentation-default.yaml b/plugins/capability/darrow-review/skills/code-review/evals/presentation-default.yaml
index b7eed932..608bca2d 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/presentation-default.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/presentation-default.yaml
@@ -26,17 +26,17 @@ fixture:
         return Number(value);
       }
 checks:
-  - name: raw TSV stays beneath the review artifact
-    run: test "$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name '*.tsv' | wc -l | tr -d ' ')" -ge 1
-  - name: canonical TSV is valid
+  - name: raw JSON stays beneath the review artifact
+    run: test "$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name '*.json' | wc -l | tr -d ' ')" -ge 1
+  - name: canonical JSON is valid
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: human response does not duplicate raw TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: human response does not duplicate raw JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: human response renders values as ordinary Markdown text
     run: >-
       ! grep -F '<code>' .git/last-message.md &&
@@ -46,7 +46,7 @@ checks:
       esc=$(printf '\033]8;') && ! grep -F "$esc" .git/last-message.md
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/presentation-machine-v1.yaml b/plugins/capability/darrow-review/skills/code-review/evals/presentation-machine-v1.yaml
index 9d218140..02b19fdd 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/presentation-machine-v1.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/presentation-machine-v1.yaml
@@ -2,7 +2,7 @@ id: code-review-presentation-machine-v1
 activation: positive
 invariant: CR-C15,CR-E12
 prompt: >-
-  Review my uncommitted changes and return only the raw darrow-review-result-v1
+  Review my uncommitted changes and return only the raw darrow-review-result-v3
   machine format. Do not repair the change.
 fixture:
   commits:
@@ -17,11 +17,11 @@ checks:
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate .git/last-message.md
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: explicit machine response preserves the retained canonical record
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      awk '1' "$record" >.git/expected-review.tsv &&
-      awk '1' .git/last-message.md >.git/actual-review.tsv &&
-      cmp .git/expected-review.tsv .git/actual-review.tsv
+      awk '1' "$record" >.git/expected-review.json &&
+      awk '1' .git/last-message.md >.git/actual-review.json &&
+      cmp .git/expected-review.json .git/actual-review.json
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/pull-request.yaml b/plugins/capability/darrow-review/skills/code-review/evals/pull-request.yaml
index dadaa872..1530efc3 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/pull-request.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/pull-request.yaml
@@ -22,34 +22,35 @@ fixture:
       base=$(git rev-parse HEAD~1)
       head=$(git rev-parse HEAD)
       printf '{"baseRefOid":"%s","headRefOid":"%s","body":"Requirement: add health.txt containing exactly ok.","url":"https://example.invalid/pr/12"}\n' "$base" "$head"
+  setup: |
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: pull-request review does not mutate Git state
     run: test -z "$(git status --porcelain --untracked-files=all)"
   - name: pull-request review does not publish or approve
     run: test "$(git rev-list --all --reflog --count)" -eq 2; test ! -s .git/forbidden-gh
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: review is pinned to the pull-request objects and body specification
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       base=$(git rev-parse HEAD~1) && target=$(git rev-parse HEAD) &&
-      grep -F "base	$base" "$record" >/dev/null &&
-      grep -F "target	$target" "$record" >/dev/null &&
-      grep -F 'spec	pass' "$record" >/dev/null &&
-      grep -F 'verdict	pass' "$record" >/dev/null &&
-      awk -F '\t' '$1 == "changed_file" { count++; if ($2 ~ /\/health[.]txt$/) found = 1 }
-      END { exit !(count == 1 && found) }' "$record"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has "base" "$base" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has "target" "$target" &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has spec pass &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict pass &&
+      python3 -c 'import json,sys; files=json.load(open(sys.argv[1]))["changed_files"]; assert len(files)==1 and files[0].endswith("/health.txt")' "$record"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/read-only-adversarial.yaml b/plugins/capability/darrow-review/skills/code-review/evals/read-only-adversarial.yaml
index c9ae4d6c..3ad7e7a9 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/read-only-adversarial.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/read-only-adversarial.yaml
@@ -47,18 +47,18 @@ checks:
     run: "! grep -E '(^|[[:space:]])(add|apply|checkout|commit|merge|push|reset|restore|revert|switch)([[:space:]]|$)' .git/git-trace"
   - name: no forge command is attempted
     run: test ! -s .git/gh-trace
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-alternative.yaml b/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-alternative.yaml
index 6417a5ce..cfdf2365 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-alternative.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-alternative.yaml
@@ -38,32 +38,60 @@ fixture:
     set -eu
     backend=$(cd "{{case_dir}}/../../../backend" && pwd -P)
     prior_output=$(uv run --quiet --frozen --no-dev --project "$backend" review-scope prepare --repo "$PWD" --base HEAD^ --target HEAD)
-    prior_manifest=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "manifest" { print $2 }')
-    original_target=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "target" { print $2 }')
-    original_result=$(dirname "$prior_manifest")/result.tsv
-    {
-      printf 'format\tdarrow-review-result-v1\n'
-      uv run --quiet --frozen --no-dev --project "$backend" review-result scope-records "$prior_manifest"
-      printf 'standards\tpass\nstandards_source\t%s/AGENTS.md\nspec\tfail\nspec_source\t%s/requirements.md\n' "$PWD" "$PWD"
-      printf 'finding\tspec\thigh\tblocking\t%s/src/name.js:2\t%s/requirements.md\tDirect trim returns an empty string for whitespace-only input instead of Anonymous\tAdvisory: store value.trim() in a local variable and return the variable or Anonymous; this supplies the missing fallback while preserving trimming\tWhitespace-only and empty input return Anonymous; padded Ada returns Ada\n' "$PWD" "$PWD"
-      printf 'check\tnone\tnot_applicable\tnot_applicable\tNo configured command\nverdict\tfail\nrisk\tnone\nnext_action\treturn findings\n'
-    } >"$original_result"
-    {
-      printf 'original_target\t%s\nprior_target\t%s\nprior_manifest\t%s\noriginal_result\t%s\nprevious_verification\tnone\tnone\n' "$original_target" "$original_target" "$prior_manifest" "$original_result"
-      uv run --quiet --frozen --no-dev --project "$backend" review-result original-findings "$original_result"
-      printf 'attempted\tspec:1:%s\n' "$original_target"
-    } >.git/verification-input
+    prior_manifest=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' manifest)
+    original_target=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' target)
+    original_result=$(dirname "$prior_manifest")/result.json
+    scope_json=$(uv run --quiet --frozen --no-dev --project "$backend" review-result scope-records "$prior_manifest")
+    python3 - "$PWD" "$scope_json" <<'PY' >"$original_result"
+    import json, sys
+    repo, scope_json = sys.argv[1:]
+    json.dump({
+        "format": "darrow-review-result-v3",
+        **json.loads(scope_json),
+        "standards": "pass",
+        "standards_sources": [f"{repo}/AGENTS.md"],
+        "spec": "fail",
+        "spec_source": f"{repo}/requirements.md",
+        "findings": [{
+            "axis": "spec", "severity": "high", "disposition": "blocking",
+            "location": f"{repo}/src/name.js:2",
+            "source": f"{repo}/requirements.md",
+            "evidence": "Direct trim returns an empty string for whitespace-only input instead of Anonymous",
+            "repair_guidance": "Advisory: store value.trim() in a local variable and return the variable or Anonymous; this supplies the missing fallback while preserving trimming",
+            "resolution_evidence": "Whitespace-only and empty input return Anonymous; padded Ada returns Ada",
+        }],
+        "checks": [{
+            "command": "none", "applicability": "not_applicable",
+            "status": "not_applicable", "evidence": "No configured command",
+        }],
+        "verdict": "fail",
+        "risks": ["none"],
+        "next_action": "return findings",
+    }, sys.stdout)
+    PY
+    finding_json=$(uv run --quiet --frozen --no-dev --project "$backend" review-result original-findings "$original_result")
+    python3 - "$original_target" "$prior_manifest" "$original_result" "$finding_json" <<'PY' >.git/verification-input
+    import json, sys
+    target, manifest, result, finding_json = sys.argv[1:]
+    json.dump({
+        "original_target": target,
+        "prior_target": target,
+        "prior_manifest": manifest,
+        "original_result": result,
+        "previous_verification": {"checksum": "none", "path": "none"},
+        "original_findings": json.loads(finding_json)["original_findings"],
+        "attempted": [f"spec:1:{target}"],
+    }, sys.stdout)
+    PY
     git hash-object src/name.js >.git/before
 checks:
   - name: alternative implementation resolves the original finding
     run: |
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1)
-      original=$(awk -F '\t' '$1 == "original_result" { print $2 }' .git/verification-input)
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1)
+      original=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["original_result"])')
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n 1)
       test -n "$record" && test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-original "$original" "$record" || exit 1
-      awk -F '\t' '$1 == "outcome" && $2 == "clear" { clear=1 }
-        $1 == "attempt" && $3 == "resolved" { resolved=1 }
-        END { exit !(clear && resolved) }' "$record"
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); assert record["outcome"]=="clear" and any(item["status"]=="resolved" for item in record["attempts"])' "$record"
   - name: repair remains read only
     run: git hash-object src/name.js >.git/after && cmp .git/before .git/after
 semantic_output_checks:
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-uncertain.yaml b/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-uncertain.yaml
index 514634e6..b4179f85 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-uncertain.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-uncertain.yaml
@@ -29,16 +29,16 @@ fixture:
       export function send(payload, tenant, vendorTransport) {
         return vendorTransport.send(payload);
       }
-  setup: git hash-object src/send.js >.git/before
+  setup: |
+    git hash-object src/send.js >.git/before
 checks:
   - name: supported signing finding survives uncertainty
     run: |
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n 1)
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n 1)
       test -n "$record" || exit 1
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n 1)
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record" || exit 1
-      awk -F '\t' '$1 == "finding" && $2 == "spec" && $4 == "blocking" && NF == 9 { found=1 }
-        END { exit !found }' "$record"
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); assert any(item["axis"]=="spec" and item["disposition"]=="blocking" and item["repair_guidance"] and item["resolution_evidence"] for item in record["findings"])' "$record"
   - name: review does not implement its advice
     run: git hash-object src/send.js >.git/after && cmp .git/before .git/after
 semantic_output_checks:
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-unresolved.yaml b/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-unresolved.yaml
index 47ce258c..64a8adff 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-unresolved.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance-unresolved.yaml
@@ -38,32 +38,60 @@ fixture:
     set -eu
     backend=$(cd "{{case_dir}}/../../../backend" && pwd -P)
     prior_output=$(uv run --quiet --frozen --no-dev --project "$backend" review-scope prepare --repo "$PWD" --base HEAD^ --target HEAD)
-    prior_manifest=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "manifest" { print $2 }')
-    original_target=$(printf '%s\n' "$prior_output" | awk -F '\t' '$1 == "target" { print $2 }')
-    original_result=$(dirname "$prior_manifest")/result.tsv
-    {
-      printf 'format\tdarrow-review-result-v1\n'
-      uv run --quiet --frozen --no-dev --project "$backend" review-result scope-records "$prior_manifest"
-      printf 'standards\tpass\nstandards_source\t%s/AGENTS.md\nspec\tfail\nspec_source\t%s/requirements.md\n' "$PWD" "$PWD"
-      printf 'finding\tspec\thigh\tblocking\t%s/src/name.js:2\t%s/requirements.md\tDirect trim returns an empty string for whitespace-only input instead of Anonymous\tAdvisory: store value.trim() in a local variable and return the variable or Anonymous; this supplies the missing fallback while preserving trimming\tWhitespace-only and empty input return Anonymous; padded Ada returns Ada\n' "$PWD" "$PWD"
-      printf 'check\tnone\tnot_applicable\tnot_applicable\tNo configured command\nverdict\tfail\nrisk\tnone\nnext_action\treturn findings\n'
-    } >"$original_result"
-    {
-      printf 'original_target\t%s\nprior_target\t%s\nprior_manifest\t%s\noriginal_result\t%s\nprevious_verification\tnone\tnone\n' "$original_target" "$original_target" "$prior_manifest" "$original_result"
-      uv run --quiet --frozen --no-dev --project "$backend" review-result original-findings "$original_result"
-      printf 'attempted\tspec:1:%s\n' "$original_target"
-    } >.git/verification-input
+    prior_manifest=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' manifest)
+    original_target=$(printf '%s' "$prior_output" | python3 -c 'import json,sys; print(json.load(sys.stdin)[sys.argv[1]])' target)
+    original_result=$(dirname "$prior_manifest")/result.json
+    scope_json=$(uv run --quiet --frozen --no-dev --project "$backend" review-result scope-records "$prior_manifest")
+    python3 - "$PWD" "$scope_json" <<'PY' >"$original_result"
+    import json, sys
+    repo, scope_json = sys.argv[1:]
+    json.dump({
+        "format": "darrow-review-result-v3",
+        **json.loads(scope_json),
+        "standards": "pass",
+        "standards_sources": [f"{repo}/AGENTS.md"],
+        "spec": "fail",
+        "spec_source": f"{repo}/requirements.md",
+        "findings": [{
+            "axis": "spec", "severity": "high", "disposition": "blocking",
+            "location": f"{repo}/src/name.js:2",
+            "source": f"{repo}/requirements.md",
+            "evidence": "Direct trim returns an empty string for whitespace-only input instead of Anonymous",
+            "repair_guidance": "Advisory: store value.trim() in a local variable and return the variable or Anonymous; this supplies the missing fallback while preserving trimming",
+            "resolution_evidence": "Whitespace-only and empty input return Anonymous; padded Ada returns Ada",
+        }],
+        "checks": [{
+            "command": "none", "applicability": "not_applicable",
+            "status": "not_applicable", "evidence": "No configured command",
+        }],
+        "verdict": "fail",
+        "risks": ["none"],
+        "next_action": "return findings",
+    }, sys.stdout)
+    PY
+    finding_json=$(uv run --quiet --frozen --no-dev --project "$backend" review-result original-findings "$original_result")
+    python3 - "$original_target" "$prior_manifest" "$original_result" "$finding_json" <<'PY' >.git/verification-input
+    import json, sys
+    target, manifest, result, finding_json = sys.argv[1:]
+    json.dump({
+        "original_target": target,
+        "prior_target": target,
+        "prior_manifest": manifest,
+        "original_result": result,
+        "previous_verification": {"checksum": "none", "path": "none"},
+        "original_findings": json.loads(finding_json)["original_findings"],
+        "attempted": [f"spec:1:{target}"],
+    }, sys.stdout)
+    PY
     git hash-object src/name.js >.git/before
 checks:
   - name: following the advice does not excuse a remaining required case
     run: |
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.tsv -type f | sort | tail -n 1)
-      original=$(awk -F '\t' '$1 == "original_result" { print $2 }' .git/verification-input)
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name verification.json -type f | sort | tail -n 1)
+      original=$(python3 -c 'import json; print(json.load(open(".git/verification-input"))["original_result"])')
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n 1)
       test -n "$record" && test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-original "$original" "$record" || exit 1
-      awk -F '\t' '$1 == "outcome" && ($2 == "continue" || $2 == "no_progress") { open=1 }
-        $1 == "attempt" && $3 == "unresolved" { unresolved=1 }
-        END { exit !(open && unresolved) }' "$record"
+      python3 -c 'import json,sys; record=json.load(open(sys.argv[1])); assert record["outcome"] in ("continue","no_progress") and any(item["status"]=="unresolved" for item in record["attempts"])' "$record"
   - name: repair remains read only
     run: git hash-object src/name.js >.git/after && cmp .git/before .git/after
 semantic_output_checks:
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance.yaml b/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance.yaml
index 237347de..df8c3173 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/repair-guidance.yaml
@@ -26,42 +26,30 @@ fixture:
         console.log("parsing", value);
         return Number(value);
       }
-  setup: git status --porcelain --untracked-files=all >.git/status-before
+  setup: |
+    git status --porcelain --untracked-files=all >.git/status-before
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
+    cp "{{case_dir}}/../../../backend/tests/evals/assert_guidance.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: each finding retains guidance from its originating reader
     run: |
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n 1)
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n 1)
       test -n "$record" || exit 1
-      artifact_dir=$(dirname "$record")
-      awk -F '\t' 'BEGIN { OFS="\t" }
-        $1 == "finding" { if (NF != 9 || $8 == "" || $9 == "") exit 1; print $2,$3,$4,$5,$6,$7,$8,$9; n++ }
-        END { if (!n) exit 1 }' "$record" >.git/aggregate-guidance || exit 1
-      : >.git/reader-guidance
-      for file in "$artifact_dir"/*; do
-        test -f "$file" || continue
-        if test "$(sed -n 1p "$file")" = "$(printf 'format\tdarrow-review-axis-v1')"; then
-          awk -F '\t' 'BEGIN { OFS="\t" }
-            $1 == "axis" { axis=$2 }
-            $1 == "finding" { print axis,$2,$3,$4,$5,$6,$7,$8 }' "$file" >>.git/reader-guidance
-        fi
-      done
-      while IFS= read -r finding; do
-        grep -Fx -- "$finding" .git/reader-guidance >/dev/null || exit 1
-      done <.git/aggregate-guidance
+      python3 .git/eval-checks/review/tests/evals/assert_guidance.py "$record" finding
   - name: review is read-only
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
-  - name: canonical Markdown handoff is materialized beside the TSV
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
+  - name: canonical Markdown handoff is materialized beside the JSON
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       report=$(dirname "$record")/review.md;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
@@ -70,7 +58,7 @@ checks:
       cmp .git/expected-review.md "$report"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/reviewer-route-override.yaml b/plugins/capability/darrow-review/skills/code-review/evals/reviewer-route-override.yaml
index 0d73cc53..0d1b5ac9 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/reviewer-route-override.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/reviewer-route-override.yaml
@@ -29,17 +29,18 @@ fixture:
     cp "{{case_dir}}/../../../backend/pyproject.toml" "{{case_dir}}/../../../backend/uv.lock" .git/eval-checks/review/
     cp -R "{{case_dir}}/../../../backend/src" .git/eval-checks/review/
     cp "{{case_dir}}/../../../backend/tests/evals/eval_routes.py" .git/eval-checks/review/tests/evals/
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: repository reviewer policy is retained with the pinned scope
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name reviewer-route.tsv -type f | sort | tail -n '1');
-      test -n "$record" && grep -F 'route_source	repository' "$record" >/dev/null
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name reviewer-route.json -type f | sort | tail -n '1');
+      test -n "$record" && python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has route_source repository
   - name: configured host route is selected without inheritance
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name reviewer-route.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name reviewer-route.json -type f | sort | tail -n '1');
       test -n "$record" && case "$DARROW_EVAL_HARNESS" in
-      codex) grep -F 'selected_route	codex	openai	gpt-5.5	xhigh' "$record" >/dev/null ;;
-      claude) grep -F 'selected_route	claude	anthropic	claude-sonnet-5	high' "$record" >/dev/null ;;
+      codex) python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has selected_route codex openai gpt-5.5 xhigh ;;
+      claude) python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has selected_route claude anthropic claude-sonnet-5 high ;;
       *) exit 2 ;; esac
   - name: both isolated axes retain exact route application evidence
     run: >-
@@ -48,18 +49,18 @@ checks:
       --host "$DARROW_EVAL_HARNESS" --profile override --axes standards spec
   - name: review remains read-only
     run: test "$(git status --porcelain --untracked-files=all)" = ' M src/config.js'
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/reviewer-route-unavailable.yaml b/plugins/capability/darrow-review/skills/code-review/evals/reviewer-route-unavailable.yaml
index 2e74ac84..6a2028f9 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/reviewer-route-unavailable.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/reviewer-route-unavailable.yaml
@@ -23,24 +23,24 @@ fixture:
   files:
     src/config.js: |
       export const mode = "unsafe";
+  setup: |
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: unavailable repository policy is retained without fallback
     run: >-
-      selection=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name reviewer-route.tsv -type f | sort | tail -n '1');
+      selection=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name reviewer-route.json -type f | sort | tail -n '1');
       test -n "$selection" && case "$DARROW_EVAL_HARNESS" in
-      codex) grep -F 'selected_route	codex	openai	gpt-5.5	xhigh' "$selection" >/dev/null ;;
-      claude) grep -F 'selected_route	claude	anthropic	claude-sonnet-5	high' "$selection" >/dev/null ;;
+      codex) python3 .git/eval-checks/review/tests/evals/assert_records.py "$selection" has selected_route codex openai gpt-5.5 xhigh ;;
+      claude) python3 .git/eval-checks/review/tests/evals/assert_records.py "$selection" has selected_route claude anthropic claude-sonnet-5 high ;;
       *) exit 2 ;; esac
   - name: no reader accepts inherited or substituted route evidence
     run: >-
-      selection=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name reviewer-route.tsv -type f | sort | tail -n '1');
+      selection=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name reviewer-route.json -type f | sort | tail -n '1');
       test -n "$selection" || exit 1; artifact_dir=$(dirname "$selection");
-      for axis in standards spec; do record="$artifact_dir/$axis-route.tsv";
+      for axis in standards spec; do record="$artifact_dir/$axis-route.json";
       if test -e "$record"; then
-      ! awk -F '\t' '$1 == "route_verified" && $2 == "true" { found = 1 } END { exit !found }'
-      "$record" || exit 1;
-      ! awk -F '\t' '$1 == "route_bound" && $2 == "true" { found = 1 } END { exit !found }'
-      "$record" || exit 1; fi; done
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks route_verified true || exit 1;
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" lacks route_bound true || exit 1; fi; done
   - name: unavailable route retains zero native reader launch attempts
     run: >-
       case "$DARROW_EVAL_HARNESS" in codex)
@@ -53,19 +53,19 @@ checks:
       *) exit 2 ;; esac
   - name: blocked aggregate remains canonical and read only
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record" &&
-      grep -F 'verdict	blocked' "$record" >/dev/null &&
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has verdict blocked &&
       test "$(git status --porcelain --untracked-files=all)" = ' M src/config.js'
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/spec-only.yaml b/plugins/capability/darrow-review/skills/code-review/evals/spec-only.yaml
index e6897da3..4f9b491d 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/spec-only.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/spec-only.yaml
@@ -25,22 +25,23 @@ fixture:
       export function formatName(value) {
         return value.trim();
       }
-  setup: git status --porcelain --untracked-files=all >.git/status-before
+  setup: |
+    git status --porcelain --untracked-files=all >.git/status-before
 checks:
   - name: review is read-only
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+    expect_regex: "^valid: darrow-review-result-v3$"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/standards-only.yaml b/plugins/capability/darrow-review/skills/code-review/evals/standards-only.yaml
index b6217f04..63d96204 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/standards-only.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/standards-only.yaml
@@ -33,24 +33,24 @@ checks:
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
   - name: review creates no commit
     run: test "$(git rev-list --all --reflog --count)" -eq 1
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: only the standards reader retains exact default route evidence
     run: >-
       uv run --quiet --frozen --no-dev --project .git/eval-checks/review
       python .git/eval-checks/review/tests/evals/eval_routes.py
       --host "$DARROW_EVAL_HARNESS" --profile default --axes standards
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/value-comparison.yaml b/plugins/capability/darrow-review/skills/code-review/evals/value-comparison.yaml
index a6c98f03..76e14488 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/value-comparison.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/value-comparison.yaml
@@ -29,65 +29,55 @@ fixture:
         const port = Number.parseInt(value, 10);
         return port >= 1 && port <= 65535 ? port : null;
       }
-  setup: git status --porcelain --untracked-files=all >.git/status-before
+  setup: |
+    git status --porcelain --untracked-files=all >.git/status-before
 checks:
   - name: seeded trailing-character defect is detected
     metric: defect_detection
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      awk -F '\t' '$1 == "finding" && $2 == "spec" && $4 == "blocking" &&
-      tolower($7) ~ /(12x|parseint|trailing|integer|string)/ { found = 1 }
-      END { exit !found }' "$record"
+      python3 -c 'import json,re,sys; record=json.load(open(sys.argv[1])); assert any(item["axis"]=="spec" and item["disposition"]=="blocking" and re.search(r"12x|parseint|trailing|integer|string",item["evidence"],re.I) for item in record["findings"])' "$record"
   - name: no seeded defect escapes
     metric: escaped_defect
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      awk -F '\t' '$1 == "finding" && $2 == "spec" && $4 == "blocking" &&
-      tolower($7) ~ /(12x|parseint|trailing|integer|string)/ { found = 1 }
-      END { exit !found }' "$record"
+      python3 -c 'import json,re,sys; record=json.load(open(sys.argv[1])); assert any(item["axis"]=="spec" and item["disposition"]=="blocking" and re.search(r"12x|parseint|trailing|integer|string",item["evidence"],re.I) for item in record["findings"])' "$record"
   - name: accepted inline design does not create a false positive
     metric: false_positive
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      awk -F '\t' '$1 == "finding" &&
-      tolower($7) ~ /(abstract|inline|generalit)/ { false_positive = 1 }
-      END { exit false_positive }' "$record"
+      python3 -c 'import json,re,sys; record=json.load(open(sys.argv[1])); assert not any(re.search(r"abstract|inline|generalit",item["evidence"],re.I) for item in record["findings"])' "$record"
   - name: comparative review remains read-only
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: canonical result preserves the seeded Spec defect without a design false positive
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      awk -F '\t' '$1 == "spec" && $2 == "fail" { spec_fail = 1 }
-      $1 == "verdict" && $2 == "fail" { verdict_fail = 1 }
-      $1 == "finding" && $2 == "spec" && $4 == "blocking" &&
-      tolower($0) ~ /(12x|parseint|trailing)/ { found = 1 }
-      $1 == "finding" && $2 == "standards" { standards = 1 }
-      END { exit !(spec_fail && verdict_fail && found && !standards) }' "$record"
-  - name: canonical Markdown handoff is materialized beside the TSV
+      python3 -c 'import json,re,sys; record=json.load(open(sys.argv[1])); assert record["spec"]=="fail" and record["verdict"]=="fail" and any(item["axis"]=="spec" and item["disposition"]=="blocking" and re.search(r"12x|parseint|trailing"," ".join(item.values()),re.I) for item in record["findings"]) and not any(item["axis"]=="standards" for item in record["findings"])' "$record"
+  - name: canonical Markdown handoff is materialized beside the JSON
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       report=$(dirname "$record")/review.md;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -r "$report" && test -s "$report" && test -n "$tool" &&
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/report.py}" review-report render "$record" >.git/expected-review.md &&
       cmp .git/expected-review.md "$report"
-  - name: default response does not expose canonical TSV
-    run: "! grep -F 'format\tdarrow-review-result-v1' .git/last-message.md"
+  - name: default response does not expose canonical JSON
+    run: "! grep -F 'darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/evals/worktree-scope.yaml b/plugins/capability/darrow-review/skills/code-review/evals/worktree-scope.yaml
index c0493fe1..a7e508dc 100644
--- a/plugins/capability/darrow-review/skills/code-review/evals/worktree-scope.yaml
+++ b/plugins/capability/darrow-review/skills/code-review/evals/worktree-scope.yaml
@@ -21,34 +21,30 @@ fixture:
     printf 'staged\nunstaged\n' >staged.txt
     printf 'untracked\n' >untracked.txt
     git status --porcelain --untracked-files=all >.git/status-before
+    mkdir -p .git/eval-checks/review/tests/evals && cp "{{case_dir}}/../../../backend/tests/evals/assert_records.py" .git/eval-checks/review/tests/evals/
 checks:
   - name: every declared layer remains unchanged
     run: git status --porcelain --untracked-files=all >.git/status-after; cmp .git/status-before .git/status-after
   - name: review creates no commit
     run: test "$(git rev-list --all --reflog --count)" -eq 2
-  - name: canonical TSV is retained beneath the review scope artifact
+  - name: canonical JSON is retained beneath the review scope artifact
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n '1');
       test -n "$tool" && uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate "$record"
-    expect_regex: "^valid: darrow-review-result-v1$"
+    expect_regex: "^valid: darrow-review-result-v3$"
   - name: scope contains every worktree layer exactly once
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
-      grep -F 'spec	not_available' "$record" >/dev/null &&
-      awk -F '\t' '$1 == "changed_file" {
-      count++; if ($2 ~ /\/committed[.]txt$/) committed++;
-      if ($2 ~ /\/staged[.]txt$/) staged++;
-      if ($2 ~ /\/untracked[.]txt$/) untracked++ }
-      END { exit !(count == 3 && committed == 1 && staged == 1 && untracked == 1) }'
-      "$record"
-  - name: default response does not duplicate canonical TSV
-    run: "! grep -F 'format	darrow-review-result-v1' .git/last-message.md"
+      python3 .git/eval-checks/review/tests/evals/assert_records.py "$record" has spec not_available &&
+      python3 -c 'import json,sys; files=json.load(open(sys.argv[1]))["changed_files"]; assert len(files)==3 and all(sum(path.endswith("/"+name+".txt") for path in files)==1 for name in ("committed","staged","untracked"))' "$record"
+  - name: default response does not duplicate canonical JSON
+    run: "! grep -F 'format	darrow-review-result-v3' .git/last-message.md"
   - name: final response preserves every canonical rendered line
     run: >-
-      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.tsv -type f | sort | tail -n '1');
+      record=$(find "${DARROW_REVIEW_STATE_DIR:-$HOME/.darrow/reviews}" -path '*/darrow-review.*/*' -name result.json -type f | sort | tail -n '1');
       test -n "$record" || exit 1;
       tool=$(find .git -path '*/backend/src/darrow_review/report.py' -type f | sort | tail -n '1');
       test -n "$tool" || exit 1;
diff --git a/plugins/capability/darrow-review/skills/code-review/references/axis-prompts.md b/plugins/capability/darrow-review/skills/code-review/references/axis-prompts.md
index 91f92db7..2a74faba 100644
--- a/plugins/capability/darrow-review/skills/code-review/references/axis-prompts.md
+++ b/plugins/capability/darrow-review/skills/code-review/references/axis-prompts.md
@@ -38,13 +38,23 @@ Supply your own bounded repair approach, rationale, and important constraints;
 mark it as advisory, separate from the required outcome. If you lack evidence
 for a safe recommendation, explicitly say why without inventing a solution or
 withholding the supported finding. Identify observable behavior or a regression
-test that would demonstrate resolution. Keep each field on one line, no tabs.
-Return at most 8 findings and no prose outside this tab-separated schema:
-format<TAB>darrow-review-axis-v1
-axis<TAB>standards
-status<TAB>pass|fail|blocked
-source<TAB>one exact repository source (repeat as needed)
-finding<TAB>critical|high|medium|low<TAB>blocking|advisory<TAB>changed path:line or command<TAB>violated source or heuristic:<name><TAB>failure and cause evidence<TAB>advisory repair guidance or explicit limitation<TAB>resolution behavior or regression test
+test that would demonstrate resolution. Encode every field as a JSON string; preserve tabs and newlines inside strings.
+Return at most 8 findings as one valid JSON object, with no prose or code fence. Replace placeholders and repeat array entries as needed:
+{
+  "format": "darrow-review-axis-v3",
+  "axis": "standards",
+  "status": "pass|fail|blocked",
+  "sources": ["one exact repository source"],
+  "findings": [{
+    "severity": "critical|high|medium|low",
+    "disposition": "blocking|advisory",
+    "location": "changed path:line or command",
+    "source": "violated source or heuristic:name",
+    "evidence": "failure and cause evidence",
+    "repair_guidance": "advisory repair guidance or explicit limitation",
+    "resolution_evidence": "resolution behavior or regression test"
+  }]
+}
 ```
 
 ## Spec reviewer
@@ -80,13 +90,23 @@ Supply your own bounded repair approach, rationale, and important constraints;
 mark it as advisory, separate from the required outcome. If you lack evidence
 for a safe recommendation, explicitly say why without inventing a solution or
 withholding the supported finding. Identify observable behavior or a regression
-test that would demonstrate resolution. Keep each field on one line, no tabs.
-Return at most 8 findings and no prose outside this tab-separated schema:
-format<TAB>darrow-review-axis-v1
-axis<TAB>spec
-status<TAB>pass|fail|blocked
-source<TAB>one exact originating source (repeat as needed)
-finding<TAB>critical|high|medium|low<TAB>blocking|advisory<TAB>changed path:line or command<TAB>exact requirement citation<TAB>failure and cause evidence<TAB>advisory repair guidance or explicit limitation<TAB>resolution behavior or regression test
+test that would demonstrate resolution. Encode every field as a JSON string; preserve tabs and newlines inside strings.
+Return at most 8 findings as one valid JSON object, with no prose or code fence. Replace placeholders and repeat array entries as needed:
+{
+  "format": "darrow-review-axis-v3",
+  "axis": "spec",
+  "status": "pass|fail|blocked",
+  "sources": ["one exact originating source"],
+  "findings": [{
+    "severity": "critical|high|medium|low",
+    "disposition": "blocking|advisory",
+    "location": "changed path:line or command",
+    "source": "exact requirement citation",
+    "evidence": "failure and cause evidence",
+    "repair_guidance": "advisory repair guidance or explicit limitation",
+    "resolution_evidence": "resolution behavior or regression test"
+  }]
+}
 ```
 
 ## Standards fix verifier
@@ -135,17 +155,37 @@ For each new direct regression, explain failure and cause against its source;
 provide your own advisory bounded repair, rationale, important constraints,
 and resolution behavior or regression test. If a safe recommendation is not
 supported, state that limitation and why without suppressing the regression.
-Keep each field on one line, no tabs.
-
-Return no prose outside this tab-separated schema:
-format<TAB>darrow-review-fix-axis-v1
-axis<TAB>standards
-original<TAB>original finding key
-prior_regression<TAB>stable regression key<TAB>causing original finding key
-attempt<TAB>original finding key<TAB>resolved|unresolved|blocked<TAB>resolved|progressing|unchanged|unavailable<TAB>current evidence
-regression_attempt<TAB>stable prior regression key<TAB>resolved|unresolved|blocked<TAB>resolved|progressing|unchanged|unavailable<TAB>current evidence
-regression<TAB>causing original finding key<TAB>critical|high|medium|low<TAB>location<TAB>source<TAB>failure and cause evidence<TAB>advisory repair guidance or explicit limitation<TAB>resolution behavior or regression test
-evidence_gap<TAB>missing or inconsistent required evidence
+Encode every field as a JSON string; preserve tabs and newlines inside strings.
+
+Return one valid JSON object, with no prose or code fence. Replace placeholders, omit absent optional arrays, and repeat array entries as needed:
+{
+  "format": "darrow-review-fix-axis-v3",
+  "axis": "standards",
+  "originals": ["original finding key"],
+  "prior_regressions": [{"key": "stable regression key", "caused_by": "original finding key"}],
+  "attempts": [{
+    "key": "original finding key",
+    "status": "resolved|unresolved|blocked",
+    "progress": "resolved|progressing|unchanged|unavailable",
+    "evidence": "current evidence"
+  }],
+  "regression_attempts": [{
+    "key": "stable prior regression key",
+    "status": "resolved|unresolved|blocked",
+    "progress": "resolved|progressing|unchanged|unavailable",
+    "evidence": "current evidence"
+  }],
+  "regressions": [{
+    "caused_by": "original finding key",
+    "severity": "critical|high|medium|low",
+    "location": "location",
+    "source": "source",
+    "evidence": "failure and cause evidence",
+    "repair_guidance": "advisory repair guidance or explicit limitation",
+    "resolution_evidence": "resolution behavior or regression test"
+  }],
+  "evidence_gaps": ["missing or inconsistent required evidence"]
+}
 ```
 
 ## Spec fix verifier
@@ -195,15 +235,35 @@ For each new direct regression, explain failure and cause against its source;
 provide your own advisory bounded repair, rationale, important constraints,
 and resolution behavior or regression test. If a safe recommendation is not
 supported, state that limitation and why without suppressing the regression.
-Keep each field on one line, no tabs.
-
-Return no prose outside this tab-separated schema:
-format<TAB>darrow-review-fix-axis-v1
-axis<TAB>spec
-original<TAB>original finding key
-prior_regression<TAB>stable regression key<TAB>causing original finding key
-attempt<TAB>original finding key<TAB>resolved|unresolved|blocked<TAB>resolved|progressing|unchanged|unavailable<TAB>current evidence
-regression_attempt<TAB>stable prior regression key<TAB>resolved|unresolved|blocked<TAB>resolved|progressing|unchanged|unavailable<TAB>current evidence
-regression<TAB>causing original finding key<TAB>critical|high|medium|low<TAB>location<TAB>source<TAB>failure and cause evidence<TAB>advisory repair guidance or explicit limitation<TAB>resolution behavior or regression test
-evidence_gap<TAB>missing or inconsistent required evidence
+Encode every field as a JSON string; preserve tabs and newlines inside strings.
+
+Return one valid JSON object, with no prose or code fence. Replace placeholders, omit absent optional arrays, and repeat array entries as needed:
+{
+  "format": "darrow-review-fix-axis-v3",
+  "axis": "spec",
+  "originals": ["original finding key"],
+  "prior_regressions": [{"key": "stable regression key", "caused_by": "original finding key"}],
+  "attempts": [{
+    "key": "original finding key",
+    "status": "resolved|unresolved|blocked",
+    "progress": "resolved|progressing|unchanged|unavailable",
+    "evidence": "current evidence"
+  }],
+  "regression_attempts": [{
+    "key": "stable prior regression key",
+    "status": "resolved|unresolved|blocked",
+    "progress": "resolved|progressing|unchanged|unavailable",
+    "evidence": "current evidence"
+  }],
+  "regressions": [{
+    "caused_by": "original finding key",
+    "severity": "critical|high|medium|low",
+    "location": "location",
+    "source": "source",
+    "evidence": "failure and cause evidence",
+    "repair_guidance": "advisory repair guidance or explicit limitation",
+    "resolution_evidence": "resolution behavior or regression test"
+  }],
+  "evidence_gaps": ["missing or inconsistent required evidence"]
+}
 ```
diff --git a/plugins/capability/darrow-review/skills/code-review/references/fix-verification.md b/plugins/capability/darrow-review/skills/code-review/references/fix-verification.md
index 1824688f..4d611db3 100644
--- a/plugins/capability/darrow-review/skills/code-review/references/fix-verification.md
+++ b/plugins/capability/darrow-review/skills/code-review/references/fix-verification.md
@@ -19,7 +19,7 @@ Require all of these caller-owned inputs before reader calls:
   verification exists, including all carried regression records; and
 - current deterministic-check commands and evidence.
 
-When the original comprehensive `result.tsv` is retained, bind its absolute
+When the original comprehensive `result.json` is retained, bind its absolute
 path as `original_result` and use its sibling scope manifest for the first
 follow-up. Obtain canonical original records through the bundled helper before
 passing them to readers:
@@ -95,12 +95,12 @@ one, never execute the literal command directly. Use the main skill's resolved
 `review-check` as its sole execution boundary:
 
 ```sh
-check_record="$(dirname "$manifest")/check-1.tsv" # increment for later checks
+check_record="$(dirname "$manifest")/check-1.json" # increment for later checks
 uv run --quiet --no-project "$backend/scripts/run_locked.py" review-check run --output "$check_record" --command "$literal_command"
 ```
 
-Copy the retained record's canonical `check` row byte-for-byte into reader
-evidence and `verification.tsv`; never reinterpret the observed status. A check
+Preserve the retained record's canonical `checks` entry values exactly in reader
+evidence and `verification.json`; never reinterpret the observed status. A check
 failure belongs in the convergence set only as evidence for a direct
 repair-caused regression tied to an attempted original finding. An unavailable
 required check or failed evidence capture is an evidence gap and blocks
@@ -175,7 +175,7 @@ entered aggregation.
 ## 4. Derive and return verification
 
 Read [`result-protocol.md`](result-protocol.md) completely. Assemble
-`verification.tsv` beneath the current scope artifact directory. Preserve every
+`verification.json` beneath the current scope artifact directory. Preserve every
 original record and verifier state. Order direct regressions by causing
 original finding order, then by their reader order, and derive their stable
 regression keys mechanically. For a first verification write
@@ -198,7 +198,7 @@ This validates the verification schema and compares the complete original
 target and ordered findings against the comprehensive result. A mismatch is a
 serialization error: restore the helper's exact original rows without changing
 reader judgment. For a complete external handoff or validated prior verification,
-compare the original rows byte-for-byte with that authoritative input and run
+compare the original row field values and order exactly with that authoritative input and run
 ordinary `validate-verification`. Incomplete original evidence only permits a
 blocked record carrying that evidence gap.
 
@@ -219,7 +219,7 @@ uv run --quiet --no-project "$backend/scripts/run_locked.py" review-report rende
 Confirm that the report is a readable, nonempty regular file before the second
 renderer invocation. Make that second invocation the last tool command and
 copy its stdout verbatim as the entire final response. For an explicit
-verification-v1, raw TSV, or machine request, return the validated TSV bytes
+verification-v3, raw JSON, or machine request, return the validated JSON bytes
 only. In composed use, return the selected presentation and exit this read-only
 capability. The enclosing goal interprets the semantic outcome and owns every
 repair, stop, goal-status, completion, and publication decision.
diff --git a/plugins/capability/darrow-review/skills/code-review/references/reader-routing.md b/plugins/capability/darrow-review/skills/code-review/references/reader-routing.md
index e83cb39a..e81b9954 100644
--- a/plugins/capability/darrow-review/skills/code-review/references/reader-routing.md
+++ b/plugins/capability/darrow-review/skills/code-review/references/reader-routing.md
@@ -9,7 +9,7 @@ fix-verification reader in one invocation.
 Resolve the bundled helper from the code-review skill directory:
 
 ```sh
-route_record="$(dirname "$manifest")/reviewer-route.tsv"
+route_record="$(dirname "$manifest")/reviewer-route.json"
 uv run --quiet --no-project "$backend/scripts/run_locked.py" review-route select --repo "$repo" --host <codex|claude> \
   --record "$route_record"
 ```
@@ -27,7 +27,7 @@ provider. For Codex, an accepted native spawn therefore proves the provider as
 well as explicit model and effort; configuration alone never establishes an
 effective provider.
 
-Keep `reviewer-route.tsv` beside the scope manifest as route-selection
+Keep `reviewer-route.json` beside the scope manifest as route-selection
 evidence. Repository configuration comes only from the active worktree root.
 
 ## Codex readers
@@ -48,7 +48,7 @@ each exact child, collect only its final axis record, and then write that axis's
 route evidence beside the manifest:
 
 ```sh
-axis_route="$(dirname "$manifest")/<axis>-route.tsv"
+axis_route="$(dirname "$manifest")/<axis>-route.json"
 uv run --quiet --no-project "$backend/scripts/run_locked.py" review-route confirm-codex --route-record "$route_record" \
   --axis <axis> --agent-id '<host-reported-child-id>' \
   --application-record "$axis_route"
@@ -73,7 +73,7 @@ child ID are internally consistent. It is not launch evidence by itself. A
 Codex result is admissible only while the coordinator also retains the host's
 accepted `spawn_agent` event for that same child ID, exact model and effort,
 `fork_turns: none`, and a host-visible axis marker in the native task name or
-retained prompt. `confirm-codex` therefore writes a `route_bound<TAB>true`
+retained prompt. `confirm-codex` therefore writes a `["route_bound", "true"]`
 binding record, never a standalone verification claim. Missing native evidence
 still blocks the axis.
 
@@ -111,7 +111,7 @@ After each exact Agent call terminates, take its host-reported agent ID and
 derive the effective route from that child's transcript:
 
 ```sh
-observed_record="$(dirname "$manifest")/<axis>-observed-route.tsv"
+observed_record="$(dirname "$manifest")/<axis>-observed-route.json"
 uv run --quiet --no-project "$backend/scripts/run_locked.py" review-claude-verify --repo "$repo" --agent-id '<agent-id>' \
   --record "$observed_record"
 ```
@@ -120,7 +120,7 @@ Feed both record paths into the confirmation gate. The helper parses and
 compares the selected and transcript-observed values:
 
 ```sh
-axis_route="$(dirname "$manifest")/<axis>-route.tsv"
+axis_route="$(dirname "$manifest")/<axis>-route.json"
 uv run --quiet --no-project "$backend/scripts/run_locked.py" review-route confirm-claude --route-record "$route_record" \
   --observed-record "$observed_record" --axis <axis> \
   --application-record "$axis_route"
@@ -137,7 +137,7 @@ transcript is insufficient.
 ## Bind route failure
 
 In comprehensive mode, materialize a schema-valid axis record with
-`status<TAB>blocked` and a `source` naming the exact route evidence gap. In
+`["status", "blocked"]` and a `source` naming the exact route evidence gap. In
 fix-verification mode, materialize a schema-valid fix-axis record containing an
 `evidence_gap` naming it. Preserve the selected route record and any observed
 route record. Never replace unavailable independent judgment with coordinator
diff --git a/plugins/capability/darrow-review/skills/code-review/references/result-protocol.md b/plugins/capability/darrow-review/skills/code-review/references/result-protocol.md
index 385e89bc..0ef80512 100644
--- a/plugins/capability/darrow-review/skills/code-review/references/result-protocol.md
+++ b/plugins/capability/darrow-review/skills/code-review/references/result-protocol.md
@@ -5,31 +5,31 @@ Use the second additive protocol only for fix verification.
 
 ## Canonical artifact and output envelope
 
-Write and validate every result as `darrow-review-result-v1` TSV at the fixed
-`result.tsv` path directly beneath the scope artifact directory. It is the
-canonical mechanical artifact and every field is one line without tabs. Do not
-select an arbitrary TSV: `scope.tsv` and axis records are not aggregate results.
+Write and validate every result as `darrow-review-result-v3` JSON at the fixed
+`result.json` path directly beneath the scope artifact directory. It is the
+canonical mechanical artifact. JSON string escaping preserves tabs and newlines
+in fields. Do not select an arbitrary JSON: `scope.json` and axis records are
+not aggregate results.
 
 Default standalone and composed responses are a Markdown rendering of that
-validated artifact. Materialize it as `review.md` beside `result.tsv`, confirm
+validated artifact. Materialize it as `review.md` beside `result.json`, confirm
 that file is readable and nonempty, then use one dedicated final
 `uv run --quiet --no-project "$backend/scripts/run_locked.py" review-report render "$result_record"` invocation and return its complete
 stdout. The renderer preserves all fields, escapes hostile content, and does
-not include raw TSV. Only an explicit request for raw TSV, v1, or machine format
-returns the TSV bytes, beginning with `format<TAB>darrow-review-result-v1`,
-ending with the `next_action` record, and containing nothing else. This applies
+not include raw JSON. Only an explicit request for raw JSON, v3, or machine
+format returns the JSON bytes. The object has `"format": "darrow-review-result-v3"` and a required `next_action`. This applies
 to `pass`, `fail`, `blocked`, invalid-base, ambiguous-base, and empty-diff
 outcomes.
 
 The human rendering presents the verdict or outcome and next action first,
 then retains findings, checks, risks, scope, sources, and binding evidence in
-later sections. This order changes no canonical TSV field or meaning.
+later sections. This order changes no canonical JSON field or meaning.
 
 For an explicit review clause inside a larger goal, return the selected normal
 presentation rather than the enclosing goal's response envelope. The goal owner
 interprets its findings and outcome, applies the enclosing continuation contract,
 and may summarize the review in its own final response. Consumers do not need
-to parse or reproduce the TSV serialization.
+to parse or reproduce the JSON serialization.
 
 Use `next_action=return control to enclosing goal` for a composed pass,
 `next_action=return findings to enclosing goal` for a composed fail, and
@@ -40,42 +40,61 @@ publication remain outside this capability.
 ## Terminal scope failure
 
 For `review-scope prepare` exit 2, 3, or 4, invoke no reviewer. Emit no
-`changed_file` record. Preserve the requested base/target identifier when no OID
+`changed_files` entry. Preserve the requested base/target identifier when no OID
 was resolved. Set Standards to `blocked`; set Spec to `blocked` when a Spec was
 available or `not_available` when genuinely absent. Add the literal failed
 prepare command as one applicable blocked `check`, set verdict `blocked`, and
 make `next_action` the exact remediation reported by the scope tool. Run
-`review-scope allocate-terminal --repo <bound-repo>` and write `result.tsv`
+`review-scope allocate-terminal --repo <bound-repo>` and write `result.json`
 directly beneath its returned `artifact_dir`; this command provides a private
 review-state run and terminal manifest when scope preparation stopped early.
 
 ## Completed result schema
 
-Create exactly this tab-separated record; repeat only marked collections:
-
-```text
-format<TAB>darrow-review-result-v1
-base<TAB>resolved base OID
-target<TAB>resolved target OID or WORKTREE fingerprint
-changed_file<TAB>absolute path                         # repeat
-standards<TAB>pass|fail|blocked
-standards_source<TAB>absolute path or heuristic:name  # repeat
-spec<TAB>pass|fail|blocked|not_available
-spec_source<TAB>source identifier or not_available
-finding<TAB>standards|spec<TAB>critical|high|medium|low<TAB>blocking|advisory<TAB>changed path:line or command<TAB>violated source<TAB>failure and cause evidence<TAB>repair guidance<TAB>resolution evidence  # repeat
-check<TAB>literal command or none<TAB>applicable|not_applicable<TAB>pass|fail|blocked|not_applicable<TAB>evidence  # repeat
-verdict<TAB>pass|fail|blocked
-risk<TAB>concise residual risk or none observed       # repeat
-next_action<TAB>one authorized next step, or none
+Create one valid JSON object with these named fields. Replace placeholders and repeat array entries as needed:
+
+```json
+{
+  "format": "darrow-review-result-v3",
+  "base": "resolved base OID",
+  "target": "resolved target OID or WORKTREE fingerprint",
+  "changed_files": ["absolute changed path; repeat as needed"],
+  "standards": "pass|fail|blocked",
+  "standards_sources": ["absolute path or heuristic:name; repeat as needed"],
+  "spec": "pass|fail|blocked|not_available",
+  "spec_source": "source identifier or not_available",
+  "findings": [
+    {
+      "axis": "standards|spec",
+      "severity": "critical|high|medium|low",
+      "disposition": "blocking|advisory",
+      "location": "changed path:line or command",
+      "source": "violated source",
+      "evidence": "failure and cause evidence",
+      "repair_guidance": "advisory repair guidance",
+      "resolution_evidence": "observable resolution behavior or regression test"
+    }
+  ],
+  "checks": [
+    {
+      "command": "literal command or none",
+      "applicability": "applicable|not_applicable",
+      "status": "pass|fail|blocked|not_applicable",
+      "evidence": "captured evidence"
+    }
+  ],
+  "verdict": "pass|fail|blocked",
+  "risks": ["concise residual risk or none observed"],
+  "next_action": "one authorized next step, or none"
+}
 ```
 
-For a resolved scope, obtain the complete `base`, `target`, and `changed_file`
-records with `uv run --quiet --no-project "$backend/scripts/run_locked.py" review-result scope-records "$manifest"`. Insert those
-bytes into the aggregate; do not retype hashes or reconstruct the file list.
+For a resolved scope, obtain the complete `base`, `target`, and `changed_files`
+fields with `uv run --quiet --no-project "$backend/scripts/run_locked.py" review-result scope-records "$manifest"`. Copy them into the aggregate; do not retype hashes or reconstruct the file list.
 This command validates the pinned diff and refuses incomplete scope records.
 
-Every applicable `check` row is copied byte-for-byte from a retained
-`darrow-review-check-v1` artifact produced beneath this scope. Coordinator prose
+Every applicable `checks` entry preserves the exact field values from a retained
+`darrow-review-check-v3` artifact produced beneath this scope. Coordinator prose
 must not replace the captured command, status, or evidence.
 
 A failing axis has at least one blocking finding; advisory findings alone do
@@ -91,9 +110,9 @@ the finding. Resolution evidence describes observable behavior or a regression
 test demonstrating the required outcome; it is a proposed verification method,
 not a claim that a test has run or a new requirement.
 
-The two trailing fields are an additive v1 extension: validators and renderers
-also accept legacy findings with neither field. A partial pair, an empty field,
-or extra fields is invalid. New readers emit both; consumers preserve their
+The `repair_guidance` and `resolution_evidence` fields are optional as a pair:
+validators and renderers also accept findings with neither field. A partial
+pair, an empty field, or extra fields is invalid. New readers emit both; consumers preserve their
 presence or absence exactly. Human output labels repair guidance as advisory.
 The originating requirement, not the suggestion, determines resolution.
 
@@ -140,10 +159,10 @@ or deploy action inside review.
 
 ## Fix-verification artifact
 
-Write fix verification to `verification.tsv` directly beneath the current
+Write fix verification to `verification.json` directly beneath the current
 scope artifact directory. Never overwrite or reinterpret an original
-`result.tsv`. The additive format is `darrow-review-verification-v1`; the
-initial `darrow-review-result-v1` records remain readable, including legacy
+`result.json`. The additive format is `darrow-review-verification-v3`; the
+initial `darrow-review-result-v3` records remain readable, including legacy
 findings without guidance.
 
 The caller must supply the original comprehensive review target, its complete
@@ -170,27 +189,73 @@ Regression order is independent of original-finding order: start at `1` when no
 regression is carried, then assign new orders after the highest carried
 regression order.
 
-Create this tab-separated record in the shown order:
-
-```text
-format<TAB>darrow-review-verification-v1
-original_target<TAB>original comprehensive-review target fingerprint
-prior_target<TAB>immediately prior repair target fingerprint
-current_target<TAB>current pinned target fingerprint
-history_target<TAB>earlier repair target fingerprint                 # repeat
-previous_verification<TAB>none<TAB>none                              # first verification
-previous_verification<TAB>Git blob checksum<TAB>absolute prior verification artifact # later verification
-original_finding<TAB>stable key<TAB>standards|spec<TAB>canonical positive order<TAB>critical|high|medium|low<TAB>blocking|advisory<TAB>location<TAB>source<TAB>original evidence<TAB>original repair guidance<TAB>original resolution evidence  # repeat
-attempt<TAB>original finding key<TAB>resolved|unresolved|blocked<TAB>resolved|progressing|unchanged|unavailable<TAB>current evidence  # repeat
-regression<TAB>stable regression key<TAB>causing original finding key<TAB>canonical positive order<TAB>standards|spec<TAB>critical|high|medium|low<TAB>resolved|unresolved|blocked<TAB>resolved|progressing|unchanged|unavailable<TAB>location<TAB>source<TAB>current evidence<TAB>repair guidance<TAB>resolution evidence  # repeat
-check<TAB>literal command or none<TAB>applicable|not_applicable<TAB>pass|fail|blocked|not_applicable<TAB>evidence  # repeat
-evidence_gap<TAB>missing or inconsistent required evidence           # repeat
-outcome<TAB>clear|continue|no_progress|blocked
-next_action<TAB>one authorized enclosing-goal action, or none
+Create one valid JSON object with these named fields. Choose one previous-verification binding, omit absent optional arrays, and repeat array entries as needed:
+
+```json
+{
+  "format": "darrow-review-verification-v3",
+  "original_target": "original comprehensive-review target fingerprint",
+  "prior_target": "immediately prior repair target fingerprint",
+  "current_target": "current pinned target fingerprint",
+  "history_targets": ["earlier repair target fingerprint; omit when none"],
+  "previous_verification": {
+    "checksum": "none or Git blob checksum",
+    "path": "none or absolute prior verification artifact"
+  },
+  "original_findings": [
+    {
+      "key": "stable finding key",
+      "axis": "standards|spec",
+      "order": "canonical positive order",
+      "severity": "critical|high|medium|low",
+      "disposition": "blocking|advisory",
+      "location": "location",
+      "source": "source",
+      "evidence": "original evidence",
+      "repair_guidance": "original advisory guidance",
+      "resolution_evidence": "original resolution evidence"
+    }
+  ],
+  "attempts": [
+    {
+      "key": "original finding key",
+      "status": "resolved|unresolved|blocked",
+      "progress": "resolved|progressing|unchanged|unavailable",
+      "evidence": "current evidence"
+    }
+  ],
+  "regressions": [
+    {
+      "key": "stable regression key",
+      "caused_by": "causing original finding key",
+      "order": "canonical positive order",
+      "axis": "standards|spec",
+      "severity": "critical|high|medium|low",
+      "status": "resolved|unresolved|blocked",
+      "progress": "resolved|progressing|unchanged|unavailable",
+      "location": "location",
+      "source": "source",
+      "evidence": "current evidence",
+      "repair_guidance": "advisory repair guidance",
+      "resolution_evidence": "observable resolution evidence"
+    }
+  ],
+  "checks": [
+    {
+      "command": "literal command or none",
+      "applicability": "applicable|not_applicable",
+      "status": "pass|fail|blocked|not_applicable",
+      "evidence": "captured evidence"
+    }
+  ],
+  "evidence_gaps": ["missing or inconsistent required evidence"],
+  "outcome": "clear|continue|no_progress|blocked",
+  "next_action": "one authorized enclosing-goal action, or none"
+}
 ```
 
-Every applicable verification `check` row likewise comes byte-for-byte from its
-retained `darrow-review-check-v1` artifact. The reader receives the same row, so
+Every applicable verification `checks` entry likewise preserves exact field values from its
+retained `darrow-review-check-v3` artifact. The reader receives the same values, so
 aggregation cannot turn a failed command into a pass.
 
 Every blocking original finding has exactly one attempt. An advisory may remain
@@ -216,10 +281,10 @@ uv run --quiet --no-project "$backend/scripts/run_locked.py" review-result valid
 uv run --quiet --no-project "$backend/scripts/run_locked.py" review-result validate-fix-axis spec "$spec_fix_record"
 ```
 
-The fix-axis schema declares supplied original keys with `original`, active
-carried regressions with `prior_regression`, original states with `attempt`,
-carried states with `regression_attempt`, newly detected direct regressions with
-`regression`, and missing evidence with `evidence_gap`. Without an explicit
+The fix-axis schema declares supplied original keys in `originals`, active
+carried regressions in `prior_regressions`, original states in `attempts`,
+carried states in `regression_attempts`, newly detected direct regressions in
+`regressions`, and missing evidence in `evidence_gaps`. Without an explicit
 evidence gap, every supplied original and carried regression must have exactly
 one corresponding state record.
 
@@ -247,7 +312,7 @@ uv run --quiet --no-project "$backend/scripts/run_locked.py" review-result valid
 That command validates the record and prior-verification chain. The
 fix-verification workflow also requires `validate-original` whenever the original
 comprehensive result is retained. Obtain
-the immutable rows with `original-findings`; do not retype their evidence or
+the immutable objects with `original-findings`; do not retype their evidence or
 assign a new finding order. An external handoff without that artifact still
 requires complete immutable original records, preserved exactly as supplied;
 missing original evidence requires a blocked gap.
@@ -263,7 +328,7 @@ uv run --quiet --no-project "$backend/scripts/run_locked.py" review-report rende
 After confirming `verification.md` is readable and nonempty, make the second
 renderer invocation the last tool command and copy its stdout verbatim as the
 entire response. A handwritten summary is incomplete. When the requester
-explicitly asks for verification TSV or machine format, return only the
-validated TSV bytes. A composed caller interprets `clear`, `continue`,
+explicitly asks for verification JSON or machine format, return only the
+validated JSON bytes. A composed caller interprets `clear`, `continue`,
 `no_progress`, or `blocked` semantically and retains all repair, stop,
 goal-status, and publication authority outside this read-only capability.
diff --git a/plugins/capability/darrow-verification/.claude-plugin/plugin.json b/plugins/capability/darrow-verification/.claude-plugin/plugin.json
index fc4ffc9d..4e170411 100644
--- a/plugins/capability/darrow-verification/.claude-plugin/plugin.json
+++ b/plugins/capability/darrow-verification/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "darrow-verification",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Bounded acceptance verification through replaceable independent code review",
   "license": "BUSL-1.1",
   "author": {
diff --git a/plugins/capability/darrow-verification/.codex-plugin/plugin.json b/plugins/capability/darrow-verification/.codex-plugin/plugin.json
index 5ca8c5af..b4a8907d 100644
--- a/plugins/capability/darrow-verification/.codex-plugin/plugin.json
+++ b/plugins/capability/darrow-verification/.codex-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "darrow-verification",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Bounded acceptance verification through replaceable independent code review",
   "author": {
     "name": "Björn Rochel",
diff --git a/plugins/capability/darrow-verification/skills/verify-change/evals/existing-review.yaml b/plugins/capability/darrow-verification/skills/verify-change/evals/existing-review.yaml
index 80b27c58..dc7f1326 100644
--- a/plugins/capability/darrow-verification/skills/verify-change/evals/existing-review.yaml
+++ b/plugins/capability/darrow-verification/skills/verify-change/evals/existing-review.yaml
@@ -50,20 +50,20 @@ checks:
     run: test "$(git rev-list --count HEAD)" -eq 1
   - name: retained report handoff is rendered last
     run: |
-      record=$(find .git -name result.tsv -type f)
+      record=$(find .git -name result.json -type f)
       test -n "$record" || exit 1
       report=$(cd "$(dirname "$record")" && pwd -P)/review.md
       last=$(awk 'NF { line=$0 } END { print line }' .git/last-message.md)
       test "$last" = "Complete provider result: [report](<$report>)"
   - name: existing provider retains a canonical failing current review
     run:
-      record=$(find .git -name result.tsv -type f) && test -n "$record" && test
-      "$(printf '%s\n' "$record" | wc -l | tr -d ' ')" = 1 && grep -q
-      '^verdict[[:space:]]fail' "$record" && test -s "$(dirname
+      record=$(find .git -name result.json -type f) && test -n "$record" && test
+      "$(printf '%s\n' "$record" | wc -l | tr -d ' ')" = 1 && python3 -c
+      'import json, sys; assert json.load(open(sys.argv[1]))["verdict"] == "fail"' "$record" && test -s "$(dirname
       "$record")/review.md"
   - name: existing result and complete provider report validate
     run: >
-      record=$(find .git -name result.tsv -type f 2>/dev/null | sort | tail -n
+      record=$(find .git -name result.json -type f 2>/dev/null | sort | tail -n
       1)
 
       result_tool=$(find .git/eval-marketplace .git/eval-plugins -path
@@ -79,7 +79,7 @@ checks:
       "$record" >.git/expected-review.md && cmp .git/expected-review.md
       "$(dirname "$record")/review.md"
   - name: complete existing report remains accessible to caller
-    run: record=$(find .git -name result.tsv -type f) && report=$(cd "$(dirname
+    run: record=$(find .git -name result.json -type f) && report=$(cd "$(dirname
       "$record")" && pwd -P)/review.md && grep -F "$report" .git/last-message.md
 semantic_output_checks:
   - name: consume actual provider finding
diff --git a/plugins/orchestration/darrow-adaptive-delivery/.claude-plugin/plugin.json b/plugins/orchestration/darrow-adaptive-delivery/.claude-plugin/plugin.json
index ed62600c..c2fa3431 100644
--- a/plugins/orchestration/darrow-adaptive-delivery/.claude-plugin/plugin.json
+++ b/plugins/orchestration/darrow-adaptive-delivery/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "darrow-adaptive-delivery",
   "description": "Adaptive Delivery: diagnose host capacity or launch one routed owner for bounded engineering work",
-  "version": "0.23.5",
+  "version": "0.23.7",
   "license": "BUSL-1.1",
   "author": {
     "name": "Björn Rochel",
diff --git a/plugins/orchestration/darrow-adaptive-delivery/.codex-plugin/plugin.json b/plugins/orchestration/darrow-adaptive-delivery/.codex-plugin/plugin.json
index c26a48f9..6ef466e2 100644
--- a/plugins/orchestration/darrow-adaptive-delivery/.codex-plugin/plugin.json
+++ b/plugins/orchestration/darrow-adaptive-delivery/.codex-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "darrow-adaptive-delivery",
-  "version": "0.23.5",
+  "version": "0.23.7",
   "description": "Adaptive Delivery: diagnose host capacity or launch one routed owner for bounded engineering work",
   "author": {
     "name": "Björn Rochel",
diff --git a/plugins/orchestration/darrow-adaptive-delivery/backend/src/darrow_adaptive_delivery/fixtures/proof.py b/plugins/orchestration/darrow-adaptive-delivery/backend/src/darrow_adaptive_delivery/fixtures/proof.py
index 08475f00..2735e36a 100644
--- a/plugins/orchestration/darrow-adaptive-delivery/backend/src/darrow_adaptive_delivery/fixtures/proof.py
+++ b/plugins/orchestration/darrow-adaptive-delivery/backend/src/darrow_adaptive_delivery/fixtures/proof.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import subprocess
 from pathlib import Path
 
@@ -14,11 +15,14 @@ class InvalidProofError(Exception):
 
 
 def field(path: Path, name: str) -> str:
-    return "\n".join(
-        row.split("\t")[1]
-        for row in path.read_text(encoding="utf-8").splitlines()
-        if row.startswith(name + "\t")
-    )
+    try:
+        record = json.loads(path.read_text(encoding="utf-8"))
+    except (ValueError, RecursionError) as exc:
+        raise InvalidProofError(f"invalid review JSON: {path}") from exc
+    value = record.get(name) if isinstance(record, dict) else None
+    if not isinstance(value, str):
+        raise InvalidProofError(f"invalid review JSON field {name}: {path}")
+    return value
 
 
 def provider(git_dir: Path) -> Path:
@@ -65,8 +69,8 @@ def canonical_record(git_dir: Path, selected: str) -> Path:
     ):
         raise InvalidProofError(f"not a canonical fixture review artifact: {path}")
     if path.name not in {
-        "result.tsv",
-        "verification.tsv",
+        "result.json",
+        "verification.json",
         "review.md",
         "verification.md",
     }:
@@ -80,9 +84,9 @@ def machine_record(backend: Path, repo: Path, path: Path) -> Path:
     if not (backend / "src/darrow_review/report.py").is_file():
         raise InvalidProofError("installed review renderer is missing")
     name, render = (
-        ("result.tsv", "render")
+        ("result.json", "render")
         if path.name == "review.md"
-        else ("verification.tsv", "render-verification")
+        else ("verification.json", "render-verification")
     )
     record = path.with_name(name)
     rendered = invoke(backend, repo, "review-report", render, str(record))
@@ -94,7 +98,7 @@ def machine_record(backend: Path, repo: Path, path: Path) -> Path:
 def original_record(git_dir: Path, target: str) -> Path:
     matches = [
         path
-        for path in git_dir.rglob("result.tsv")
+        for path in git_dir.rglob("result.json")
         if path.parent.name.startswith("darrow-review.")
         and field(path, "target") == target
     ]
@@ -106,15 +110,15 @@ def original_record(git_dir: Path, target: str) -> Path:
 
 def reviewed_target(backend: Path, repo: Path, git_dir: Path, path: Path) -> str:
     format_name = field(path, "format")
-    if format_name == "darrow-review-result-v1":
+    if format_name == "darrow-review-result-v3":
         return comprehensive_target(backend, repo, path)
-    if format_name == "darrow-review-verification-v1":
+    if format_name == "darrow-review-verification-v3":
         return verification_target(backend, repo, git_dir, path)
     raise InvalidProofError(f"unsupported format: {format_name}")
 
 
 def comprehensive_target(backend: Path, repo: Path, path: Path) -> str:
-    if path.name != "result.tsv":
+    if path.name != "result.json":
         raise InvalidProofError("wrong comprehensive artifact name")
     invoke(backend, repo, "review-result", "validate", str(path))
     if field(path, "verdict") != "pass":
@@ -125,7 +129,7 @@ def comprehensive_target(backend: Path, repo: Path, path: Path) -> str:
 
 
 def verification_target(backend: Path, repo: Path, git_dir: Path, path: Path) -> str:
-    if path.name != "verification.tsv":
+    if path.name != "verification.json":
         raise InvalidProofError("wrong verification artifact name")
     invoke(backend, repo, "review-result", "validate-verification", str(path))
     if field(path, "outcome") != "clear":
@@ -152,9 +156,13 @@ def current(backend: Path, repo: Path, target: str) -> None:
         "--target",
         "WORKTREE",
     )
-    actual = "\n".join(
-        row.split("\t")[1] for row in scope.splitlines() if row.startswith("target\t")
-    )
+    try:
+        value = json.loads(scope)
+        actual = value["target"]
+        if not isinstance(actual, str):
+            raise TypeError("target must be a string")
+    except (ValueError, KeyError, TypeError) as exc:
+        raise InvalidProofError("invalid review scope JSON") from exc
     if not target or target != actual:
         raise InvalidProofError(f"stale review target: {target}; current: {actual}")
 
diff --git a/plugins/orchestration/darrow-adaptive-delivery/backend/tests/test_proof.py b/plugins/orchestration/darrow-adaptive-delivery/backend/tests/test_proof.py
index 65f751b3..71520f6d 100644
--- a/plugins/orchestration/darrow-adaptive-delivery/backend/tests/test_proof.py
+++ b/plugins/orchestration/darrow-adaptive-delivery/backend/tests/test_proof.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import subprocess
 from pathlib import Path
 
@@ -29,7 +30,7 @@ def invoke(_backend: Path, _repo: Path, *args: str) -> str:
         result.append(args)
         if args[0] == "review-report":
             return "Canonical human report\n"
-        return "target\tWORKTREE@current\n"
+        return json.dumps({"target": "WORKTREE@current"})
 
     monkeypatch.setattr(proof, "invoke", invoke)
     return result
@@ -37,15 +38,29 @@ def invoke(_backend: Path, _repo: Path, *args: str) -> str:
 
 def comprehensive(repo: Path) -> Path:
     return write(
-        repo / ".git/darrow-review.original/result.tsv",
-        "format\tdarrow-review-result-v1\nverdict\tpass\nnext_action\treturn control to enclosing goal\ntarget\tWORKTREE@current\n",
+        repo / ".git/darrow-review.original/result.json",
+        json.dumps(
+            {
+                "format": "darrow-review-result-v3",
+                "verdict": "pass",
+                "next_action": "return control to enclosing goal",
+                "target": "WORKTREE@current",
+            }
+        ),
     )
 
 
 def verification(repo: Path) -> Path:
     return write(
-        repo / ".git/darrow-review.repair/verification.tsv",
-        "format\tdarrow-review-verification-v1\noutcome\tclear\noriginal_target\tWORKTREE@current\ncurrent_target\tWORKTREE@current\n",
+        repo / ".git/darrow-review.repair/verification.json",
+        json.dumps(
+            {
+                "format": "darrow-review-verification-v3",
+                "outcome": "clear",
+                "original_target": "WORKTREE@current",
+                "current_target": "WORKTREE@current",
+            }
+        ),
     )
 
 
@@ -114,8 +129,8 @@ def test_provider_discovery_and_conflicts(repo: Path) -> None:
     "relative,error",
     [
         ("missing", "unreadable"),
-        ("outside.tsv", "not a canonical"),
-        (".git/darrow-review.test/other.tsv", "not a canonical"),
+        ("outside.json", "not a canonical"),
+        (".git/darrow-review.test/other.json", "not a canonical"),
     ],
 )
 def test_proof_path_refusals(repo: Path, relative: str, error: str) -> None:
@@ -137,13 +152,19 @@ def test_bad_modes_and_missing_saved_evidence(repo: Path) -> None:
 @pytest.mark.parametrize(
     "replacement,error",
     [
-        (("verdict\tpass", "verdict\tfail"), "not clear"),
+        (('"verdict": "pass"', '"verdict": "fail"'), "not clear"),
         (
-            ("next_action\treturn control to enclosing goal", "next_action\tcontinue"),
+            (
+                '"next_action": "return control to enclosing goal"',
+                '"next_action": "continue"',
+            ),
             "did not return",
         ),
-        (("target\tWORKTREE@current", "target\tWORKTREE@old"), "stale review"),
-        (("format\tdarrow-review-result-v1", "format\tunknown"), "unsupported format"),
+        (('"target": "WORKTREE@current"', '"target": "WORKTREE@old"'), "stale review"),
+        (
+            ('"format": "darrow-review-result-v3"', '"format": "unknown"'),
+            "unsupported format",
+        ),
     ],
 )
 def test_comprehensive_refusals(
@@ -157,15 +178,34 @@ def test_comprehensive_refusals(
     assert not (repo / ".git/goal-complete").exists()
 
 
+def test_proof_rejects_legacy_array_record(repo: Path) -> None:
+    provider(repo)
+    record = comprehensive(repo)
+    record.write_text(
+        json.dumps(
+            [
+                ["format", "darrow-review-result-v2"],
+                ["target", "WORKTREE@current"],
+                ["verdict", "pass"],
+            ]
+        ),
+        encoding="utf-8",
+    )
+    with pytest.raises(
+        proof.InvalidProofError, match="invalid review JSON field format"
+    ):
+        proof.validate(repo, "complete", str(record))
+
+
 def test_artifact_names(repo: Path, calls: list[tuple[str, ...]]) -> None:
     backend = provider(repo)
     original = comprehensive(repo)
-    wrong = original.with_name("verification.tsv")
+    wrong = original.with_name("verification.json")
     original.rename(wrong)
     with pytest.raises(proof.InvalidProofError, match="wrong comprehensive"):
         proof.validate(repo, "complete", str(wrong))
     repaired = verification(repo)
-    wrong = repaired.with_name("result.tsv")
+    wrong = repaired.with_name("result.json")
     repaired.rename(wrong)
     with pytest.raises(proof.InvalidProofError, match="wrong verification"):
         proof.validate(repo, "complete", str(wrong))
@@ -182,10 +222,12 @@ def test_verification_requires_clear_and_original(
     with pytest.raises(proof.InvalidProofError, match=r"original.*missing"):
         proof.validate(repo, "complete", str(record))
     original = comprehensive(repo)
-    write(repo / ".git/darrow-review.duplicate/result.tsv", original.read_text())
+    write(repo / ".git/darrow-review.duplicate/result.json", original.read_text())
     with pytest.raises(proof.InvalidProofError, match=r"original.*ambiguous"):
         proof.validate(repo, "complete", str(record))
-    record.write_text(record.read_text().replace("outcome\tclear", "outcome\tcontinue"))
+    record.write_text(
+        record.read_text().replace('"outcome": "clear"', '"outcome": "continue"')
+    )
     with pytest.raises(proof.InvalidProofError, match="verification is not clear"):
         proof.validate(repo, "complete", str(record))
 
diff --git a/plugins/orchestration/darrow-adaptive-delivery/skills/adaptive-delivery/evals/high-risk-routine.yaml b/plugins/orchestration/darrow-adaptive-delivery/skills/adaptive-delivery/evals/high-risk-routine.yaml
index c872f9c5..fc7b4ebf 100644
--- a/plugins/orchestration/darrow-adaptive-delivery/skills/adaptive-delivery/evals/high-risk-routine.yaml
+++ b/plugins/orchestration/darrow-adaptive-delivery/skills/adaptive-delivery/evals/high-risk-routine.yaml
@@ -47,7 +47,7 @@ fixture:
           node auth-config.test.js
           git_dir=$(git rev-parse --git-dir)
           mkdir -p "$git_dir/fixture-state"
-          scope_count=$(find "$git_dir" -maxdepth 2 -name scope.tsv -path '*/darrow-review.*/*' | wc -l | tr -d ' ')
+          scope_count=$(find "$git_dir" -maxdepth 2 -name scope.json -path '*/darrow-review.*/*' | wc -l | tr -d ' ')
           printf 'check\t%s\n' "$scope_count" >>"$git_dir/fixture-state/high-risk-review-events"
         mark-complete.sh: |
           #!/usr/bin/env bash
diff --git a/plugins/orchestration/darrow-adaptive-delivery/skills/adaptive-delivery/evals/verification-existing-review.yaml b/plugins/orchestration/darrow-adaptive-delivery/skills/adaptive-delivery/evals/verification-existing-review.yaml
index 6e597dcb..499422e0 100644
--- a/plugins/orchestration/darrow-adaptive-delivery/skills/adaptive-delivery/evals/verification-existing-review.yaml
+++ b/plugins/orchestration/darrow-adaptive-delivery/skills/adaptive-delivery/evals/verification-existing-review.yaml
@@ -50,15 +50,14 @@ checks:
       test "$(git rev-list --count HEAD)" -eq 1
   - name: real provider returns a closed clear repair assessment
     run: |
-      record=$(find .git -maxdepth 2 -name verification.tsv -path '*/darrow-review.*/*' | sort | tail -n 1)
+      record=$(find .git -maxdepth 2 -name verification.json -path '*/darrow-review.*/*' | sort | tail -n 1)
       test -n "$record"
       tool=$(find .git -path '*/backend/src/darrow_review/result.py' -type f | sort | tail -n 1)
       test -n "$tool"
       uv run --quiet --frozen --no-dev --project "${tool%/src/darrow_review/result.py}" review-result validate-verification "$record"
-      # Retain the bounded immutable finding rows when diagnosing a history loss.
-      find .git -maxdepth 2 -name result.tsv -path '*/darrow-review.*/*' -exec awk -F '\t' '$1 == "target" || $1 == "finding" { print FILENAME ":" $0 }' {} \;
-      awk -F '\t' '$1 == "original_target" || $1 == "original_finding" { print FILENAME ":" $0 }' "$record"
-      grep -F 'outcome	clear' "$record" >/dev/null
+      # Retain the bounded immutable findings when diagnosing a history loss.
+      find .git -maxdepth 2 -name result.json -path '*/darrow-review.*/*' -exec python3 -c 'import json, sys; record = json.load(open(sys.argv[1])); print(record["target"], *record.get("findings", []), sep="\n")' {} \;
+      python3 -c 'import json, sys; record = json.load(open(sys.argv[1])); print(record["original_target"], *record.get("original_findings", []), sep="\n"); assert record["outcome"] == "clear"' "$record"
       uv run --quiet --frozen --no-dev --project .git/fixture-backend adaptive-delivery-fixture proof complete "$record"
       uv run --quiet --frozen --no-dev --project .git/fixture-backend adaptive-delivery-fixture proof current
 semantic_output_checks: