@gonrocca/nodd 0.1.0

package/src/state.test.ts

@@ -0,0 +1,153 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { observation, type Observation } from "./observations.ts";
+import { emptyCommitted, fold, foldAll } from "./state.ts";
+
+let seq = 0;
+function obs(fields: Partial<Observation> & { toolName: string }): Observation {
+  return observation({
+    toolCallId: fields.toolCallId ?? `call_${++seq}`,
+    toolName: fields.toolName,
+    input: fields.input ?? {},
+    isError: fields.isError ?? false,
+    resultText: fields.resultText ?? "",
+    at: fields.at ?? "2026-09-19T10:00:00.000Z",
+  });
+}
+
+test("a fixed sequence folds into an exact snapshot", () => {
+  seq = 0;
+  const events: Observation[] = [
+    obs({ toolName: "read", input: { path: "a.ts" } }),
+    obs({ toolName: "read", input: { path: "b.ts" } }),
+    obs({ toolName: "read", input: { path: "a.ts" } }),
+    obs({ toolName: "grep", input: { pattern: "x" } }),
+    obs({ toolName: "ls", input: { path: "." } }),
+    obs({ toolName: "write", input: { path: "c.ts" } }),
+    obs({ toolName: "edit", input: { path: "c.ts" } }),
+    obs({ toolName: "edit", input: { path: "d.ts" } }),
+    obs({ toolName: "bash", input: { command: "npm test" }, resultText: "ok" }),
+    obs({ toolName: "bash", input: { command: "echo hi > f.txt" } }),
+    obs({ toolName: "subagent", input: { agent: "nodd-explore" } }),
+    obs({ toolName: "nodd_declare", input: { intent: "change", route: "tracked", slug: "demo" } }),
+  ];
+
+  const committed = foldAll(emptyCommitted(), events);
+  assert.deepEqual([...committed.filesRead], ["a.ts", "b.ts"]);
+  assert.deepEqual([...committed.filesWritten.keys()], ["c.ts", "d.ts"]);
+  assert.equal(committed.delegations, 1);
+  assert.equal(committed.toolCalls, 12);
+  assert.deepEqual(committed.declaration, {
+    intent: "change", route: "tracked", slug: "demo", runner: null, tdd: "off", files: [],
+  });
+  // Bash records are stored raw. Whether a command mutates is the classifier's
+  // judgement (T014) and is derived at gate time, so the ledger never
+  // pre-collapses an observation into a verdict.
+  assert.deepEqual(committed.commandResults.map((r) => r.command), ["npm test", "echo hi > f.txt"]);
+  assert.deepEqual(committed.commandResults[0], {
+    toolCallId: "call_9", command: "npm test", isError: false, resultText: "ok",
+    at: "2026-09-19T10:00:00.000Z", seq: 9,
+  });
+});
+
+test("distinct-path counting: one file read six times is one file", () => {
+  const events = Array.from({ length: 6 }, () => obs({ toolName: "read", input: { path: "same.ts" } }));
+  const committed = foldAll(emptyCommitted(), events);
+  assert.equal(committed.filesRead.size, 1);
+  assert.equal(committed.toolCalls, 6);
+});
+
+test("replay is idempotent by toolCallId", () => {
+  const events = [
+    obs({ toolCallId: "r1", toolName: "read", input: { path: "a.ts" } }),
+    obs({ toolCallId: "w1", toolName: "write", input: { path: "b.ts" } }),
+    obs({ toolCallId: "b1", toolName: "bash", input: { command: "rm -rf x" } }),
+  ];
+  const once = foldAll(emptyCommitted(), events);
+  const twice = foldAll(emptyCommitted(), [...events, ...events]);
+  assert.deepEqual(twice, once);
+});
+
+// Without this, "the evidence ran after the edit" is not computable at all: a
+// Set of paths has no ordering against a command result, which is how a green
+// run predating the edit certified the edit in round 1.
+test("a written file records when it was written, so evidence can be ordered against it", () => {
+  const committed = foldAll(emptyCommitted(), [
+    obs({ toolName: "write", input: { path: "c.ts" }, at: "2026-09-19T10:00:00.000Z" }),
+    obs({ toolName: "edit", input: { path: "d.ts" }, at: "2026-09-19T11:00:00.000Z" }),
+  ]);
+  assert.deepEqual(committed.filesWritten.get("c.ts"), { at: "2026-09-19T10:00:00.000Z", seq: 1 });
+  assert.deepEqual(committed.filesWritten.get("d.ts"), { at: "2026-09-19T11:00:00.000Z", seq: 2 });
+});
+
+// Wall clocks are not fine-grained enough to order two tool results that land in
+// the same millisecond, and in a real session a write and the run that follows
+// it routinely do. Observation order is what the kernel actually knows.
+test("observation order, not the clock, decides what came after what", () => {
+  const sameInstant = "2026-09-19T10:00:00.000Z";
+  const committed = foldAll(emptyCommitted(), [
+    obs({ toolName: "bash", input: { command: "npm test" }, at: sameInstant }),
+    obs({ toolName: "edit", input: { path: "c.ts" }, at: sameInstant }),
+  ]);
+  assert.equal(committed.commandResults[0].at, committed.filesWritten.get("c.ts")!.at, "the clock cannot tell them apart");
+  assert.ok(
+    committed.filesWritten.get("c.ts")!.seq > committed.commandResults[0].seq,
+    "but the kernel saw the edit second, and that is what ordering must use",
+  );
+});
+
+test("rewriting a file moves its timestamp forward: the latest edit is the one evidence must postdate", () => {
+  const committed = foldAll(emptyCommitted(), [
+    obs({ toolName: "write", input: { path: "c.ts" }, at: "2026-09-19T10:00:00.000Z" }),
+    obs({ toolName: "edit", input: { path: "c.ts" }, at: "2026-09-19T12:00:00.000Z" }),
+  ]);
+  assert.equal(committed.filesWritten.size, 1, "distinct paths, still");
+  assert.equal(committed.filesWritten.get("c.ts")!.at, "2026-09-19T12:00:00.000Z");
+});
+
+test("a declaration records its runner, its TDD mode and the files it promised to touch", () => {
+  const committed = foldAll(emptyCommitted(), [obs({
+    toolName: "nodd_declare",
+    input: { intent: "change", route: "tracked", slug: "demo", runner: "npm test", tdd: "strict", files: ["a.ts", "b.ts", "a.ts"] },
+  })]);
+  assert.equal(committed.declaration?.runner, "npm test");
+  assert.equal(committed.declaration?.tdd, "strict");
+  assert.deepEqual(committed.declaration?.files, ["a.ts", "b.ts"], "distinct paths, as gate-promotion counts them");
+});
+
+test("a declaration without a runner records none, and never invents one", () => {
+  const committed = foldAll(emptyCommitted(), [obs({
+    toolName: "nodd_declare", input: { intent: "change", route: "tracked", slug: "demo" },
+  })]);
+  assert.equal(committed.declaration?.runner, null);
+  assert.equal(committed.declaration?.tdd, "off");
+  assert.deepEqual(committed.declaration?.files, []);
+});
+
+test("folding is total: an unknown tool advances only the call count", () => {
+  const before = emptyCommitted();
+  const after = fold(before, obs({ toolName: "some_other_extension_tool", input: { weird: true } }));
+  assert.equal(after.toolCalls, 1);
+  assert.equal(after.filesRead.size, 0);
+  assert.equal(after.filesWritten.size, 0);
+  assert.equal(after.commandResults.length, 0);
+});
+
+test("a later declaration replaces the earlier one", () => {
+  const committed = foldAll(emptyCommitted(), [
+    obs({ toolName: "nodd_declare", input: { intent: "read-only", route: "inline", slug: "a" } }),
+    obs({ toolName: "nodd_declare", input: { intent: "change", route: "tracked", slug: "b" } }),
+  ]);
+  assert.deepEqual(committed.declaration, {
+    intent: "change", route: "tracked", slug: "b", runner: null, tdd: "off", files: [],
+  });
+});
+
+test("the reducer imports neither node:fs nor pi", () => {
+  const src = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "state.ts"), "utf8");
+  assert.ok(!src.includes("node:fs"), "state.ts must not touch the filesystem");
+  assert.ok(!src.includes("@earendil-works/"), "state.ts must not import pi");
+});

package/src/state.ts

@@ -0,0 +1,163 @@
+// The read-only kernel: `Observation[]` folded into committed state.
+//
+// Total, deterministic and idempotent by `toolCallId` — replaying a session on
+// reload must land on the same state, so a re-delivered event may never
+// double-count a file or a tool call. Nothing here reads the filesystem and
+// nothing imports pi: every rule downstream of this reducer is testable without
+// a runtime.
+//
+// Bash commands are recorded raw. Whether one mutates the filesystem is the
+// classifier's judgement (`src/bash-classifier.ts`) and is derived when a gate
+// asks, never baked into the record.
+
+import type { Observation, PendingCall } from "./observations.ts";
+import type { Intent, Route } from "./feature-doc.ts";
+
+export type CommandResult = {
+  toolCallId: string;
+  command: string;
+  isError: boolean;
+  resultText: string;
+  at: string;
+  /**
+   * Position in this session's observation order. `at` is a wall clock and two
+   * tool results can share a millisecond, so "did the run come after the edit?"
+   * is answered by the order the kernel observed them in — which it knows
+   * exactly — rather than by a timestamp's resolution. A rule that is only sound
+   * when the clock happens to tick between two events is not a mechanism.
+   */
+  seq: number;
+};
+
+/** When a file was written, and where that write sits in observation order. */
+export type WriteRecord = { at: string; seq: number };
+
+export type Declaration = {
+  intent: Intent;
+  route: Route;
+  slug: string;
+  /**
+   * The verification command this feature is checked with, as declared. Evidence
+   * must come from it: without this, any exit-0 string the model chose certifies
+   * any task, and `echo 'tests pass'` is a valid receipt.
+   */
+  runner: string | null;
+  tdd: "strict" | "off";
+  /** Distinct files the declaration promised to touch. `gate-promotion` reads it. */
+  files: string[];
+};
+
+export type Committed = {
+  seen: Set<string>;
+  filesRead: Set<string>;
+  /**
+   * path -> the most recent write to it. A `Set` made "the evidence ran after
+   * the edit" structurally uncomputable, which is how a green run predating an
+   * edit certified that edit.
+   */
+  filesWritten: Map<string, WriteRecord>;
+  commandResults: CommandResult[];
+  delegations: number;
+  toolCalls: number;
+  declaration: Declaration | null;
+};
+
+/**
+ * The whole session state. `committed` is advanced only by `tool_result`;
+ * `pending` holds calls preflighted in the current assistant batch. pi does not
+ * guarantee a `tool_call` handler sees its siblings' results
+ * (`extensions.md:757-758`), so the two halves are different types on purpose:
+ * evidence readers take `Committed` and therefore cannot reach a pending call.
+ */
+export type NoddState = {
+  committed: Committed;
+  pending: Map<string, PendingCall>;
+};
+
+export function emptyState(): NoddState {
+  return { committed: emptyCommitted(), pending: new Map() };
+}
+
+export function emptyCommitted(): Committed {
+  return {
+    seen: new Set(),
+    filesRead: new Set(),
+    filesWritten: new Map(),
+    commandResults: [],
+    delegations: 0,
+    toolCalls: 0,
+    declaration: null,
+  };
+}
+
+const READ_TOOLS = new Set(["read"]);
+const WRITE_TOOLS = new Set(["write", "edit"]);
+
+function str(value: unknown): string | null {
+  return typeof value === "string" && value !== "" ? value : null;
+}
+
+/** Distinct declared paths. Counted the same way written files are. */
+function declaredFiles(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  const paths = value.filter((entry): entry is string => typeof entry === "string" && entry !== "");
+  return [...new Set(paths)];
+}
+
+export function fold(committed: Committed, obs: Observation): Committed {
+  if (committed.seen.has(obs.toolCallId)) return committed;
+
+  const next: Committed = {
+    seen: new Set(committed.seen).add(obs.toolCallId),
+    filesRead: new Set(committed.filesRead),
+    filesWritten: new Map(committed.filesWritten),
+    commandResults: [...committed.commandResults],
+    delegations: committed.delegations,
+    toolCalls: committed.toolCalls + 1,
+    declaration: committed.declaration,
+  };
+
+  const path = str(obs.input.path);
+  if (READ_TOOLS.has(obs.toolName) && path) next.filesRead.add(path);
+  if (WRITE_TOOLS.has(obs.toolName) && path) next.filesWritten.set(path, { at: obs.at, seq: next.toolCalls });
+
+  if (obs.toolName === "bash") {
+    const command = str(obs.input.command);
+    if (command) {
+      next.commandResults.push({
+        toolCallId: obs.toolCallId,
+        command,
+        isError: obs.isError,
+        resultText: obs.resultText,
+        at: obs.at,
+        seq: next.toolCalls,
+      });
+    }
+  }
+
+  if (obs.toolName === "subagent") next.delegations += 1;
+
+  if (obs.toolName === "nodd_declare") {
+    const intent = str(obs.input.intent);
+    const route = str(obs.input.route);
+    const slug = str(obs.input.slug);
+    if (intent && route && slug) {
+      next.declaration = {
+        intent: intent as Intent,
+        route: route as Route,
+        slug,
+        runner: str(obs.input.runner),
+        // Anything but the literal `strict` is off. A mode NODD cannot read is
+        // not a mode it gets to assume.
+        tdd: obs.input.tdd === "strict" ? "strict" : "off",
+        files: declaredFiles(obs.input.files),
+      };
+    }
+  }
+
+  return next;
+}
+
+export function foldAll(committed: Committed, observations: Observation[]): Committed {
+  return observations.reduce(fold, committed);
+}

package/test/package-invariants.test.ts

@@ -0,0 +1,66 @@
+// T001 — the package manifest is a contract, so it is asserted like one.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+
+test("package.json is an ESM pi package", () => {
+  assert.equal(pkg.type, "module");
+  assert.ok(pkg.keywords.includes("pi-package"), "keywords must carry pi-package");
+  assert.equal(pkg.scripts.test, "node --test --experimental-strip-types");
+});
+
+test("pi.extensions is non-empty and every listed path exists", () => {
+  assert.ok(Array.isArray(pkg.pi?.extensions), "pi.extensions must be an array");
+  assert.ok(pkg.pi.extensions.length > 0, "pi.extensions must not be empty");
+  for (const rel of pkg.pi.extensions) {
+    assert.ok(existsSync(join(root, rel)), `missing extension entrypoint: ${rel}`);
+  }
+});
+
+test("pi is a peer dependency only", () => {
+  assert.ok(pkg.peerDependencies?.["@earendil-works/pi-coding-agent"], "pi must be a peerDependency");
+  assert.equal(pkg.dependencies, undefined, "the package ships no runtime dependencies");
+});
+
+// The scan covers every code and manifest file NODD ships. Prose files are
+// excluded on purpose: README.md must be free to *explain* the rule, and a test
+// that forbade naming the package would make the honest documentation
+// impossible to write.
+const SCANNED_DIRS = ["src", "extensions", "test", "spike"];
+
+function codeFiles(): string[] {
+  const out: string[] = [join(root, "package.json")];
+  const walk = (dir: string) => {
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry);
+      if (statSync(full).isDirectory()) walk(full);
+      else out.push(full);
+    }
+  };
+  for (const dir of SCANNED_DIRS) walk(join(root, dir));
+  return out;
+}
+
+test("no code file names the TUI package, not even as a type import", () => {
+  const forbidden = ["pi", "tui"].join("-");
+  for (const file of codeFiles()) {
+    const text = readFileSync(file, "utf8");
+    assert.ok(!text.includes(`@earendil-works/${forbidden}`), `${file} references the TUI package`);
+  }
+});
+
+test("no code file imports pi outside extensions/", () => {
+  // Assembled at runtime so this assertion does not match its own source.
+  const piSpecifier = `@earendil-works/${["pi", "coding", "agent"].join("-")}`;
+  for (const file of codeFiles()) {
+    if (file.startsWith(join(root, "extensions"))) continue;
+    const text = readFileSync(file, "utf8");
+    assert.ok(!text.includes(`from "${piSpecifier}"`), `${file} imports pi outside extensions/`);
+  }
+});

package/test/parity-matrix.test.ts

@@ -0,0 +1,272 @@
+/**
+ * The ODD parity matrix, checked against the code.
+ *
+ * `REQ: odd-parity-matrix` is the contract for what NODD inherits from ODD, and
+ * round 1 "verified" it with `assert.ok(README.includes("(M)"))` — which passes
+ * on any document containing that substring and proved nothing. Three rows were
+ * marked **(M)** with no mechanism behind them, which is the precise sin NODD
+ * accuses ODD of: claiming more than the machinery delivers.
+ *
+ * The rule enforced here: a row may call itself mechanized only if its
+ * justification names something that exists in this repository — a `REQ:` with
+ * acceptance criteria, a registered gate id, a source file, a tool, or a
+ * command. A (P) row must give a reason. Nothing may be unclassified.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { GATE_IDS } from "../src/gates/registry.ts";
+import { emptyDoc, parseFeatureDoc, renderFeatureDoc } from "../src/feature-doc.ts";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const requirements = readFileSync(join(root, ".sdd", "nodd", "requirements.md"), "utf8");
+
+type Row = { n: number; line: string; clause: string; klass: string; how: string };
+
+/** Every table row in the matrix section, which starts at the parity heading. */
+function matrixRows(): Row[] {
+  const start = requirements.indexOf("# ODD parity matrix");
+  assert.ok(start > 0, "the matrix section must exist");
+
+  const rows: Row[] = [];
+  for (const raw of requirements.slice(start).split("\n")) {
+    if (!raw.startsWith("|")) continue;
+    // An escaped pipe inside a cell (route unions like `inline|tracked`) is not a
+    // column separator. Splitting naively dropped those rows silently, which is
+    // exactly how a matrix row could go unchecked.
+    const cells = raw
+      .replace(/\\\|/g, "\u0000")
+      .split("|")
+      .slice(1, -1)
+      .map((cell) => cell.trim().replace(/\u0000/g, "|"));
+    if (cells.length !== 5) continue;
+    const n = Number(cells[0]);
+    if (!Number.isInteger(n)) continue;
+    rows.push({ n, line: cells[1], clause: cells[2], klass: cells[3], how: cells[4] });
+  }
+  return rows;
+}
+
+const rows = matrixRows();
+
+test("the matrix is a complete, contiguous, uniquely numbered table", () => {
+  assert.ok(rows.length >= 50, `expected the full ODD surface, parsed ${rows.length} rows`);
+  const numbers = rows.map((row) => row.n);
+  assert.deepEqual(numbers, [...new Set(numbers)], "a duplicated row number hides a clause");
+  assert.deepEqual(
+    numbers,
+    Array.from({ length: rows.length }, (_, i) => i + 1),
+    "row numbers must be contiguous from 1: a gap is an unclassified clause",
+  );
+});
+
+test("every row is classified, and every row cites the ODD line it came from", () => {
+  for (const row of rows) {
+    assert.match(row.klass, /\*\*(M|P|F)\*\*/, `row ${row.n} is unclassified: ${row.klass}`);
+    // One row may answer several ODD lines, or a range of them; each reference
+    // still has to be an actual citation.
+    for (const ref of row.line.split(",")) {
+      assert.match(ref.trim(), /^`:\d+(-\d+)?`$/, `row ${row.n} must cite routing.go lines, got ${row.line}`);
+    }
+    assert.ok(row.clause.length > 10, `row ${row.n} has no clause text`);
+  }
+});
+
+/**
+ * What counts as naming a mechanism. Each entry is a pattern plus a check that
+ * whatever it captured actually exists, so a row cannot satisfy this test by
+ * inventing a plausible-looking requirement name or a file that was never
+ * written.
+ */
+const MECHANISMS: Array<{ label: string; pattern: RegExp; exists: (name: string) => boolean }> = [
+  {
+    label: "a REQ with acceptance criteria",
+    pattern: /`REQ: ([a-z-]+)`/g,
+    exists: (name) => requirements.includes(`## REQ: ${name}`),
+  },
+  {
+    label: "a registered gate id",
+    pattern: /`gate-([a-z-]+)`/g,
+    exists: (name) => (GATE_IDS as readonly string[]).includes(name),
+  },
+  {
+    label: "a source file",
+    pattern: /`((?:src|extensions|test)\/[\w./-]+\.ts)`/g,
+    exists: (name) => fileExists(name),
+  },
+  {
+    label: "a named exported function",
+    pattern: /`([a-z][a-zA-Z]+)\(\)`/g,
+    exists: (name) =>
+      ["src/feature-doc.ts", "src/gates/evidence.ts", "src/ledger.ts", "extensions/nodd-kernel.ts"]
+        .some((file) => sourceOf(file).includes(`function ${name}`)),
+  },
+  {
+    label: "a nodd tool",
+    pattern: /`(nodd_[a-z]+)/g,
+    exists: (name) => sourceOf("extensions/nodd-kernel.ts").includes(`"${name}"`),
+  },
+  {
+    label: "a slash command",
+    pattern: /`(\/nodd-[a-z]+)/g,
+    exists: (name) => fileExists(`extensions/${name.slice(1)}.ts`),
+  },
+];
+
+const cache = new Map<string, string>();
+function sourceOf(rel: string): string {
+  if (!cache.has(rel)) {
+    try {
+      cache.set(rel, readFileSync(join(root, rel), "utf8"));
+    } catch {
+      cache.set(rel, "");
+    }
+  }
+  return cache.get(rel)!;
+}
+function fileExists(rel: string): boolean {
+  return sourceOf(rel) !== "";
+}
+
+/** The mechanisms a row's justification names, and the ones it names falsely. */
+function citations(how: string): { found: string[]; missing: string[] } {
+  const found: string[] = [];
+  const missing: string[] = [];
+  for (const { pattern, exists } of MECHANISMS) {
+    for (const match of how.matchAll(pattern)) {
+      (exists(match[1]) ? found : missing).push(match[1]);
+    }
+  }
+  return { found, missing };
+}
+
+test("every (M) row names a mechanism that exists in this repository", () => {
+  // The claim under test: "mechanized" means there is machinery, not that the
+  // row's author intended some. Rows 13, 45 and 46 failed this in round 1.
+  const unbacked: string[] = [];
+  for (const row of rows) {
+    if (!row.klass.includes("**M**")) continue;
+    const { found, missing } = citations(row.how);
+    assert.deepEqual(missing, [], `row ${row.n} cites something that does not exist: ${missing.join(", ")}`);
+    if (found.length === 0) unbacked.push(`row ${row.n} (${row.line}): ${row.how.slice(0, 80)}`);
+  }
+  assert.deepEqual(
+    unbacked,
+    [],
+    `these rows claim (M) without naming any mechanism:\n${unbacked.join("\n")}`,
+  );
+});
+
+test("every (P) row gives a reason the clause is not mechanizable", () => {
+  // `REQ: odd-parity-matrix`: "we did not get to it" is not a reason.
+  for (const row of rows) {
+    if (!row.klass.includes("**P**")) continue;
+    assert.ok(row.how.length > 40, `row ${row.n} must say why, not just that: ${row.how}`);
+    assert.match(
+      row.how,
+      /judge?ment|judgement|not observable|natural language|prose|cannot|wording|taste|intent|proportional/i,
+      `row ${row.n} gives no reason the clause resists mechanization: ${row.how}`,
+    );
+    assert.ok(
+      !/did not get|todo|later|future|not yet implemented/i.test(row.how),
+      `row ${row.n} defers instead of giving a reason: ${row.how}`,
+    );
+  }
+});
+
+test("every (F) row points at the out-of-scope requirement that justifies it", () => {
+  for (const row of rows) {
+    if (!row.klass.includes("**F**")) continue;
+    assert.ok(
+      row.how.includes("odd-parity-out-of-scope") || row.how.length > 40,
+      `row ${row.n} must justify being out of scope: ${row.how}`,
+    );
+  }
+});
+
+// ---------------------------------------------------------------------------
+// The three rows the round-1 verdict caught, pinned individually so a
+// regression names the specific claim that broke.
+// ---------------------------------------------------------------------------
+
+function row(n: number): Row {
+  const found = rows.find((r) => r.n === n);
+  assert.ok(found, `row ${n} must exist`);
+  return found!;
+}
+
+test("row 13: the Outcome section is derived, so a pending check cannot be dropped", () => {
+  const doc = sourceOf("src/feature-doc.ts");
+  assert.ok(doc.includes("export function renderOutcome"), "the renderer must exist");
+  assert.ok(
+    /"## Outcome",\s*\n\s*"",\s*\n\s*\.\.\.renderOutcome\(doc\)/.test(doc),
+    "renderFeatureDoc must derive ## Outcome on every save, not accept a caller's text",
+  );
+  // `TaskEvidence.outcome` is legitimate: it holds one observed result. What must
+  // not exist is a doc-level outcome string, which is what used to let a caller
+  // write the closing report by hand and omit a failed check.
+  assert.ok(
+    !/^\s*outcome: string;/m.test(doc.slice(doc.indexOf("export type FeatureDoc"))),
+    "a doc-level free-text outcome field would let a caller omit a failed check",
+  );
+  assert.ok(
+    !/doc\.outcome/.test(sourceOf("extensions/nodd-kernel.ts")),
+    "and no caller may supply one",
+  );
+  assert.match(row(13).how, /renderOutcome|derived|task list/i, "the row must name the real mechanism");
+});
+
+// `includes` over a whole source file is H2's shape: renaming the fields while
+// leaving the words in a comment kept this green. The row claims the values are
+// recorded and survive, so the test round-trips them through the real renderer
+// and parser instead of reading the source for words.
+test("row 45: TDD mode, source and runner are recorded and reach the gate", () => {
+  const doc = emptyDoc({ slug: "row45", title: "Row 45" });
+  doc.verification = { runner: "npm test", tdd: "strict", source: "nodd_declare", files: ["a.ts"] };
+
+  const parsed = parseFeatureDoc(renderFeatureDoc(doc));
+  assert.deepEqual(parsed.defects, [], "the rendered doc must parse cleanly");
+  assert.deepEqual(
+    parsed.doc.verification,
+    { runner: "npm test", tdd: "strict", source: "nodd_declare", files: ["a.ts"] },
+    "mode, source, runner and files must survive the round trip",
+  );
+  assert.ok(
+    sourceOf("extensions/nodd-kernel.ts").includes("tdd:"),
+    "the kernel must pass the recorded mode to the evidence gate, or the row's RED clause is unreachable",
+  );
+});
+
+test("row 12: no NODD source issues a push, a PR or a merge", () => {
+  // A negative guarantee needs a mechanism too, and for "NODD never does X" the
+  // mechanism is a scan that fails when someone adds X.
+  const files = [
+    "src/gates/evidence.ts", "src/gates/track.ts", "src/gates/delegate.ts",
+    "src/gates/promotion.ts", "src/gates/authorize.ts", "src/gates/classify.ts",
+    "src/delivery.ts", "src/io.ts", "src/ledger.ts", "src/feature-doc.ts",
+    "extensions/nodd-kernel.ts", "extensions/nodd-promote.ts",
+  ];
+  for (const file of files) {
+    const executable = sourceOf(file)
+      .split("\n")
+      .filter((line) => !/^\s*(\/\/|\*|\/\*)/.test(line))
+      .join("\n");
+    assert.ok(
+      !/git\s+push|gh\s+pr|git\s+merge|pulls?\/create/.test(executable),
+      `${file} issues a push, PR or merge, which row 12 promises NODD leaves to the user`,
+    );
+  }
+});
+
+test("row 46: evidence is keyed to the declared runner and the write, never to a checkbox", () => {
+  const evidence = sourceOf("src/gates/evidence.ts");
+  assert.ok(evidence.includes("isDeclaredRunner"), "the runner binding is the mechanism");
+  assert.ok(evidence.includes("lastWriteSeq"), "and the write ordering is the other half");
+  assert.match(
+    row(46).how,
+    /runner|declared|write/i,
+    "the row must name what the evidence is actually keyed to, not merely deny the checkbox",
+  );
+});