diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/ac-checklist.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/ac-checklist.json
new file mode 100644
index 000000000..be1d27433
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/ac-checklist.json
@@ -0,0 +1,495 @@
+{
+  "schema_version": 1,
+  "faff_version": "0.44.0",
+  "all_verified": true,
+  "criteria": [
+    {
+      "ac": "A PR that deletes a non-exempt block of skill prose, commits a spec, and has no row or move covering the block fails `faff rule-inventory check` with exit 1, naming the file and base line.",
+      "verified": "exit 1, uncovered names plugin/skills/faff-graft/SKILL.md:5",
+      "passed": true,
+      "ac_id": "faff-1428#done:1",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a deleted paragraph with a committed spec and no inventory section fails, naming the file and the missing section"
+        }
+      ]
+    },
+    {
+      "ac": "`faff rule-inventory check [--base REF] [--json] [--summary FILE]` exists, with exits 0 / 1 / 2 as section 3 defines.",
+      "verified": "exits 0/1/2 asserted; self-run on this branch exits 0 (skipped no-prose-deleted)",
+      "passed": true,
+      "ac_id": "faff-1428#done:2",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a deleted paragraph with a committed spec and no inventory section fails, naming the file and the missing section"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a --base that is not a plain ref exits 2 and prints nothing on stdout"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a failing git command exits 2, never 0"
+        },
+        {
+          "kind": "command",
+          "locator": "node plugin/skills/faff/bin/faff rule-inventory check --base origin/main --json"
+        }
+      ]
+    },
+    {
+      "ac": "`--json` output has every `CheckResult` field.",
+      "verified": "every CheckResult key asserted present",
+      "passed": true,
+      "ac_id": "faff-1428#done:3",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a deleted paragraph with a committed spec and no inventory section fails, naming the file and the missing section"
+        }
+      ]
+    },
+    {
+      "ac": "The inventory format (section heading, `Prose rule` code-span anchor, `Covering test`, `Disposition`) is documented in `docs/reference/skill-authoring.md` under a `Rule inventory` heading, and every uncovered-block message names that anchor.",
+      "verified": "section at docs/reference/skill-authoring.md:37; uncovered line names #rule-inventory",
+      "passed": true,
+      "ac_id": "faff-1428#done:4",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a deleted paragraph with a committed spec and no inventory section fails, naming the file and the missing section"
+        },
+        {
+          "kind": "command",
+          "locator": "grep -n '^## Rule inventory' docs/reference/skill-authoring.md"
+        }
+      ]
+    },
+    {
+      "ac": "`plugin/skills/faffter-dark-nlspec/SKILL.md` gains one line telling the producer that a spec deleting skill prose carries a `## Rule inventory` in that format, and `prose-baseline.json` is raised by exactly that file's growth.",
+      "verified": "one Rule inventory line added; prose-baseline raised 18443 -> 18680 (+237, the file's exact growth); validate-adapters PASS",
+      "passed": true,
+      "ac_id": "faff-1428#done:5",
+      "verifications": [
+        {
+          "kind": "command",
+          "locator": "node plugin/skills/faff/bin/faff validate-adapters"
+        }
+      ]
+    },
+    {
+      "ac": "The command is TypeScript (`rule-inventory.ts` with its committed `.js` emit and `build-manifest.json`), in the factory region, with `REGION_SELFTEST_ARGV[\"rule-inventory\"] = null`, a `TEST_FILE_COVERAGE` entry for `test/rule-inventory.test.mjs`, and a `docs/guide/cli.md` row; `faff regions check`, `faff lint-cli-coverage` and `faff lint-cli-doc` pass.",
+      "verified": "rule-inventory.ts, committed .js emit and build-manifest; factory region, selftest null, TEST_FILE_COVERAGE, cli.md row; all three lints PASS",
+      "passed": true,
+      "ac_id": "faff-1428#done:6",
+      "verifications": [
+        {
+          "kind": "command",
+          "locator": "node plugin/skills/faff/bin/faff regions check"
+        },
+        {
+          "kind": "command",
+          "locator": "node plugin/skills/faff/bin/faff lint-cli-coverage"
+        },
+        {
+          "kind": "command",
+          "locator": "node plugin/skills/faff/bin/faff lint-cli-doc"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::the CLI registration: a factory command with no selftest"
+        }
+      ]
+    },
+    {
+      "ac": "A row's anchor covers a block only when it is at least 20 characters and a substring of the block's normalised deleted text, or when it equals that whole text; a short anchor never covers a longer block containing it.",
+      "verified": "short anchor covers only equal text; the floor mutation flips the case",
+      "passed": true,
+      "ac_id": "faff-1428#done:7",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a short anchor covers only a block whose whole text it equals, never a longer block containing it"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::row errors: no code span, short anchor, bad disposition, empty reason, bad or missing test path, absent test name"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::mutations: dropping the anchor-length floor, the kept-needs-test rule or the moved test each fail a case"
+        }
+      ]
+    },
+    {
+      "ac": "A deleted block whose text sits inside a single head block of any watched file counts as moved, with no row needed, including a reflow that leaves some lines unchanged.",
+      "verified": "cross-file move and partial reflow counted moved; the moved-test mutation flips",
+      "passed": true,
+      "ac_id": "faff-1428#done:8",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::text moved verbatim into another skill file, or reflowed in place, is moved and needs no row"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::mutations: dropping the anchor-length floor, the kept-needs-test rule or the moved test each fail a case"
+        }
+      ]
+    },
+    {
+      "ac": "The watched set is `prose-size`'s exported `isCovered`, imported, not a second list.",
+      "verified": "isCovered imported from ./prose-size; no second list",
+      "passed": true,
+      "ac_id": "faff-1428#done:9",
+      "verifications": [
+        {
+          "kind": "command",
+          "locator": "grep -n 'isCovered' plugin/skills/faff/bin/lib/rule-inventory.ts"
+        }
+      ]
+    },
+    {
+      "ac": "Path listing uses `-z` with `core.quotePath=false`; a watched-looking path the parser cannot decode exits 2.",
+      "verified": "diff -z --name-status under core.quotePath=false; an undecodable plugin/skills/ path throws (exit 2); per-file diff uses --text and --literal-pathspecs, a hunkless or Binary diff exits 2; a mode-only change or empty-base deletion deletes nothing, any other hunkless content change exits 2",
+      "passed": true,
+      "ac_id": "faff-1428#done:10",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a changed path under plugin/skills/ that is not valid UTF-8 is an error, never a skip"
+        },
+        {
+          "kind": "command",
+          "locator": "grep -n 'core.quotePath=false' plugin/skills/faff/bin/lib/rule-inventory.ts"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a binary or -diff attribute, or a NUL byte at HEAD, never hides a deletion (review: binary diff)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a watched file whose diff has no text hunk is an error, never a skip (review: binary diff)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a watched path with glob characters is matched literally (review: literal pathspecs)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a mode-only change or an empty watched file's deletion deletes nothing; a content change with no hunk still exits 2 (review round 2: no-hunk guard)"
+        }
+      ]
+    },
+    {
+      "ac": "A move into a non-watched file is not moved.",
+      "verified": "a move into docs/guide/prep.md is uncovered",
+      "passed": true,
+      "ac_id": "faff-1428#done:11",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::text moved into a non-watched file is not moved"
+        }
+      ]
+    },
+    {
+      "ac": "Table separator rows and letterless blocks are exempt; a table header row is exempt only when its whole table is deleted, and a heading only when its whole section is deleted.",
+      "verified": "separator and letterless exempt; header exempt only with its whole table; heading only with its whole section; exemption needs every line deleted by pure-deletion hunks, a lettered block, and no reappearance; an empty section is never exempt; a heading deleted alone over an edited paragraph is not exempt",
+      "passed": true,
+      "ac_id": "faff-1428#done:12",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a deleted thematic break alone is letterless and exempt"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::exemptions: separator rows are exempt; a header row is exempt only with its whole table"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a whole section deleted counts only its paragraph: the heading is exempt"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a reworded heading alone is not exempt: it needs a row"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a reworded heading over a partly edited section is not exempt (review: section exemption)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a renamed table header is not exempt when the table's rows reappear (review: table exemption)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a section moved to another skill under a new heading is not exempt: its old heading needs a row (review: section exemption)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a heading with an empty section is not exempt when deleted (review: empty section)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a heading deleted alone while its one-line paragraph is edited is not exempt (review round 2: pure members)"
+        }
+      ]
+    },
+    {
+      "ac": "Normalise deletes `*` and backticks and collapses whitespace, on anchors, deleted text and head blocks alike.",
+      "verified": "normalise strips * and backticks and collapses whitespace",
+      "passed": true,
+      "ac_id": "faff-1428#done:13",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::normalise, clean and mdEscape"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a qualified header (`Prose rule (\u00a72)`) is read; a kept row in a table with no Covering test column is a row error"
+        }
+      ]
+    },
+    {
+      "ac": "Only specs the diff adds are read; a modified older spec contributes no rows.",
+      "verified": "a modified older spec contributes no rows; ./records/specs/ normalised, absolute path exits 2",
+      "passed": true,
+      "ac_id": "faff-1428#done:14",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::only specs the diff adds are read: an older spec the branch modifies contributes no rows"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::spec_docs_path is normalised: ./records/specs/ finds the spec; an absolute path exits 2 (review: spec_docs_path)"
+        }
+      ]
+    },
+    {
+      "ac": "A diff that adds or modifies a path under `.faff/anchors/` but commits no spec fails with `footprint_without_spec: true`.",
+      "verified": "added and modified anchor paths both fail with footprint_without_spec",
+      "passed": true,
+      "ac_id": "faff-1428#done:15",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::an added or modified .faff/anchors/ path with deleted prose and no spec fails with footprint_without_spec"
+        }
+      ]
+    },
+    {
+      "ac": "`--summary` escapes markdown metacharacters and HTML in every spec-derived value.",
+      "verified": "mdEscape escapes metacharacters and HTML; no unescaped ![ or pipe",
+      "passed": true,
+      "ac_id": "faff-1428#done:16",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::normalise, clean and mdEscape"
+        }
+      ]
+    },
+    {
+      "ac": "A covering-test path outside `^test/\u2026\\.test\\.mjs$` or with a `..` segment is a row error and is never looked up.",
+      "verified": "src/a.js and test/../escape.test.mjs are row errors and never looked up",
+      "passed": true,
+      "ac_id": "faff-1428#done:17",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::row errors: no code span, short anchor, bad disposition, empty reason, bad or missing test path, absent test name"
+        }
+      ]
+    },
+    {
+      "ac": "Every printed line starts with `rule-inventory: `; spec-derived values are stripped of control characters and capped at 200 characters; a committed spec over 1 MiB exits 2.",
+      "verified": "every stdout line prefixed; ::error:: never starts a line; clean() strips controls and caps at 200; a spec over 1 MiB exits 2",
+      "passed": true,
+      "ac_id": "faff-1428#done:18",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a spec-derived workflow command never starts an output line"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a committed spec over 1 MiB exits 2"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::normalise, clean and mdEscape"
+        }
+      ]
+    },
+    {
+      "ac": "`--summary FILE` appends the row-covered table, `dropped` and `changed` first, and the CI step passes `$GITHUB_STEP_SUMMARY`.",
+      "verified": "summary appends, dropped first; the CI step passes $GITHUB_STEP_SUMMARY",
+      "passed": true,
+      "ac_id": "faff-1428#done:19",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::--summary appends the row-covered table with dropped rows first"
+        },
+        {
+          "kind": "command",
+          "locator": "grep -n 'GITHUB_STEP_SUMMARY' .github/workflows/validate.yml"
+        }
+      ]
+    },
+    {
+      "ac": "A row whose anchor matches no deleted block produces the warning `anchor matches no deleted prose` and does not fail the check.",
+      "verified": "warning emitted, exit 0",
+      "passed": true,
+      "ac_id": "faff-1428#done:20",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a row whose anchor matches no deleted prose warns and does not fail"
+        }
+      ]
+    },
+    {
+      "ac": "`kept` rows with no test, `changed`/`dropped` rows with no reason, and rows naming a missing test file or a test name absent from the file are row errors.",
+      "verified": "kept with no test, empty reason, missing file and absent name are all row errors; a directory is not a covering test (cat-file -t blob); covering-test lookup is ls-tree through the failure guard and must be a blob",
+      "passed": true,
+      "ac_id": "faff-1428#done:21",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a kept row with an empty Covering test cell is a row error"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::row errors: no code span, short anchor, bad disposition, empty reason, bad or missing test path, absent test name"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a covering test that is a directory at HEAD does not exist (review: cat-file -t)"
+        }
+      ]
+    },
+    {
+      "ac": "A PR that commits no spec is `skipped` with `no-spec-committed`; one that deletes no non-exempt prose is `skipped` with `no-prose-deleted`.",
+      "verified": "no-spec-committed and no-prose-deleted skips",
+      "passed": true,
+      "ac_id": "faff-1428#done:22",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::deleted prose with no spec committed is skipped with no-spec-committed and the fixed notice"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a deleted thematic break alone is letterless and exempt"
+        }
+      ]
+    },
+    {
+      "ac": "Without `--base`, the base is the merge-base with `origin/HEAD`, or the result is `skipped` with `no-base`.",
+      "verified": "no origin/HEAD gives no-base; with origin/HEAD the merge-base; a failing origin/HEAD lookup exits 2, never a no-base skip; merge-base takes refs/remotes/origin/HEAD",
+      "passed": true,
+      "ac_id": "faff-1428#done:23",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::without --base: merge-base with origin/HEAD, else skipped no-base"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::without --base, a failing origin/HEAD lookup is an error, not a no-base skip (holdout scenarios:21)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::without --base, the merge-base uses the full refs/remotes/origin/HEAD, never a local branch named origin/HEAD (review round 3)"
+        }
+      ]
+    },
+    {
+      "ac": "A failing git command, an unreadable committed spec, or a bad `--base` exits 2, never 0.",
+      "verified": "git failures (diff, cat-file, ls-tree), a bad ref and an unreadable config all exit 2; hunkless diff and absolute spec_docs_path exit 2; a lost main-checkout config fallback exits 2; a lost overlay fallback exits 2; from a passing run every injected git failure exits 2 with empty stdout, and the shared main-checkout probe prints the dispatch line naming the root and git's message (FAFF-1463)",
+      "passed": true,
+      "ac_id": "faff-1428#done:24",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a failing git command exits 2, never 0"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::an unreadable config exits 2, never a pass"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a --base that is not a plain ref exits 2 and prints nothing on stdout"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a watched file whose diff has no text hunk is an error, never a skip (review: binary diff)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::spec_docs_path is normalised: ./records/specs/ finds the spec; an absolute path exits 2 (review: spec_docs_path)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a failed main-checkout lookup in the shared config resolution exits 2, never a no-spec skip (holdout scenarios:21)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::a lost overlay fallback in a linked worktree exits 2 (FAFF-1463 shared lookup)"
+        },
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::from a passing run, failing any single git call exits 2, with and without --base (holdout scenarios:21)"
+        }
+      ]
+    },
+    {
+      "ac": "`validate.yml` runs the check on `pull_request` with `--base origin/$BASE_REF` and on `push` with `BEFORE`, with event values reaching the script only through `env`, an unfetchable `BEFORE` failing the step, and the literal no-base line present for `faff gates discover`.",
+      "verified": "pull_request --base origin/$BASE_REF, push --base $BEFORE, env-only values, unfetchable BEFORE exits 1, literal no-base line discovered as a STATIC_ANALYSIS rung",
+      "passed": true,
+      "ac_id": "faff-1428#done:25",
+      "verifications": [
+        {
+          "kind": "command",
+          "locator": "node plugin/skills/faff/bin/faff gates discover"
+        },
+        {
+          "kind": "command",
+          "locator": "grep -n 'rule-inventory check' .github/workflows/validate.yml"
+        }
+      ]
+    },
+    {
+      "ac": "`test/rule-inventory.test.mjs` covers each scenario in section 5, each row-error kind and each exemption rule (separator, letterless, header row with and without its whole table, heading with and without its whole section), using fixture repos with a local bare origin, and passes under `node --test`.",
+      "verified": "45 cases pass over fixture repos with a local bare origin: builder-view scenarios, every row-error kind and every exemption rule",
+      "passed": true,
+      "ac_id": "faff-1428#done:26",
+      "verifications": [
+        {
+          "kind": "command",
+          "locator": "node --import ./test/hermetic-env.mjs --test test/rule-inventory.test.mjs"
+        }
+      ]
+    },
+    {
+      "ac": "A mutation test shows each check bites: removing the anchor-length floor, the kept-needs-test rule, or the moved test each makes at least one case in the file fail.",
+      "verified": "three mutants (floor, kept-needs-test, moved) each fail a case",
+      "passed": true,
+      "ac_id": "faff-1428#done:27",
+      "verifications": [
+        {
+          "kind": "test",
+          "locator": "test/rule-inventory.test.mjs::mutations: dropping the anchor-length floor, the kept-needs-test rule or the moved test each fail a case"
+        }
+      ]
+    }
+  ]
+}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/build-progress.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/build-progress.json
new file mode 100644
index 000000000..721f40ab3
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/build-progress.json
@@ -0,0 +1,12 @@
+{
+  "schema_version": 1,
+  "faff_version": "0.44.0",
+  "issue": "FAFF-1428",
+  "build": {
+    "status": "complete",
+    "diff_hash": "7c89f968d59c4d33d4e9349004d5bc816617278d282fc160dda4a89262d95792",
+    "branch": "FAFF-1428-rule-inventory-check",
+    "pushed_at": "2026-11-05T04:30:48.962Z"
+  },
+  "updated_at": "2026-11-05T04:30:48.962Z"
+}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/chain-head.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/chain-head.json
new file mode 100644
index 000000000..154429863
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/chain-head.json
@@ -0,0 +1,8 @@
+{
+  "run_id": "run-20261104-043908-graft-FAFF-1428",
+  "issue": "FAFF-1428",
+  "head_seq": 6,
+  "head_sha256": "a1921f1cd041c65ea65be8b579e98086c42b5b2de53580e4eb5e1d9c183e46e3",
+  "line_count": 7,
+  "schema_floor": 2
+}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/commissaire/producer/pk.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/commissaire/producer/pk.json
new file mode 100644
index 000000000..c4eca2f2e
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/commissaire/producer/pk.json
@@ -0,0 +1,4 @@
+{
+  "pk": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAeneVFe/XteOJKXLj4elrU+SKRykLHIIrOzYr05EAdL0=\n-----END PUBLIC KEY-----\n",
+  "pk_fingerprint": "63fb9792d84045accb7add6724d4dbb0c73941627e7e5246d46bf2e101bd9ac9"
+}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/declared-effects.jsonl b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/declared-effects.jsonl
new file mode 100644
index 000000000..a1c076141
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/declared-effects.jsonl
@@ -0,0 +1,25 @@
+{"schema":3,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":0,"ts":"2026-11-04T04:39:08.514Z","author":"commissaire","producer_id":"run-20261104-043908-graft-FAFF-1428","contract_revision":"faff-runner-v1","kind_of_entry":"admission","unit_id":"-","step":"admit","prev":"7edf13ff84671efe8bddedc5d97da3fcece561b33b8dec1a73b612e5c60e1de0","payload":{"producer_id":"run-20261104-043908-graft-FAFF-1428","contract_revision":"faff-runner-v1","admitted_scope":["merge","branch-delete","pr-create","push","label-write","file-write","tracker-write"],"pk_fingerprint":"63fb9792d84045accb7add6724d4dbb0c73941627e7e5246d46bf2e101bd9ac9","admitted_at":"2026-11-04T04:39:08.499Z"},"commissaire_sig":"snkoxWClnnpADFEhH6lll3avfsEniLiiCqiBYxP3v1mIiicnhI0ZDODe+Y/tQYsyIQZ2jmqBu4A8XMHVP7SPDw=="}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":1,"ts":"2026-11-04T04:39:38.622Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"tracker-write","effect":{"kind":"tracker-write","target":"FAFF-1428:Todo->In Progress","reversible":true},"prev":"10e4f3bd9d000ddab7e7789b2fa99204db2038530d1fb11cc0973fc24162aab8"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":2,"ts":"2026-11-04T04:39:38.679Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"label-write","effect":{"kind":"label-write","target":"FAFF-1428:faff-claimed","reversible":true},"prev":"76633127c6c12293a5f7c06312dbdf63022eccddd3a83357cdc4da37d76ca54d"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":3,"ts":"2026-11-04T04:39:48.891Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"tracker-write","effect":{"kind":"tracker-write","target":"FAFF-1428:Todo->In Progress","reversible":true},"prev":"01262a3d2b51abc738b02008ed34501d4fcbb3ea96be1f95b2b752c833c5c04c"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":4,"ts":"2026-11-04T04:39:48.947Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"label-write","effect":{"kind":"label-write","target":"FAFF-1428:faff-claimed","reversible":true},"prev":"cbf44629fc760d3b68e83a0c3f0d1ba1a173d58bb687031689eb6601894280c0"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":5,"ts":"2026-11-04T05:11:45.510Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"88b4337317be5be2ca524a27c8d29af47a06a33df87dfb276efd8fd8fe170227"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":6,"ts":"2026-11-04T05:11:48.052Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"a8946ef5ff3a833138065c11a0bd1fa7ebbc1b573a541e110543a23bbe45e533"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":7,"ts":"2026-11-04T05:31:40.938Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"49f7920dd05634e4f43b4bbe50bf54995ed1f8e08def489d65b8424392a90701"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":8,"ts":"2026-11-04T05:31:43.013Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"0de3f33dd2a8491d7f40e57b009bafe13ac07dab30038d47689c29024c6a934f"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":9,"ts":"2026-11-04T05:45:35.790Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"63619f5de2d594703d4f570bb986125d3f2af07dcbae2690ff64329ca8a8f65f"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":10,"ts":"2026-11-04T05:45:37.574Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"e766ea31affc4af5fd00e9e5ef7cdfed3e27d8382fd6f324f2ac8b97391fda1d"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":11,"ts":"2026-11-04T05:57:40.763Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"1167dc8b014fdbce0b873d6022956d2ae6d8e30e2ef692f7df97b05b2b528824"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":12,"ts":"2026-11-04T05:57:42.961Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"af8935dab2e6841d89a919f7f5b9f38e66f21686f8a51352285466b62fc78166"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":13,"ts":"2026-11-04T21:53:07.058Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"3193be197fdb930e2e2992fd25b42b3684b1a3911b815e66acef815bede2dcbf"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":14,"ts":"2026-11-04T21:53:09.884Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"ebbd4471a49d7153d86f2566712739266206bb3040c0693b3c95bd7fddef45d3"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":15,"ts":"2026-11-05T03:58:17.347Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"54f3a089ead528b1c48d364d4cded51f4fc862d16bc9e29bd9ff922fbd168ede"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":16,"ts":"2026-11-05T03:58:20.751Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"08fb954999f53f6c6db31dfcf9ee6fb6fc759adf90210c33c3d509c819385722"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":17,"ts":"2026-11-05T04:10:02.103Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"490d71f061af7beab14097a62ddd8c845e6a8922174cc56fcd6596e4980abff3"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":18,"ts":"2026-11-05T04:10:04.562Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"790e1878205e4fabccb08c1138bf6e1b1b74a74bce898ab981c48872bb640447"}
+{"schema":3,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":19,"ts":"2026-11-05T04:10:07.479Z","author":"producer","producer_id":"run-20261104-043908-graft-FAFF-1428","contract_revision":"faff-runner-v1","kind_of_entry":"declare","unit_id":"FAFF-1428","step":"pr-create","prev":"2b293795e1414e39e7dea52be57f0e025cdf10b57e88ea4be9aafc0c4012b51d","effect":{"kind":"pr-create","target":"main","reversible":true},"producer_hmac":"7d4596d8b09eefa0cec2fed37b9bbfbf05fafa738d0358d183f73149a093fa3b"}
+{"schema":3,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":20,"ts":"2026-11-05T04:10:07.547Z","author":"producer","producer_id":"run-20261104-043908-graft-FAFF-1428","contract_revision":"faff-runner-v1","kind_of_entry":"effect-decision-request","unit_id":"FAFF-1428","step":"pr-create","prev":"1bc8c048ca7d8c3792622ba6e268a9c882a01da17240c5b96224c0486f9f1b3e","payload":{"effect":{"kind":"pr-create","target":"main"},"declared_ref":null,"level":"L2","attended":true,"holdout":"meets-spec"},"producer_hmac":"2a014827e8d2512e315ac793d7b9dd48610de7d993a2a0c43eea2a548e342216"}
+{"schema":3,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":21,"ts":"2026-11-05T04:10:07.550Z","author":"commissaire","producer_id":"run-20261104-043908-graft-FAFF-1428","contract_revision":"faff-runner-v1","kind_of_entry":"effect-decision-verdict","unit_id":"FAFF-1428","step":"pr-create","prev":"156f6fdb7ec26522babb7f8c22847ff20d4017980f3b299e5e15d3d9308f1a7d","payload":{"request_seq":20,"verdict":"grant","reason":"all-legs-pass","effect":{"kind":"pr-create","target":"main"},"level":"L2","attended":true,"holdout":"meets-spec","level_policy":{"pass":true,"reason":"attended"},"pure_verdict":"grant","pure_reason":"all-legs-pass"},"commissaire_sig":"TbzFwieidoBAixpQ6TY8M1rUZbN7HZn2ti5xoMu8JKVkTsJ2jFgkeek0xGXqB5UkfNCVZjbWOv83DiW3gH31Dw=="}
+{"schema":3,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":22,"ts":"2026-11-05T04:10:11.935Z","author":"producer","producer_id":"run-20261104-043908-graft-FAFF-1428","contract_revision":"faff-runner-v1","kind_of_entry":"observe","unit_id":"FAFF-1428","step":"pr-create","prev":"bf801c3191586e243b8cc268174ab06e474947811f8bfc2e4d89867d7d3cc2ce","effect":{"kind":"pr-create","target":"main","reversible":true},"producer_hmac":"8d081095b86a8af2ff98308e58bfbc583899077cefa04123de464a13248a48ed"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":23,"ts":"2026-11-05T04:30:45.525Z","kind_of_entry":"declare","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"8fdce545b610e02d911dc14a48e03e11d2c0aed3e7a4e6bf596c20f8130fff5f"}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":24,"ts":"2026-11-05T04:30:48.112Z","kind_of_entry":"observe","issue":"FAFF-1428","step":"push","effect":{"kind":"push","target":"FAFF-1428-rule-inventory-check","reversible":true},"prev":"40a93e05131ee5c12487334e9295780961981c42592c8c84602789b00edaf97b"}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/effects-chain-head.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/effects-chain-head.json
new file mode 100644
index 000000000..e44b02aed
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/effects-chain-head.json
@@ -0,0 +1,8 @@
+{
+  "run_id": "run-20261104-043908-graft-FAFF-1428",
+  "issue": "FAFF-1428",
+  "head_seq": 24,
+  "head_sha256": "98b477a0313a9e19d48dac3c22bd774b4dbad147f70e75765ae204a5a0148e8e",
+  "line_count": 25,
+  "schema_floor": 2
+}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/events.jsonl b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/events.jsonl
new file mode 100644
index 000000000..460f96cb8
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/events.jsonl
@@ -0,0 +1,7 @@
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":0,"ts":"2026-11-04T04:39:08.374Z","prev":"7edf13ff84671efe8bddedc5d97da3fcece561b33b8dec1a73b612e5c60e1de0","phase":"run","type":"ledger-write","data":{"ledger_sha256":"fde7669c508968c948c0805e2421b4d8aac5d80981e24c5169c06334930999bf"}}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":1,"ts":"2026-11-04T04:39:08.376Z","prev":"0e5f26d4b85429ab869fb22b8202507d057fdbe242f1ad3d675451a5de05bfdf","phase":"run","type":"run-start","data":{"faff_version":"0.44.0"}}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":2,"ts":"2026-11-04T04:39:08.381Z","prev":"ee6de914e69fe66959673cfb5b6683178a4d5f3ae93bc2ce4955f1cf94b86d95","phase":"run","type":"runner-identity","data":{"github_login":null,"github_login_source":"unresolved","credential_source":"ambient","credential_unresolved":false,"verified":false}}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":3,"ts":"2026-11-04T05:16:48.629Z","prev":"f08cb502351d5ac3a8d09b5efc211430dd11b3b2641c6dd11293de6c0826e619","phase":"run","type":"ledger-write","data":{"ledger_sha256":"22852bcb808fd8ce8af99afbe6b2baefb9aaf40a5b5720ff48e47dd2bb45bea6"}}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":4,"ts":"2026-11-04T22:04:34.388Z","prev":"1b1de5e7292f72fe594f9127b5406ffe261b1e5fa9713bb3308517d0d0609e84","phase":"run","type":"ledger-write","data":{"ledger_sha256":"22852bcb808fd8ce8af99afbe6b2baefb9aaf40a5b5720ff48e47dd2bb45bea6"}}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":5,"ts":"2026-11-05T04:06:10.529Z","prev":"958ce6ec24f6e44274393cc19a52c73499bff0887f50078e9ecf97747a1f35e2","phase":"run","type":"ledger-write","data":{"ledger_sha256":"22852bcb808fd8ce8af99afbe6b2baefb9aaf40a5b5720ff48e47dd2bb45bea6"}}
+{"schema":2,"run_id":"run-20261104-043908-graft-FAFF-1428","seq":6,"ts":"2026-11-05T04:39:37.218Z","prev":"7868e81c68853ffbb5681f10a6083b0c70d88986afb4e72075dac68a2d716c94","phase":"run","type":"ledger-write","data":{"ledger_sha256":"22852bcb808fd8ce8af99afbe6b2baefb9aaf40a5b5720ff48e47dd2bb45bea6"}}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/holdout.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/holdout.json
new file mode 100644
index 000000000..df9b7989c
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/holdout.json
@@ -0,0 +1,524 @@
+{
+  "schema_version": 1,
+  "faff_version": "0.44.0",
+  "issue": "FAFF-1428",
+  "aggregate": "meets-spec",
+  "code_blind": true,
+  "spawner_attested": false,
+  "attestation": null,
+  "violations": [],
+  "criteria": [
+    {
+      "id": "scenarios:1",
+      "text": "Given a branch that deletes a paragraph from plugin/skills/faff-graft/SKILL.md\nAnd the branch commits records/specs/2026-11-04-FAFF-9-x-design.md with no \"## Rule inventory\" section\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 1\nAnd the JSON result is \"fail\" with one uncovered entry naming plugin/skills/faff-graft/SKILL.md\nAnd row_errors names the spec with \"no ## Rule inventory section\"",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the paragraph at base line 696 of plugin/skills/faff-graft/SKILL.md ('If a wait is long enough...'); adds records/specs/2026-11-04-FAFF-9-x-design.md with no Rule inventory heading; ran --base origin/main --json",
+      "expected": "exit 1; result fail; one uncovered entry naming plugin/skills/faff-graft/SKILL.md; row_errors names the spec with 'no ## Rule inventory section'",
+      "observed": "exit 1; result \"fail\"; uncovered=[{file:plugin/skills/faff-graft/SKILL.md, base_line:696, excerpt:'If a wait is long enough...'}] (exactly one); row_errors=[{spec:records/specs/2026-11-04-FAFF-9-x-design.md, line:1, reason:'no ## Rule inventory section'}]",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s1 via /tmp/e6/s1-5.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:2",
+      "text": "Given a branch that deletes two bullets from plugin/skills/faff-prep/SKILL.md\nAnd commits a spec whose Rule inventory has one row per bullet, each quoting 30 characters of its bullet in a code span\nAnd each row is \"kept\" naming an existing test/x.test.mjs\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 0\nAnd the JSON reports covered_by_row 2 and uncovered []",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes two bullets of plugin/skills/faff-prep/SKILL.md (base lines 343, 345); spec rows quote exactly 30 characters of each bullet in a code span, both 'kept' naming test/x.test.mjs which the branch adds; ran --base origin/main --json (also a 31/32-char variant in /tmp/e6/s2)",
+      "expected": "exit 0; covered_by_row 2; uncovered []",
+      "observed": "exit 0; result pass; covered_by_row 2; uncovered []; row_errors []; row_covered lists base lines 343 and 345 against spec lines 9 and 10 (same for the 31/32-char variant)",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s2b and /tmp/e6/s2 via /tmp/e6/s6-12.sh and /tmp/e6/s1-5.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:3",
+      "text": "Given a branch that rewraps one paragraph of plugin/skills/faff/references/kernel.md across different line breaks without changing a word\nAnd commits a spec with an empty Rule inventory table\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 0\nAnd covered_moved is 1",
+      "holdout": true,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch rewraps the single-line paragraph at line 7 of plugin/skills/faff/references/kernel.md into four lines at ~60 columns, no word changed; spec has an empty Rule inventory table (header+separator only); ran --base origin/main --json",
+      "expected": "exit 0; covered_moved 1",
+      "observed": "exit 0; result pass; blocks_deleted 1; covered_moved 1; covered_by_row 0; uncovered []",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s3 via /tmp/e6/s1-5.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:4",
+      "text": "Given a branch that deletes a bullet from plugin/skills/faff-beep-boop/SKILL.md\nAnd commits a spec whose only row quotes that bullet, is \"kept\", and names test/missing.test.mjs, which does not exist\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 1\nAnd row_errors names test/missing.test.mjs",
+      "holdout": true,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the bullet at base line 21 of plugin/skills/faff-beep-boop/SKILL.md; spec's only row quotes it, 'kept', names test/missing.test.mjs (absent at HEAD, confirmed by ls); ran --base origin/main --json",
+      "expected": "exit 1; row_errors names test/missing.test.mjs",
+      "observed": "exit 1; result fail; row_errors=[{line:9, reason:'covering test test/missing.test.mjs does not exist'}]; the bullet listed as uncovered",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s4 via /tmp/e6/s1-5.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:5",
+      "text": "Given a branch that deletes a paragraph from plugin/skills/faff-graft/SKILL.md and commits no file under records/specs/\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 0\nAnd skipped_reason is \"no-spec-committed\"",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the graft paragraph (base line 696) and changes only that file (name-status: M plugin/skills/faff-graft/SKILL.md); ran --base origin/main --json",
+      "expected": "exit 0; skipped_reason no-spec-committed",
+      "observed": "exit 0; result skipped; skipped_reason \"no-spec-committed\"; specs []",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s5 via /tmp/e6/s1-5.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:6",
+      "text": "Given a branch that deletes a bullet and commits a spec whose row for it reads \"dropped:\" with nothing after the colon\nWhen faff rule-inventory check --base origin/main runs\nThen it exits 1\nAnd the output has a line starting \"rule-inventory: row-error\" that names the spec's path and the row's line number",
+      "holdout": true,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the beep-boop bullet (base line 21); spec row at line 9 reads '| `spec, review, ship — passed through to the sub-skills` | dropped: | |'; ran --base origin/main (no --json)",
+      "expected": "exit 1; a stdout line starting 'rule-inventory: row-error' naming the spec path and row line number",
+      "observed": "exit 1; stdout line 'rule-inventory: row-error records/specs/2026-11-04-FAFF-9-x-design.md:9: dropped row gives no reason' (line 9 is the row's line, confirmed by grep -n); also an uncovered line and the 'rule-inventory: fail (...)' summary",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s6 via /tmp/e6/s6-12.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:7",
+      "text": "Given a branch that deletes a paragraph from plugin/skills/faff-graft/SKILL.md\nAnd adds .faff/anchors/FAFF-9/anchor.json but commits no file under records/specs/\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 1\nAnd footprint_without_spec is true",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the graft paragraph and adds .faff/anchors/FAFF-9/anchor.json, no file under records/specs/ (name-status A anchor, M SKILL.md); ran --base origin/main --json",
+      "expected": "exit 1; footprint_without_spec true",
+      "observed": "exit 1; result fail; footprint_without_spec true; specs []",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s7 via /tmp/e6/s6-12.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:8",
+      "text": "Given a branch that moves a bullet from plugin/skills/faff-prep/SKILL.md into docs/guide/prep.md unchanged\nAnd commits a spec with an empty Rule inventory table\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 1\nAnd the uncovered entry names plugin/skills/faff-prep/SKILL.md",
+      "holdout": true,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes '- No noisy commits, PRs, or CI runs for planning work' from plugin/skills/faff-prep/SKILL.md and adds the same line unchanged to a new docs/guide/prep.md; spec with empty Rule inventory table; ran --base origin/main --json",
+      "expected": "exit 1; the uncovered entry names plugin/skills/faff-prep/SKILL.md",
+      "observed": "exit 1; result fail; covered_moved 0; uncovered=[{file:plugin/skills/faff-prep/SKILL.md, base_line:343, excerpt:'- No noisy commits, PRs, or CI runs for planning work'}]",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s8 via /tmp/e6/s6-12.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:9",
+      "text": "Given a branch that deletes a bullet and commits a spec with a valid row for it plus a second \"dropped: obsolete\" row quoting text that appears in no deleted block\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 0\nAnd warnings contains \"anchor matches no deleted prose\"",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the beep-boop bullet; spec has a valid 'dropped: gone' row for it plus a 'dropped: obsolete' row quoting '`this sentence appears in no deleted block whatsoever`'; ran --base origin/main --json",
+      "expected": "exit 0; warnings contains 'anchor matches no deleted prose'",
+      "observed": "exit 0; result pass; covered_by_row 1; warnings=['records/specs/2026-11-04-FAFF-9-x-design.md:10: anchor matches no deleted prose']",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s9 via /tmp/e6/s6-12.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:10",
+      "text": "Given a branch that deletes a bullet and commits a spec whose row for it reads \"dropped: ::error::forged\"\nWhen faff rule-inventory check --base origin/main runs\nThen no line of its output starts with \"::error::\"",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the beep-boop bullet; spec row reads 'dropped: ::error::forged'; ran --base origin/main (no --json), stdout and stderr captured separately and combined",
+      "expected": "no line of output starts with '::error::'",
+      "observed": "exit 0; stdout is the single line 'rule-inventory: pass (1 deleted, 0 moved, 1 by row, 0 uncovered, 0 row error(s))'; stderr empty; grep '^::' on combined output = 0 lines; every line starts 'rule-inventory: '",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s10 via /tmp/e6/s6-12.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:11",
+      "text": "Given a branch that deletes two bullets and commits a spec with a \"kept\" row naming an existing test/x.test.mjs for one and a \"dropped: superseded by faff x\" row for the other\nWhen faff rule-inventory check --base origin/main --summary out.md runs\nThen it exits 0\nAnd the first table row in out.md is the dropped one",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes two faff-prep bullets (base 343, 345); spec row 9 'kept' naming test/x.test.mjs (added), row 10 'dropped: superseded by faff x'; ran --base origin/main --summary out.md",
+      "expected": "exit 0; first table row in out.md is the dropped one",
+      "observed": "exit 0; out.md table header '| Disposition | Reason | Deleted block | Inventory row |', separator, then first data row '| dropped | superseded by faff x | plugin/skills/faff-prep/SKILL.md:345 | ...:10 |', then the kept row",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s11/w/out.md via /tmp/e6/s6-12.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:12",
+      "text": "Given a branch that deletes a bullet and commits a spec whose \"dropped:\" reason is \"x | ![p](https://example.invalid/p.png)\"\nWhen faff rule-inventory check --base origin/main --summary out.md runs\nThen out.md's table has the same number of cells in every row\nAnd out.md contains no unescaped \"![\" sequence",
+      "holdout": true,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the beep-boop bullet; spec row reason written per the documented format with the cell pipe escaped: 'dropped: x \\| ![p](https://example.invalid/p.png)'; ran --base origin/main --summary out.md; counted unescaped pipes per table line and unescaped '![' with a backslash-aware scanner",
+      "expected": "every table row of out.md has the same number of cells; no unescaped '![' in out.md",
+      "observed": "exit 0; table lines have 4 cells each (header, separator, data); data row reason rendered 'x \\| \\!\\[p\\]\\(https://example.invalid/p.png\\)'; unescaped '![' count 0. (Variant with a raw unescaped '|' in the spec cell splits the cell, yields a row error and exit 1, and writes no table: vacuously consistent, not the judged form)",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s12/w/out.md and /tmp/e6/s12b via /tmp/e6/s12-20.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:13",
+      "text": "Given a branch that deletes a bullet and commits a spec whose row for it is \"kept\" with an empty Covering test cell\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 1\nAnd row_errors contains \"kept row names no covering test\"",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the beep-boop bullet; spec row 'kept' with an empty Covering test cell (test/x.test.mjs exists); ran --base origin/main --json",
+      "expected": "exit 1; row_errors contains 'kept row names no covering test'",
+      "observed": "exit 1; result fail; row_errors=[{line:9, reason:'kept row names no covering test'}]",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s13 via /tmp/e6/s12-20.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:14",
+      "text": "Given a branch that changes the text of one heading in plugin/skills/faff-graft/SKILL.md and nothing else\nAnd commits a spec with an empty Rule inventory table\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 1\nAnd the uncovered entry is the heading's base line",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch changes only the heading at base line 688 of plugin/skills/faff-graft/SKILL.md ('### How to actually wait for CI' -> '### How to wait for CI'); diff -U0 shows one hunk @@ -688 +688 @@; spec with empty Rule inventory table; ran --base origin/main --json",
+      "expected": "exit 1; the uncovered entry is the heading's base line",
+      "observed": "exit 1; result fail; uncovered=[{file:plugin/skills/faff-graft/SKILL.md, base_line:688, excerpt:'### How to actually wait for CI'}]",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s14 via /tmp/e6/s12-20.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:15",
+      "text": "Given a branch that deletes a bullet and commits a spec larger than 1 MiB\nWhen faff rule-inventory check --base origin/main runs\nThen it exits 2",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the beep-boop bullet; committed spec is 1,170,200 bytes (> 1 MiB) with a valid row; ran --base origin/main",
+      "expected": "exit 2",
+      "observed": "exit 2; stdout empty; stderr 'rule-inventory: committed spec records/specs/2026-11-04-FAFF-9-x-design.md is larger than 1 MiB' followed by the usage lines",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s15 via /tmp/e6/s12-20.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:16",
+      "text": "Given a branch that deletes one data row of a three-row table in plugin/skills/faff-prep/SKILL.md and leaves its header and separator\nAnd commits a spec with an empty Rule inventory table\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 1\nAnd uncovered has exactly one entry, the deleted data row",
+      "holdout": true,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes data row '| `surface` | Surface the outage (interactive) |' (base line 255) of the three-data-row action table in plugin/skills/faff-prep/SKILL.md, keeping header and separator; spec with empty Rule inventory table; ran --base origin/main --json",
+      "expected": "exit 1; uncovered has exactly one entry, the deleted data row",
+      "observed": "exit 1; result fail; blocks_deleted 1; uncovered=[{file:plugin/skills/faff-prep/SKILL.md, base_line:255, excerpt:'| `surface` | Surface the outage (interactive) |'}] (exactly one)",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s16 via /tmp/e6/s12-20.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:17",
+      "text": "Given a branch that deletes a whole \"### Example\" section of plugin/skills/faff-graft/SKILL.md: its heading and one paragraph\nAnd commits a spec whose one row quotes 30 characters of the paragraph, \"dropped: obsolete example\"\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 0\nAnd blocks_deleted is 1",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Origin main seeded with a '### Example' section (heading + one paragraph) appended to plugin/skills/faff-graft/SKILL.md (base = seeded commit, origin/HEAD = origin/main); branch deletes the heading and paragraph; spec row quotes 35 chars of the paragraph ('walks a hypothetical ticket through'), 'dropped: obsolete example'; ran --base origin/main --json. Control: deleting only the heading fails with the heading uncovered",
+      "expected": "exit 0; blocks_deleted 1",
+      "observed": "exit 0; result pass; blocks_deleted 1; covered_by_row 1 (base_line 805, dropped, 'obsolete example'). Control run: exit 1 with uncovered '### Example' at base line 803",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s17, /tmp/e6/s17b via /tmp/e6/s17-20.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:18",
+      "text": "Given a branch that deletes one line of only \"---\" from plugin/skills/faff-graft/SKILL.md\nAnd commits a spec with no Rule inventory section\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 0\nAnd skipped_reason is \"no-prose-deleted\"",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Branch deletes the line-4 '---' (closing frontmatter fence) of plugin/skills/faff-graft/SKILL.md, diff -U0 shows only '----' at @@ -4; spec with no Rule inventory section; ran --base origin/main --json. Variant: base seeded with a body '---' rule between blank lines, branch deletes it",
+      "expected": "exit 0; skipped_reason no-prose-deleted",
+      "observed": "exit 0; result skipped; skipped_reason \"no-prose-deleted\"; blocks_deleted 0 (both the frontmatter and body-rule variants)",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s18, /tmp/e6/s18b via /tmp/e6/s17-20.sh, /tmp/e6/s18b.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:19",
+      "text": "Given a branch that deletes two bullets, \"- Fails loud.\" and a longer bullet containing \"Fails loud.\" among other words\nAnd commits a spec whose only row has the anchor \"- Fails loud.\" and \"dropped: merged\"\nWhen faff rule-inventory check --base origin/main --json runs\nThen it exits 1\nAnd the uncovered entry is the longer bullet",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Base seeded with bullets '- Fails loud.' (line 803) and '- The checker Fails loud. whenever git is unreachable or the config is unreadable.' (line 804) in faff-graft SKILL.md; branch deletes both; spec's only row has anchor `- Fails loud.` and 'dropped: merged'; ran --base origin/main --json",
+      "expected": "exit 1; the uncovered entry is the longer bullet",
+      "observed": "exit 1; result fail; covered_by_row 1 (base_line 803, the short bullet); uncovered=[{base_line:804, excerpt:'- The checker Fails loud. whenever git is unreachable ...'}] only",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s19 via /tmp/e6/s17-20.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:20",
+      "text": "Given faff rule-inventory check is run with --base \"-x\"\nWhen it runs\nThen it exits 2\nAnd nothing is printed on stdout",
+      "holdout": false,
+      "class": "scenario",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "Ran faff rule-inventory check --base \"-x\" (also --base=-x and with --json) in a fixture repo, stdout and stderr captured separately",
+      "expected": "exit 2; nothing on stdout",
+      "observed": "exit 2 in all three forms; stdout 0 bytes; stderr 'rule-inventory: --base -x is not a plain ref' plus usage",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s19/w via /tmp/e6/s17-20.sh",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    },
+    {
+      "id": "scenarios:21",
+      "text": "The check MUST NOT exit 0 when a git command it runs fails.",
+      "holdout": false,
+      "class": "assertion",
+      "verdict": "met",
+      "evidence_present": true,
+      "exercised": "git wrapper first on PATH (/tmp/e6/gw/git) logging every call and failing exactly one call per run (exit 128 with 'fatal: injected failure', and separately exit 1), swept over every call index of 14 fixture/mode combinations: s1 fail --json, s2b pass, s5 no-spec skip, s11 --summary, s3 moved (text mode), s7 footprint, s4 missing test, s12 summary escaping, s18 no-prose-deleted skip, s19, --base HEAD (base==HEAD skip), no --base with origin/HEAD present (--json and text), no --base with origin/HEAD deleted (confirmed rev-parse --verify --quiet origin/HEAD rc=1) — 2 to 14 git calls per run, 296 injected runs",
+      "expected": "never exit 0 when any git command the check runs fails",
+      "observed": "every one of the 296 injected-failure runs exited 2; zero runs exited 0 or 1. Includes failing rev-parse --show-toplevel, the base verify, merge-base, for-each-ref origin/HEAD probe (in the no-base absent case too), diff --name-status, diff -U0, ls-tree, cat-file --batch, cat-file -s and the covering-test ls-tree lookups",
+      "evidence_ref": "container faff-holdout-1428-f /tmp/e6/s21.sh, /tmp/e6/gw/git",
+      "reason": "every Then/And clause observed as specified",
+      "reason_code": null
+    }
+  ],
+  "delegated": [
+    {
+      "id": "done:1",
+      "text": "A PR that deletes a non-exempt block of skill prose, commits a spec, and has no row or move covering the block fails `faff rule-inventory check` with exit 1, naming the file and base line.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:1"
+    },
+    {
+      "id": "done:2",
+      "text": "`faff rule-inventory check [--base REF] [--json] [--summary FILE]` exists, with exits 0 / 1 / 2 as section 3 defines.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:2"
+    },
+    {
+      "id": "done:3",
+      "text": "`--json` output has every `CheckResult` field.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:3"
+    },
+    {
+      "id": "done:4",
+      "text": "The inventory format (section heading, `Prose rule` code-span anchor, `Covering test`, `Disposition`) is documented in `docs/reference/skill-authoring.md` under a `Rule inventory` heading, and every uncovered-block message names that anchor.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:4"
+    },
+    {
+      "id": "done:5",
+      "text": "`plugin/skills/faffter-dark-nlspec/SKILL.md` gains one line telling the producer that a spec deleting skill prose carries a `## Rule inventory` in that format, and `prose-baseline.json` is raised by exactly that file's growth.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:5"
+    },
+    {
+      "id": "done:6",
+      "text": "The command is TypeScript (`rule-inventory.ts` with its committed `.js` emit and `build-manifest.json`), in the factory region, with `REGION_SELFTEST_ARGV[\"rule-inventory\"] = null`, a `TEST_FILE_COVERAGE` entry for `test/rule-inventory.test.mjs`, and a `docs/guide/cli.md` row; `faff regions check`, `faff lint-cli-coverage` and `faff lint-cli-doc` pass.",
+      "holdout": false,
+      "verification_tier": "integration",
+      "verifier": "review-merge-floor",
+      "ac_id": "faff-1428#done:6"
+    },
+    {
+      "id": "done:7",
+      "text": "A row's anchor covers a block only when it is at least 20 characters and a substring of the block's normalised deleted text, or when it equals that whole text; a short anchor never covers a longer block containing it.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:7"
+    },
+    {
+      "id": "done:8",
+      "text": "A deleted block whose text sits inside a single head block of any watched file counts as moved, with no row needed, including a reflow that leaves some lines unchanged.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:8"
+    },
+    {
+      "id": "done:9",
+      "text": "The watched set is `prose-size`'s exported `isCovered`, imported, not a second list.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:9"
+    },
+    {
+      "id": "done:10",
+      "text": "Path listing uses `-z` with `core.quotePath=false`; a watched-looking path the parser cannot decode exits 2.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:10"
+    },
+    {
+      "id": "done:11",
+      "text": "A move into a non-watched file is not moved.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:11"
+    },
+    {
+      "id": "done:12",
+      "text": "Table separator rows and letterless blocks are exempt; a table header row is exempt only when its whole table is deleted, and a heading only when its whole section is deleted.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:12"
+    },
+    {
+      "id": "done:13",
+      "text": "Normalise deletes `*` and backticks and collapses whitespace, on anchors, deleted text and head blocks alike.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:13"
+    },
+    {
+      "id": "done:14",
+      "text": "Only specs the diff adds are read; a modified older spec contributes no rows.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:14"
+    },
+    {
+      "id": "done:15",
+      "text": "A diff that adds or modifies a path under `.faff/anchors/` but commits no spec fails with `footprint_without_spec: true`.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:15"
+    },
+    {
+      "id": "done:16",
+      "text": "`--summary` escapes markdown metacharacters and HTML in every spec-derived value.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:16"
+    },
+    {
+      "id": "done:17",
+      "text": "A covering-test path outside `^test/…\\.test\\.mjs$` or with a `..` segment is a row error and is never looked up.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:17"
+    },
+    {
+      "id": "done:18",
+      "text": "Every printed line starts with `rule-inventory: `; spec-derived values are stripped of control characters and capped at 200 characters; a committed spec over 1 MiB exits 2.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:18"
+    },
+    {
+      "id": "done:19",
+      "text": "`--summary FILE` appends the row-covered table, `dropped` and `changed` first, and the CI step passes `$GITHUB_STEP_SUMMARY`.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:19"
+    },
+    {
+      "id": "done:20",
+      "text": "A row whose anchor matches no deleted block produces the warning `anchor matches no deleted prose` and does not fail the check.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:20"
+    },
+    {
+      "id": "done:21",
+      "text": "`kept` rows with no test, `changed`/`dropped` rows with no reason, and rows naming a missing test file or a test name absent from the file are row errors.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:21"
+    },
+    {
+      "id": "done:22",
+      "text": "A PR that commits no spec is `skipped` with `no-spec-committed`; one that deletes no non-exempt prose is `skipped` with `no-prose-deleted`.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:22"
+    },
+    {
+      "id": "done:23",
+      "text": "Without `--base`, the base is the merge-base with `origin/HEAD`, or the result is `skipped` with `no-base`.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:23"
+    },
+    {
+      "id": "done:24",
+      "text": "A failing git command, an unreadable committed spec, or a bad `--base` exits 2, never 0.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:24"
+    },
+    {
+      "id": "done:25",
+      "text": "`validate.yml` runs the check on `pull_request` with `--base origin/$BASE_REF` and on `push` with `BEFORE`, with event values reaching the script only through `env`, an unfetchable `BEFORE` failing the step, and the literal no-base line present for `faff gates discover`.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:25"
+    },
+    {
+      "id": "done:26",
+      "text": "`test/rule-inventory.test.mjs` covers each scenario in section 5, each row-error kind and each exemption rule (separator, letterless, header row with and without its whole table, heading with and without its whole section), using fixture repos with a local bare origin, and passes under `node --test`.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:26"
+    },
+    {
+      "id": "done:27",
+      "text": "A mutation test shows each check bites: removing the anchor-length floor, the kept-needs-test rule, or the moved test each makes at least one case in the file fail.",
+      "holdout": false,
+      "verification_tier": "delegated",
+      "verifier": "ac-checklist",
+      "ac_id": "faff-1428#done:27"
+    }
+  ]
+}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/review-verdict.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/review-verdict.json
new file mode 100644
index 000000000..54ed0d38f
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/review-verdict.json
@@ -0,0 +1,559 @@
+{
+  "schema_version": 1,
+  "faff_version": "0.44.0",
+  "signal": "pass",
+  "rounds_total": 5,
+  "round_history": "recorded",
+  "findings": [
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::binary or -diff attribute hides deleted prose in deletedblocks diff",
+      "title": "binary or -diff attribute hides deleted prose in deletedBlocks diff",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:508",
+      "action": "Add --text to the per-file git diff and throw CheckError when a watched file's diff has no @@ hunk or reports Binary files.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "major",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "title": "binary or -diff attribute hides deleted prose in deletedBlocks diff",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:508",
+          "severity": "major",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::heading and table-header exemption keyed on touched, not wholly deleted, section",
+      "title": "heading and table-header exemption keyed on touched, not wholly deleted, section",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:189",
+      "action": "Exempt a heading or header row only when every line of every block in its section or table is deleted and the section has at least one lettered block.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "major",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "title": "heading and table-header exemption keyed on touched, not wholly deleted, section",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:189",
+          "severity": "major",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::empty-section heading non-exemption is unpinned by any test",
+      "title": "empty-section heading non-exemption is unpinned by any test",
+      "location": "test/rule-inventory.test.mjs",
+      "action": "Add a case deleting a heading directly followed by a same-level heading and assert it is uncovered.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "title": "empty-section heading non-exemption is unpinned by any test",
+          "location": "test/rule-inventory.test.mjs",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::covering-test existence check accepts a directory",
+      "title": "covering-test existence check accepts a directory",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:548",
+      "action": "Require git cat-file -t HEAD:<file> to return blob.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "title": "covering-test existence check accepts a directory",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:548",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::spec docs path not normalised before prefix match",
+      "title": "spec docs path not normalised before prefix match",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:495",
+      "action": "Normalise with path.posix.normalize, strip a leading ./, and exit 2 on an absolute path.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "title": "spec docs path not normalised before prefix match",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:495",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::per-file diff pathspec is not literal",
+      "title": "per-file diff pathspec is not literal",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:508",
+      "action": "Pass --literal-pathspecs to the per-file diff.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "title": "per-file diff pathspec is not literal",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:508",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::no-hunk error false-fires on mode-only change or empty watched file deletion",
+      "title": "no-hunk error false-fires on mode-only change or empty watched file deletion",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts",
+      "action": "Raise the no-hunk CheckError only when base and HEAD blob ids differ and the base blob is non-empty; treat equal-blob or empty-base changes as having no deleted lines.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 2,
+      "last_round": 2,
+      "occurrences": [
+        {
+          "round": 2,
+          "title": "no-hunk error false-fires on mode-only change or empty watched file deletion",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::member purity check in guardof is unpinned by any test",
+      "title": "member purity check in guardOf is unpinned by any test",
+      "location": "test/rule-inventory.test.mjs",
+      "action": "Add a case deleting a heading alone (blank line kept) while editing its one-line paragraph, with a row only for the paragraph, and assert the heading is uncovered.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 2,
+      "last_round": 2,
+      "occurrences": [
+        {
+          "round": 2,
+          "title": "member purity check in guardOf is unpinned by any test",
+          "location": "test/rule-inventory.test.mjs",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/shared-infra.js::shared-infra overlay fallback probe failure still exits 0 in a main checkout",
+      "title": "shared-infra overlay fallback probe failure still exits 0 in a main checkout",
+      "location": "plugin/skills/faff/bin/lib/shared-infra.js",
+      "action": "Make mainWorktreeRoot distinguish a git failure inside a repo from no main checkout and surface it through loadConfig, or record a human acceptance of the harmless exit 0 and narrow the claim.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 3,
+      "last_round": 3,
+      "occurrences": [
+        {
+          "round": 3,
+          "title": "shared-infra overlay fallback probe failure still exits 0 in a main checkout",
+          "location": "plugin/skills/faff/bin/lib/shared-infra.js",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::cat-file -t and blobid read git failure as absence",
+      "title": "cat-file -t and blobId read git failure as absence",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts",
+      "action": "Look up the test file and blob ids with git ls-tree -z HEAD -- <path> through must, treating empty output as absent and a failing call as CheckError.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 3,
+      "last_round": 3,
+      "occurrences": [
+        {
+          "round": 3,
+          "title": "cat-file -t and blobId read git failure as absence",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::overlay half of verifyconfiglocation is unpinned and the every-call test starts from a failing run",
+      "title": "overlay half of verifyConfigLocation is unpinned and the every-call test starts from a failing run",
+      "location": "test/rule-inventory.test.mjs",
+      "action": "Add a linked-worktree overlay-only divergence case expecting exit 2, and run the every-call enumeration from a passing scenario asserting exit 2 per injected failure.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "faffter-noon-review",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 3,
+      "last_round": 3,
+      "occurrences": [
+        {
+          "round": 3,
+          "title": "overlay half of verifyConfigLocation is unpinned and the every-call test starts from a failing run",
+          "location": "test/rule-inventory.test.mjs",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::overlay test title names the removed config guard",
+      "title": "overlay test title names the removed config guard",
+      "location": "test/rule-inventory.test.mjs:752",
+      "action": "Retitle to 'a lost overlay fallback in a linked worktree exits 2 (FAFF-1463 shared lookup)' and update the done:24 locator in ac-checklist.json in the same change.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "standard",
+      "model": "anthropic/claude-opus-5-5",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "title": "overlay test title names the removed config guard",
+          "location": "test/rule-inventory.test.mjs:752",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::every-call sweep asserts inline and stops at the first failing call",
+      "title": "every-call sweep asserts inline and stops at the first failing call",
+      "location": "test/rule-inventory.test.mjs:793",
+      "action": "Collect status/stdout/stderr mismatches across all n and assert once after the loop, as the pre-62220446 notTwo shape did.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "adversarial",
+      "model": "openai/z-ai/glm-5.3-flash",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "title": "every-call sweep asserts inline and stops at the first failing call",
+          "location": "test/rule-inventory.test.mjs:793",
+          "severity": "minor",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::verifyconfiglocation removal drops a wrong-file mismatch check",
+      "title": "verifyConfigLocation removal drops a wrong-file mismatch check",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:555",
+      "action": "No change: keep the guard removed; the refutation evidence stands.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "observation",
+      "source": "adversarial",
+      "model": "openai/z-ai/glm-5.3-flash",
+      "disposition": "refuted",
+      "refutation": "Guard recomputed the expectation with the same findConfigIn/findOverlayIn, the same rev-parse --git-common-dir from the same cwd/env, and the same .git-basename rule as findLocationWithMainFallback. Restored guard on FAFF-1463 with an instrumented fallback branch: branch reached in 11 layouts (deprecated name, overlay-only main, abs/relative/polluted GIT_DIR, separate-git-dir, non-ASCII path, symlinked worktree, config-is-dir), never refused; outputs identical with and without guard.",
+      "disposition_rationale": "On probe success the guard is equal to the shared lookup by construction; on probe failure FAFF-1463 throws first. Severity downgraded from critical.",
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "title": "verifyConfigLocation removal drops a wrong-file mismatch check",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:555",
+          "severity": "observation",
+          "disposition": "refuted"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::isprobefailure matches the git-probe-failed message token",
+      "title": "isProbeFailure matches the git-probe-failed message token",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:66",
+      "action": "No change: refuted; see refutation.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "observation",
+      "source": "adversarial",
+      "model": "openai/z-ai/glm-5.3-flash",
+      "disposition": "refuted",
+      "refutation": "The token is the designed contract: MainWorktreeProbeError sets message git-probe-failed and governedExitCode (shared-infra.js) branches on the same message; spec-review-round.js:39 uses the identical check. Tests 40 and 42 pin the end-to-end dispatch line, so a token drift fails them.",
+      "disposition_rationale": "Repo convention, pinned end to end. Severity downgraded from major.",
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "title": "isProbeFailure matches the git-probe-failed message token",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:66",
+          "severity": "observation",
+          "disposition": "refuted"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/rule-inventory.ts::cmdcheck rethrows the probe error to an unseen caller",
+      "title": "cmdCheck rethrows the probe error to an unseen caller",
+      "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:733",
+      "action": "No change: refuted; see refutation.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "observation",
+      "source": "adversarial",
+      "model": "openai/z-ai/glm-5.3-flash",
+      "disposition": "refuted",
+      "refutation": "cmdCheck is reached only through cmdRuleInventory from the bin/faff dispatch table, which wraps every handler in runGovernedDispatch (bin/faff:365); tests 40 and 42 exercise that path and assert exit 2 and the one line.",
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "title": "cmdCheck rethrows the probe error to an unseen caller",
+          "location": "plugin/skills/faff/bin/lib/rule-inventory.ts:733",
+          "severity": "observation",
+          "disposition": "refuted"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::probe-line assertion couples to git's stderr wording",
+      "title": "probe-line assertion couples to git's stderr wording",
+      "location": "test/rule-inventory.test.mjs:736",
+      "action": "No change: refuted; see refutation.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "observation",
+      "source": "adversarial",
+      "model": "openai/z-ai/glm-5.3-flash",
+      "disposition": "refuted",
+      "refutation": "'fatal: injected failure' is written by the test's own PATH git wrapper, not by git, so no git version can change it; the dispatch prefix pin is intentional (62220446).",
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "title": "probe-line assertion couples to git's stderr wording",
+          "location": "test/rule-inventory.test.mjs:736",
+          "severity": "observation",
+          "disposition": "refuted"
+        }
+      ]
+    },
+    {
+      "finding_id": "plugin/skills/faff/bin/lib/shared-infra.js::main-checkout probe failure is now fatal where its answer is irrelevant",
+      "title": "main-checkout probe failure is now fatal where its answer is irrelevant",
+      "location": "plugin/skills/faff/bin/lib/shared-infra.js:594",
+      "action": "No change: accepted as FAFF-1463 design; no change in this PR.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "observation",
+      "source": "adversarial",
+      "model": "openai/z-ai/glm-5.3-flash",
+      "disposition": "accepted-risk",
+      "refutation": null,
+      "disposition_rationale": "That is FAFF-1463's merged design and the spec's fail-closed rule (any git error exits 2); out of this delta's scope.",
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "title": "main-checkout probe failure is now fatal where its answer is irrelevant",
+          "location": "plugin/skills/faff/bin/lib/shared-infra.js:594",
+          "severity": "observation",
+          "disposition": "accepted-risk"
+        }
+      ]
+    },
+    {
+      "finding_id": ".faff/runs/run-20261104-043908-graft-FAFF-1428/FAFF-1428/holdout.json::holdout predates the rebased head",
+      "title": "holdout predates the rebased head",
+      "location": ".faff/runs/run-20261104-043908-graft-FAFF-1428/FAFF-1428/holdout.json",
+      "action": "Re-run the code-blind holdout on 7c0e20de before merge.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "observation",
+      "source": "standard",
+      "model": "anthropic/claude-opus-5-5",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "title": "holdout predates the rebased head",
+          "location": ".faff/runs/run-20261104-043908-graft-FAFF-1428/FAFF-1428/holdout.json",
+          "severity": "observation",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::redundant re-fetch double-sources origin/head in the no-base merge-base test",
+      "title": "Redundant re-fetch double-sources origin/HEAD in the no-base merge-base test",
+      "location": "test/rule-inventory.test.mjs:442",
+      "action": "Drop the fetch after remote set-head so set-head is the only source of origin/HEAD on every git version.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "observation",
+      "source": "standard",
+      "model": "claude-opus-5-5",
+      "disposition": "open",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 5,
+      "last_round": 5,
+      "occurrences": [
+        {
+          "round": 5,
+          "title": "Redundant re-fetch double-sources origin/HEAD in the no-base merge-base test",
+          "location": "test/rule-inventory.test.mjs:442",
+          "severity": "observation",
+          "disposition": "open"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::update-ref -d on an absent origin/head breaks fixtures on older git",
+      "title": "update-ref -d on an absent origin/HEAD breaks fixtures on older git",
+      "location": "test/rule-inventory.test.mjs:114",
+      "action": "None; deleting a missing ref exits 0.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "major",
+      "source": "adversarial",
+      "model": "openai/z-ai/glm-5.3-flash",
+      "disposition": "refuted",
+      "refutation": null,
+      "disposition_rationale": "git update-ref --no-deref -d on a missing ref exits 0 on git 2.39.5 and 2.30.6; the suite passes 45/45 on 2.39.5.",
+      "first_round": 5,
+      "last_round": 5,
+      "occurrences": [
+        {
+          "round": 5,
+          "title": "update-ref -d on an absent origin/HEAD breaks fixtures on older git",
+          "location": "test/rule-inventory.test.mjs:114",
+          "severity": "major",
+          "disposition": "refuted"
+        }
+      ]
+    },
+    {
+      "finding_id": "test/rule-inventory.test.mjs::collect-then-assert sweep loses strictness",
+      "title": "Collect-then-assert sweep loses strictness",
+      "location": "test/rule-inventory.test.mjs:800",
+      "action": "None; the pass/fail conditions are equivalent.",
+      "location_present": true,
+      "action_present": true,
+      "severity": "minor",
+      "source": "adversarial",
+      "model": "openai/z-ai/glm-5.3-flash",
+      "disposition": "refuted",
+      "refutation": null,
+      "disposition_rationale": "Status, stdout and probe stderr are each still checked per call, and non-probe stderr was never asserted. The inline version also aborted before the probes.length pin. Mutants show one failing run reports 4 and 2 mismatches.",
+      "first_round": 5,
+      "last_round": 5,
+      "occurrences": [
+        {
+          "round": 5,
+          "title": "Collect-then-assert sweep loses strictness",
+          "location": "test/rule-inventory.test.mjs:800",
+          "severity": "minor",
+          "disposition": "refuted"
+        }
+      ]
+    }
+  ]
+}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/run-ledger.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/run-ledger.json
new file mode 100644
index 000000000..03c567d67
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/run-ledger.json
@@ -0,0 +1,31 @@
+{
+  "schema_version": 1,
+  "run_id": "run-20261104-043908-graft-FAFF-1428",
+  "level": "L2",
+  "admitted": [
+    "FAFF-1428"
+  ],
+  "outcomes": {},
+  "budget": {
+    "envelope": {
+      "ceilings": {},
+      "at_ceiling": "stop"
+    }
+  },
+  "base_sha": "3553d023d83486d59951116d0c2747bea0c9aed8",
+  "base_sha_required": true,
+  "owner": {
+    "status": "running",
+    "session_id": "run-20261104-043908-graft-FAFF-1428",
+    "pid": 3652542,
+    "started_at": "2026-11-04T04:39:08.264Z",
+    "utc_offset_min": 0,
+    "last_heartbeat": "2026-11-04T04:39:08.264Z",
+    "faff_version": "0.44.0"
+  },
+  "capabilities": {
+    "FAFF-1428": {
+      "sut_env_stood": true
+    }
+  }
+}
diff --git a/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/spec-review-verdict.json b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/spec-review-verdict.json
new file mode 100644
index 000000000..8973762a4
--- /dev/null
+++ b/.faff/anchors/run-20261104-043908-graft-FAFF-1428/FAFF-1428/spec-review-verdict.json
@@ -0,0 +1,429 @@
+{
+  "schema_version": 1,
+  "faff_version": "0.44.0",
+  "verdict": "reject-approach",
+  "final_verdict": "reject-approach",
+  "rounds_total": 5,
+  "objections": [
+    {
+      "lens": "architectural",
+      "severity": "minor",
+      "claim": "The `Normalise` definition strips only whitespace (\"Nothing else is stripped; markdown emphasis and backticks inside the text are kept\"). The dominant prose form in the watched files is the house bold-lead mega-bullet (`- **Lean.** Say it once…`, per `docs/reference/skill-authoring.md`). A deleted bullet's normalised deleted text therefore contains literal `**Lean.**` and any inline-code backticks; an author who quotes the rule's words (\"Lean. Say it once…\") — the natural quote — is *not* a substring and the block is uncovered. The spec anticipates backtick-run escaping for anchors *containing* backticks but never says emphasis markers must be reproduced, and the failure message points at the format doc, which won't say it either. Every extraction PR deleting bold-lead bullets hits this systematically until authors discover it by trial.",
+      "evidence": "`Normalise` row in the vocabulary table; the anchor-matching rule in \"How a deleted block maps to a row\"; house style in `docs/reference/skill-authoring.md`.",
+      "predicted_consequence": "the first extraction PR under this check produces a burst of false uncovered-block failures whose fix (embedding `**` inside code spans) is undiscoverable from the failure message; the spec edit is one line — strip `*`/`_` emphasis and backtick delimiters in `Normalise`, or state the reproduction requirement in the format doc.",
+      "spec_anchor": "3-what-vocabulary-types-and-interfaces",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "severity": "minor",
+          "claim": "The `Normalise` definition strips only whitespace (\"Nothing else is stripped; markdown emphasis and backticks inside the text are kept\"). The dominant prose form in the watched files is the house bold-lead mega-bullet (`- **Lean.** Say it once…`, per `docs/reference/skill-authoring.md`). A deleted bullet's normalised deleted text therefore contains literal `**Lean.**` and any inline-code backticks; an author who quotes the rule's words (\"Lean. Say it once…\") — the natural quote — is *not* a substring and the block is uncovered. The spec anticipates backtick-run escaping for anchors *containing* backticks but never says emphasis markers must be reproduced, and the failure message points at the format doc, which won't say it either. Every extraction PR deleting bold-lead bullets hits this systematically until authors discover it by trial.",
+          "spec_anchor": "3-what-vocabulary-types-and-interfaces"
+        }
+      ]
+    },
+    {
+      "lens": "architectural",
+      "severity": "minor",
+      "claim": "`added_corpus := normalise(join of every added line of every watched file, with single spaces)` concatenates all added lines of all files into one stream. A deleted block's text can then match across the seam between two unrelated added lines (even in different files), counting as \"moved\" when nothing was moved. This is a fail-open hole in a check whose stated principle is \"Fail closed inside scope … It never turns into a pass.\" The fix costs nothing: build the corpus per watched file (or per added block) and test membership against each.",
+      "evidence": "PROCEDURE step 6 and step 9's substring test; the \"Fail closed inside scope\" design principle in section 1.",
+      "predicted_consequence": "a rare but real false pass on exactly the class of deletion the check exists to catch, contradicting the spec's own fail-closed commitment; reviewers cannot distinguish a genuine move from a seam artifact.",
+      "spec_anchor": "3-what-vocabulary-types-and-interfaces",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "severity": "minor",
+          "claim": "`added_corpus := normalise(join of every added line of every watched file, with single spaces)` concatenates all added lines of all files into one stream. A deleted block's text can then match across the seam between two unrelated added lines (even in different files), counting as \"moved\" when nothing was moved. This is a fail-open hole in a check whose stated principle is \"Fail closed inside scope … It never turns into a pass.\" The fix costs nothing: build the corpus per watched file (or per added block) and test membership against each.",
+          "spec_anchor": "3-what-vocabulary-types-and-interfaces"
+        }
+      ]
+    },
+    {
+      "lens": "infosec",
+      "severity": "major",
+      "claim": "The check grants \"pass\" on the strength of the `## Rule inventory` rows in the committed spec, but the committed spec is written by the same agent whose PR it gates. An agent (or any PR author) that deletes a rule can satisfy the check by writing its own row — `dropped: <anything>`, or a `kept` row naming a real test that does not test the rule — quoting ≥20 characters of the deleted text. The check verifies only that the quote is a substring of the deleted prose and that named files exist; it cannot distinguish a truthful row from a fabricated one. Worse, rows are pooled across all committed specs with no file binding: a row in an unrelated old spec under the spec docs path covers deletions in any watched file, and one anchor matching duplicated text covers many blocks at once. The design principle \"Coverage is mechanical; correctness stays with review\" is the stated control, but it does not answer the threat: the reviewer sees a plausible-looking table and the mechanical gate adds zero adversarial resistance — it enforces the format, not the coverage, against a non-cooperative actor. The spec must establish who can write the input that grants the pass; it establishes only that the actor is the PR author.",
+      "evidence": "§3 \"Coverage is mechanical; correctness stays with review\"; §3 \"One row may cover several blocks\"; §4 step 7 \"rows := for each spec … parse every inventory table\" (pooled, unbound to the deleted file); §4 step 9 (anchor-substring is the only coverage test).",
+      "predicted_consequence": "an agent PR can delete any rule from any watched skill file and pass `faff rule-inventory check` (exit 0) by authoring a `dropped:` row in any committed spec — the guardrail the ticket exists to add is trivially bypassable by the actor it targets, and the CI log shows a green check.",
+      "spec_anchor": "how-a-deleted-block-maps-to-a-row",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "severity": "major",
+          "claim": "The check grants \"pass\" on the strength of the `## Rule inventory` rows in the committed spec, but the committed spec is written by the same agent whose PR it gates. An agent (or any PR author) that deletes a rule can satisfy the check by writing its own row — `dropped: <anything>`, or a `kept` row naming a real test that does not test the rule — quoting ≥20 characters of the deleted text. The check verifies only that the quote is a substring of the deleted prose and that named files exist; it cannot distinguish a truthful row from a fabricated one. Worse, rows are pooled across all committed specs with no file binding: a row in an unrelated old spec under the spec docs path covers deletions in any watched file, and one anchor matching duplicated text covers many blocks at once. The design principle \"Coverage is mechanical; correctness stays with review\" is the stated control, but it does not answer the threat: the reviewer sees a plausible-looking table and the mechanical gate adds zero adversarial resistance — it enforces the format, not the coverage, against a non-cooperative actor. The spec must establish who can write the input that grants the pass; it establishes only that the actor is the PR author.",
+          "spec_anchor": "how-a-deleted-block-maps-to-a-row"
+        }
+      ]
+    },
+    {
+      "lens": "infosec",
+      "severity": "major",
+      "claim": "The check applies only when the PR commits a spec under the spec docs path, and a PR that does not returns `skipped` with exit 0 (§3 exit table: \"exit 0 pass or skipped\"). In branch protection, exit 0 is a green required check — a skip is indistinguishable from a pass. So an agent PR that deletes skill prose and commits no spec sails through the gate. The spec's answer is that graft's `faff spec commit` always commits the spec, and a violation \"is a graft defect to file, not a reason to change this scope\" — but nothing in this check or in CI enforces that invariant; the gate's coverage rests entirely on an unverified precondition controlled by the gated actor. The precedent cited (`governance.yml` `on-missing: pass`) is a governance floor with a documented residual and a named flip-to-fail path; this spec states no such end-state and no detection beyond a human reading CI logs for `skipped_reason: \"no-spec-committed\"` on a PR that carries an anchor footprint.",
+      "evidence": "§3 \"Chosen: scope by artifact footprint\"; §4 failure modes third bullet (\"it is a graft defect to file, not a reason to change this scope\"); §3 exit table (skipped = exit 0).",
+      "predicted_consequence": "a prose-deleting agent PR with no committed spec passes the required `validate` check with exit 0; the rule loss the ticket was created to catch (FAFF-1429/FAFF-1430-shaped) ships green.",
+      "spec_anchor": "pure-prose-edits",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "severity": "major",
+          "claim": "The check applies only when the PR commits a spec under the spec docs path, and a PR that does not returns `skipped` with exit 0 (§3 exit table: \"exit 0 pass or skipped\"). In branch protection, exit 0 is a green required check — a skip is indistinguishable from a pass. So an agent PR that deletes skill prose and commits no spec sails through the gate. The spec's answer is that graft's `faff spec commit` always commits the spec, and a violation \"is a graft defect to file, not a reason to change this scope\" — but nothing in this check or in CI enforces that invariant; the gate's coverage rests entirely on an unverified precondition controlled by the gated actor. The precedent cited (`governance.yml` `on-missing: pass`) is a governance floor with a documented residual and a named flip-to-fail path; this spec states no such end-state and no detection beyond a human reading CI logs for `skipped_reason: \"no-spec-committed\"` on a PR that carries an anchor footprint.",
+          "spec_anchor": "pure-prose-edits"
+        }
+      ]
+    },
+    {
+      "lens": "infosec",
+      "severity": "minor",
+      "claim": "The committed spec is agent-authored untrusted input, and the command prints spec-derived strings raw: row-error reasons include spec content (the anchor, the reason text, the test name), and `--json`/plain output carries them to the step log. A spec line containing GitHub Actions workflow-command syntax (`::error::`, `::warning::`) or ANSI escapes can forge annotations or conceal real findings in the `validate` job log. The spec sanitises nothing and imposes no character restrictions on the `reason` free text or the anchor.",
+      "evidence": "§3 \"Without `--json` it prints one line per uncovered block and per row error\"; §4 step 8 row errors interpolate spec content; no escaping rule anywhere in §4.",
+      "predicted_consequence": "a crafted `dropped: ::error::…` reason forges a CI annotation or visually suppresses the real row-error output in the validate job log.",
+      "spec_anchor": "command-surface",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "severity": "minor",
+          "claim": "The committed spec is agent-authored untrusted input, and the command prints spec-derived strings raw: row-error reasons include spec content (the anchor, the reason text, the test name), and `--json`/plain output carries them to the step log. A spec line containing GitHub Actions workflow-command syntax (`::error::`, `::warning::`) or ANSI escapes can forge annotations or conceal real findings in the `validate` job log. The spec sanitises nothing and imposes no character restrictions on the `reason` free text or the anchor.",
+          "spec_anchor": "command-surface"
+        }
+      ]
+    },
+    {
+      "lens": "infosec",
+      "severity": "minor",
+      "claim": "A row's covering-test entry must \"start `test/` and end `.test.mjs`\", but `test/../../<anything>.test.mjs` satisfies both. The check then runs `git cat-file -e HEAD:<file>` and, when a name is given, reads the file's text to assert containment. A crafted row can make the check probe existence of, and string-containment in, any tracked file at HEAD — a small oracle and an inconsistent-with-intent read surface, and the containment assertion against a non-test file is meaningless.",
+      "evidence": "§3 TestRef \"file: Path — repo-relative, must start `test/` and end `.test.mjs`\"; §4 step 8 (`git cat-file -e HEAD:<file>`, \"the file text must contain the name as written\").",
+      "predicted_consequence": "a row naming `test/../../records/…​.test.mjs` passes the shape check and turns the gate into an existence/containment oracle over arbitrary tracked paths.",
+      "spec_anchor": "the-inventory-format-documented-in-docs-references-skill-authoring-md",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "severity": "minor",
+          "claim": "A row's covering-test entry must \"start `test/` and end `.test.mjs`\", but `test/../../<anything>.test.mjs` satisfies both. The check then runs `git cat-file -e HEAD:<file>` and, when a name is given, reads the file's text to assert containment. A crafted row can make the check probe existence of, and string-containment in, any tracked file at HEAD — a small oracle and an inconsistent-with-intent read surface, and the containment assertion against a non-test file is meaningless.",
+          "spec_anchor": "the-inventory-format-documented-in-docs-references-skill-authoring-md"
+        }
+      ]
+    },
+    {
+      "lens": "QA",
+      "severity": "minor",
+      "claim": "\"Exempt block\" is defined as a *block* that states no rule, but two of its criteria are line-level (\"a blank line\", \"a line with no letters\") while others are block-level (\"a heading\", \"a table separator row\", \"the header row\"). For a deleted block containing both a letterless line and a lettered line, the spec does not say whether the block is exempt, partially exempt, or a deleted block whose deleted text includes the letterless line. A builder can implement either reading and both satisfy the text; a tester cannot decide which is correct.",
+      "evidence": "§3 Vocabulary, \"Exempt block\"; DONE item \"Headings, blank lines, table separator rows, table header rows and letterless lines are exempt\" (which repeats the same block/line conflation).",
+      "predicted_consequence": "two conforming builds disagree on whether a mixed block is uncovered, flipping exit 1 vs exit 0 on the same diff; the DONE item cannot be decided for that input.",
+      "spec_anchor": "3-what-vocabulary-types-and-interfaces",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 1,
+      "last_round": 1,
+      "occurrences": [
+        {
+          "round": 1,
+          "severity": "minor",
+          "claim": "\"Exempt block\" is defined as a *block* that states no rule, but two of its criteria are line-level (\"a blank line\", \"a line with no letters\") while others are block-level (\"a heading\", \"a table separator row\", \"the header row\"). For a deleted block containing both a letterless line and a lettered line, the spec does not say whether the block is exempt, partially exempt, or a deleted block whose deleted text includes the letterless line. A builder can implement either reading and both satisfy the text; a tester cannot decide which is correct.",
+          "spec_anchor": "3-what-vocabulary-types-and-interfaces"
+        }
+      ]
+    },
+    {
+      "lens": "architectural",
+      "severity": "minor",
+      "claim": "The spec requires both that step 5 \"print a `::notice::` line\" and that \"Every printed line starts with the fixed prefix `rule-inventory: `\". GitHub's runner only interprets a workflow command at the start of a line, so under the prefix rule the notice is inert literal text; dropping the prefix for that one line violates the hygiene rule exactly as written (and the rule's stated purpose — no line starting with `::` — is what scenario 10 pins for `::error::`). The spec as written cannot satisfy both; the builder must silently pick one.",
+      "evidence": "§4 step 5 (\"print a ::notice:: line and return skipped\") vs §3 \"Output hygiene\" (\"Every printed line starts with the fixed prefix `rule-inventory: `\"); scenario \"no line of its output starts with `::error::`\".",
+      "predicted_consequence": "Two PRs implementing the same spec emit differently formatted skip notices — one an inert text line, one a working workflow command — and a later hygiene audit flags whichever choice contradicts the letter of the rule.",
+      "spec_anchor": "what-how",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 2,
+      "last_round": 2,
+      "occurrences": [
+        {
+          "round": 2,
+          "severity": "minor",
+          "claim": "The spec requires both that step 5 \"print a `::notice::` line\" and that \"Every printed line starts with the fixed prefix `rule-inventory: `\". GitHub's runner only interprets a workflow command at the start of a line, so under the prefix rule the notice is inert literal text; dropping the prefix for that one line violates the hygiene rule exactly as written (and the rule's stated purpose — no line starting with `::` — is what scenario 10 pins for `::error::`). The spec as written cannot satisfy both; the builder must silently pick one.",
+          "spec_anchor": "what-how"
+        }
+      ]
+    },
+    {
+      "lens": "infosec",
+      "severity": "minor",
+      "claim": "The exemption set is decided per block with no content test for headings and header rows — a deleted block is skipped from coverage *because of its markdown shape*, not because it states no rule. A rule carried as a heading (`### Never invoke the prd slot without a run dir`) or as a table header cell is deleted with no row, no move requirement, and no failure: the check returns `skipped(\"no-prose-deleted\")` if that was the only deletion, or omits the block from `uncovered` otherwise. This is a fail-open path the spec itself creates inside its own scope, not a careless-build risk — the exemption list is normative in §3.",
+      "evidence": "§3 \"Exempt block … a heading, a table separator row (`|---|`), the header row of a table … or a block whose deleted text has no letters\"; §4 step 3 \"drop exempt blocks\"; §8 DONE \"Headings, table separator rows, table header rows and blocks whose deleted text has no letters are exempt, decided per block.\"",
+      "predicted_consequence": "an agent PR deletes a rule-bearing heading, the check exits 0, and the rule leaves the runtime prompt with no inventory row and no reviewer-facing `dropped` entry in the step summary.",
+      "spec_anchor": "what-vocabulary-types-and-interfaces",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 2,
+      "last_round": 2,
+      "occurrences": [
+        {
+          "round": 2,
+          "severity": "minor",
+          "claim": "The exemption set is decided per block with no content test for headings and header rows — a deleted block is skipped from coverage *because of its markdown shape*, not because it states no rule. A rule carried as a heading (`### Never invoke the prd slot without a run dir`) or as a table header cell is deleted with no row, no move requirement, and no failure: the check returns `skipped(\"no-prose-deleted\")` if that was the only deletion, or omits the block from `uncovered` otherwise. This is a fail-open path the spec itself creates inside its own scope, not a careless-build risk — the exemption list is normative in §3.",
+          "spec_anchor": "what-vocabulary-types-and-interfaces"
+        }
+      ]
+    },
+    {
+      "lens": "QA",
+      "severity": "minor",
+      "claim": "The scenario cannot be executed as written — the `When` clause omits the `--json` flag whose output the `Then` clause asserts, so a tester cannot decide what command to run or whether a failing build mis-routed the flag.",
+      "evidence": "Scenario \"Given a branch that deletes two bullets from plugin/skills/faff-prep/SKILL.md … When `faff rule-inventory check --base origin/main` runs / Then it exits 0 / And `--json` reports covered_by_row 2 and uncovered []\".",
+      "predicted_consequence": "The fixture test for the check's happy covered-by-row path is ambiguous: a builder may either add `--json` to the command or read the human-readable summary, and the two are not equivalent outputs — the assertion \"covered_by_row 2\" is only decidable on the JSON object.",
+      "spec_anchor": "5-scenarios",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 2,
+      "last_round": 2,
+      "occurrences": [
+        {
+          "round": 2,
+          "severity": "minor",
+          "claim": "The scenario cannot be executed as written — the `When` clause omits the `--json` flag whose output the `Then` clause asserts, so a tester cannot decide what command to run or whether a failing build mis-routed the flag.",
+          "spec_anchor": "5-scenarios"
+        }
+      ]
+    },
+    {
+      "lens": "architectural",
+      "severity": "minor",
+      "claim": "The spec justifies blocking from day one by claiming nine shipped inventories prove the format and \"the only new requirement is the code-span anchor.\" That is not true. Section 3 also introduces (a) a strict disposition grammar — exactly `kept`, `changed: <reason>`, or `dropped: <reason>` — and (b) a mandatory covering test for every `kept` row. The spec's own cited precedent, FAFF-1418's `## Rule inventory` (supplied in context), has no `Covering test` column at all and ~25 `kept` rows, most of them \"kept in prose\" with no test and no test possible. Under the new parser, every one of those rows is a row error, and the format has no natural disposition for a rule kept in prose: `kept` demands a test, so the author must misfile it as `changed: kept in prose`, which reads as a semantic lie in the summary table the reviewer is told to trust.",
+      "evidence": "Design decision \"**Blocking from day one, or report first.**\" (\"the only new requirement is the code-span anchor\") vs section 3's disposition and covering-test rules; FAFF-1418's inventory table in the supplied context.",
+      "predicted_consequence": "The first real extraction PR under this check cannot reuse the proven inventory style its author just shipped; it must retrofit every kept-in-prose row into a disposition the grammar doesn't actually have, or the check reddens on the format the spec cited as proof of readiness.",
+      "spec_anchor": "blocking-from-day-one-or-report-first",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 3,
+      "last_round": 3,
+      "occurrences": [
+        {
+          "round": 3,
+          "severity": "minor",
+          "claim": "The spec justifies blocking from day one by claiming nine shipped inventories prove the format and \"the only new requirement is the code-span anchor.\" That is not true. Section 3 also introduces (a) a strict disposition grammar — exactly `kept`, `changed: <reason>`, or `dropped: <reason>` — and (b) a mandatory covering test for every `kept` row. The spec's own cited precedent, FAFF-1418's `## Rule inventory` (supplied in context), has no `Covering test` column at all and ~25 `kept` rows, most of them \"kept in prose\" with no test and no test possible. Under the new parser, every one of those rows is a row error, and the format has no natural disposition for a rule kept in prose: `kept` demands a test, so the author must misfile it as `changed: kept in prose`, which reads as a semantic lie in the summary table the reviewer is told to trust.",
+          "spec_anchor": "blocking-from-day-one-or-report-first"
+        }
+      ]
+    },
+    {
+      "lens": "infosec",
+      "severity": "minor",
+      "claim": "The summary writer strips control characters and caps length, but does not escape markdown metacharacters. A committed spec (untrusted input, written by the gated agent) can carry a `dropped:` reason or anchor containing `|`, backticks, or `![label](https://attacker/px)`; those bytes flow verbatim into the markdown table appended to `$GITHUB_STEP_SUMMARY`, which GitHub renders on the PR's check page. A `|` breaks the table (hiding the dropped-row surfacing the check exists to provide); an image/link renders attacker-chosen content on a GitHub-trusted surface.",
+      "evidence": "§4 \"Output hygiene\" — \"Every spec-derived value is stripped of control characters … and capped at 200 characters before it is … written to the summary\"; the CI step passes `$GITHUB_STEP_SUMMARY`. No escaping of `|`, `` ` ``, `[]()`, `!` is specified anywhere.",
+      "predicted_consequence": "A spec author controls rendered markdown on the PR check page (external-image beacon, link injection, or a broken table that suppresses the dropped/changed rows from the reviewer's view).",
+      "spec_anchor": "output-hygiene-the-committed-spec-is-untrusted-input",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 3,
+      "last_round": 3,
+      "occurrences": [
+        {
+          "round": 3,
+          "severity": "minor",
+          "claim": "The summary writer strips control characters and caps length, but does not escape markdown metacharacters. A committed spec (untrusted input, written by the gated agent) can carry a `dropped:` reason or anchor containing `|`, backticks, or `![label](https://attacker/px)`; those bytes flow verbatim into the markdown table appended to `$GITHUB_STEP_SUMMARY`, which GitHub renders on the PR's check page. A `|` breaks the table (hiding the dropped-row surfacing the check exists to provide); an image/link renders attacker-chosen content on a GitHub-trusted surface.",
+          "spec_anchor": "output-hygiene-the-committed-spec-is-untrusted-input"
+        }
+      ]
+    },
+    {
+      "lens": "QA",
+      "severity": "minor",
+      "claim": "`footprint := some path with status A starts \".faff/anchors/\"`. A continuation PR on the same run (rebase, follow-up fix, second extraction against the same issue) modifies the anchor graft already committed — status `M`, not `A`. Such a PR deletes prose, carries the agent footprint, commits no new spec, and the check returns `skipped: no-spec-committed` with a `::notice::` — exactly the silent skip the footprint scope exists to prevent. The spec's own failure mode \"An agent PR commits neither a spec nor an anchor\" names the neither-case but not the modified-anchor case.",
+      "evidence": "§3 \"Agent footprint\" definition; §4 step 2; failure mode \"An agent PR commits neither a spec nor an anchor.\"",
+      "predicted_consequence": "an agent PR that deletes skill prose with no inventory row merges green; the check's core guarantee silently does not apply to it, and nothing in the test suite or scenarios would catch it.",
+      "spec_anchor": "3-what-vocabulary-types-and-interfaces",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 3,
+      "last_round": 3,
+      "occurrences": [
+        {
+          "round": 3,
+          "severity": "minor",
+          "claim": "`footprint := some path with status A starts \".faff/anchors/\"`. A continuation PR on the same run (rebase, follow-up fix, second extraction against the same issue) modifies the anchor graft already committed — status `M`, not `A`. Such a PR deletes prose, carries the agent footprint, commits no new spec, and the check returns `skipped: no-spec-committed` with a `::notice::` — exactly the silent skip the footprint scope exists to prevent. The spec's own failure mode \"An agent PR commits neither a spec nor an anchor\" names the neither-case but not the modified-anchor case.",
+          "spec_anchor": "3-what-vocabulary-types-and-interfaces"
+        }
+      ]
+    },
+    {
+      "lens": "architectural",
+      "severity": "minor",
+      "claim": "The moved test matches a deleted block's joined text against a **single** added run (\"Runs are never joined to each other\"), but a reflow that leaves two or more consecutive unchanged lines in the middle of a paragraph splits both the deletions and the additions into separate `-U0` hunks. The block's deleted text (joined across the unchanged line) is then a substring of no single added run, so the block is not moved — directly contradicting the spec's own edge-case bullet, which asserts reflows are always moved.",
+      "evidence": "§3 \"Moved\" definition and the \"Runs are never joined to each other\" clause; §4 edge case \"**A paragraph reflowed.** The deleted lines join to the same normalised text the added lines join to, so it is moved.\"",
+      "predicted_consequence": "A pure word-preserving reflow that happens to preserve an interior line fails as \"uncovered\" and demands a `changed: reworded`-style row for a change that needs none — exactly the noise failure mode §4 names, produced by the spec's own stated guarantee rather than by a careless builder. A builder implementing to the edge-case bullet (e.g., asserting moved-ness in the mutation test) ships a check whose behaviour disagrees with its documented contract.",
+      "spec_anchor": "4-how-behaviour",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "severity": "minor",
+          "claim": "The moved test matches a deleted block's joined text against a **single** added run (\"Runs are never joined to each other\"), but a reflow that leaves two or more consecutive unchanged lines in the middle of a paragraph splits both the deletions and the additions into separate `-U0` hunks. The block's deleted text (joined across the unchanged line) is then a substring of no single added run, so the block is not moved — directly contradicting the spec's own edge-case bullet, which asserts reflows are always moved.",
+          "spec_anchor": "4-how-behaviour"
+        }
+      ]
+    },
+    {
+      "lens": "architectural",
+      "severity": "minor",
+      "claim": "The watched-path list (`plugin/skills/*/SKILL.md` + `plugin/skills/faff/references/*.md`) is a new, independently maintained path list that is **narrower** than the prose set `prose-size.ts`/`prose-baseline.json` already govern (per `docs/reference/skill-authoring.md`: every `SKILL.md` and every `references/*.md`). A rule moved from a watched `SKILL.md` into another skill's `references/*.md` — real skill prose by the charter's definition — is \"not moved\" here and demands a row, while the byte ratchet treats the same file as first-class prose. The two gates now disagree about what counts as skill prose, and the spec names no cross-check.",
+      "evidence": "§3 \"Watched file\" term; §2 OUT OF SCOPE \"Prose outside `plugin/skills/**/SKILL.md` and `plugin/skills/faff/references/*.md`\" with extension point \"the watched-path list in the module\"; reference-context row for `prose-size.ts` (\"defines which files count as skill prose\").",
+      "predicted_consequence": "The next prose surface (e.g., a second skill gains `references/`) is added to `prose-baseline.json` but silently escapes rule-inventory — deletions from it need no rows — and the divergence is invisible until a reviewer notices a rule that the byte ratchet guards but the inventory check does not.",
+      "spec_anchor": "3-what-vocabulary-types-and-interfaces",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "severity": "minor",
+          "claim": "The watched-path list (`plugin/skills/*/SKILL.md` + `plugin/skills/faff/references/*.md`) is a new, independently maintained path list that is **narrower** than the prose set `prose-size.ts`/`prose-baseline.json` already govern (per `docs/reference/skill-authoring.md`: every `SKILL.md` and every `references/*.md`). A rule moved from a watched `SKILL.md` into another skill's `references/*.md` — real skill prose by the charter's definition — is \"not moved\" here and demands a row, while the byte ratchet treats the same file as first-class prose. The two gates now disagree about what counts as skill prose, and the spec names no cross-check.",
+          "spec_anchor": "3-what-vocabulary-types-and-interfaces"
+        }
+      ]
+    },
+    {
+      "lens": "infosec",
+      "severity": "minor",
+      "claim": "The spec pins the diff commands without zero-termination or quoted-path handling. `git diff --no-renames --name-status base HEAD` (and `git diff -U0` for hunk headers, and `git show base:<path>`) quote paths containing spaces, quotes, or non-ASCII characters (`core.quotePath`), emitting `\"plugin/skills/my skill/SKILL.md\"` with C-style escapes. A PR that adds or edits a watched file whose directory name contains a space, a quote, or a non-ASCII character produces a quoted path the parser may fail to match against the watched globs — so deletions in that file are never seen, and the check returns `skipped: no-prose-deleted` or a pass while skill prose was deleted. Because the PR author controls the directory name, this is an input-driven fail-open, not a careless-build risk: the exact commands are specified, and nothing in the spec says to use `-z` or to unquote.",
+      "evidence": "§4 PROCEDURE step 2 (\"git diff --no-renames --name-status base HEAD\") and step 3 (\"git show base:<path>\", \"git diff -U0 … hunk headers\"); no `-z` flag or quoted-path rule appears anywhere in §3/§4.",
+      "predicted_consequence": "a PR deleting rules from `plugin/skills/<name containing a space or non-ASCII char>/SKILL.md` exits 0 (skipped/pass) with the deletion unenforced.",
+      "spec_anchor": "how-behaviour",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "severity": "minor",
+          "claim": "The spec pins the diff commands without zero-termination or quoted-path handling. `git diff --no-renames --name-status base HEAD` (and `git diff -U0` for hunk headers, and `git show base:<path>`) quote paths containing spaces, quotes, or non-ASCII characters (`core.quotePath`), emitting `\"plugin/skills/my skill/SKILL.md\"` with C-style escapes. A PR that adds or edits a watched file whose directory name contains a space, a quote, or a non-ASCII character produces a quoted path the parser may fail to match against the watched globs — so deletions in that file are never seen, and the check returns `skipped: no-prose-deleted` or a pass while skill prose was deleted. Because the PR author controls the directory name, this is an input-driven fail-open, not a careless-build risk: the exact commands are specified, and nothing in the spec says to use `-z` or to unquote.",
+          "spec_anchor": "how-behaviour"
+        }
+      ]
+    },
+    {
+      "lens": "QA",
+      "severity": "minor",
+      "claim": "The scenario cannot pass as specified, because its own fixture triggers a row error the spec elsewhere mandates.",
+      "evidence": "Scenario \"Given a branch that deletes two bullets and commits a spec with a 'kept' row for one and a 'dropped: superseded by faff x' row for the other … `--summary out.md` … Then it exits 0\". The scenario never states that the `kept` row names a covering test — but §4.1 step 8 and the DONE item make \"kept with no tests\" a row error, which forces exit 1. As written, the fixture's expected outcome contradicts the spec's own validation rule; a builder implementing faithfully fails this scenario, and a builder making it pass must silently add an unstated fixture detail.",
+      "predicted_consequence": "The scenario is unbuildable as stated — either the test fails spuriously or the fixture is amended off-spec, so this scenario verifies nothing.",
+      "spec_anchor": "5-scenarios",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "severity": "minor",
+          "claim": "The scenario cannot pass as specified, because its own fixture triggers a row error the spec elsewhere mandates.",
+          "spec_anchor": "5-scenarios"
+        }
+      ]
+    },
+    {
+      "lens": "QA",
+      "severity": "minor",
+      "claim": "§3 says only \"Without `--json` it prints one line per uncovered block and per row error, then a one-line summary\" — it never states what those lines contain. The holdout scenario \"…reads 'dropped:' with nothing after the colon … Then it exits 1 And the output names the row's line in the spec\" asserts a property (`names the row's line`) the spec never requires the printed line to carry. `row_errors` entries carry `line` in the JSON record, but nothing says the human-readable rendering includes it.",
+      "evidence": "Scenario in §5 (the empty-`dropped:` holdout); §3 \"Command surface\" output description.",
+      "predicted_consequence": "The holdout's `Then` cannot be decided from the spec — a build whose row-error lines omit the spec line number satisfies every stated output requirement yet fails the scenario, and there is no way to say which side is wrong.",
+      "spec_anchor": "3-what-vocabulary-types-and-interfaces",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": null,
+      "first_round": 4,
+      "last_round": 4,
+      "occurrences": [
+        {
+          "round": 4,
+          "severity": "minor",
+          "claim": "§3 says only \"Without `--json` it prints one line per uncovered block and per row error, then a one-line summary\" — it never states what those lines contain. The holdout scenario \"…reads 'dropped:' with nothing after the colon … Then it exits 1 And the output names the row's line in the spec\" asserts a property (`names the row's line`) the spec never requires the printed line to carry. `row_errors` entries carry `line` in the JSON record, but nothing says the human-readable rendering includes it.",
+          "spec_anchor": "3-what-vocabulary-types-and-interfaces"
+        }
+      ]
+    },
+    {
+      "lens": "architectural",
+      "severity": "minor",
+      "claim": "The anchor floor and the coverage rule are inconsistent. Row validation admits any anchor shorter than 20 characters provided it equals the whole normalised deleted text of *some* deleted block; the coverage rule then lets any valid anchor cover any block it is a substring of, with no length or equality restriction. So a short anchor that is legitimately valid for one small block (a short heading, a one-line bullet) silently covers every other deleted block containing that phrase — the spurious coverage the floor was designed to prevent.",
+      "evidence": "§3 Design decisions, \"How a deleted block maps to a row\": \"The 20-character floor stops an anchor like `` `faff next` `` from covering every block that mentions the command. A deleted block shorter than 20 characters is covered by an anchor equal to its whole normalised deleted text.\" Step 8 validates the floor *or* whole-text equality; step 9 applies only \"anchor is a substring of normalise(b.deleted_text)\".",
+      "predicted_consequence": "A deleted block passes as `covered_by_row` on the strength of a row written for an unrelated short block; the gate reports pass where its own floor rationale says it should report uncovered. Fix is a one-line spec edit: a sub-20-character anchor covers only the block it exactly equals.",
+      "spec_anchor": "3-what-vocabulary-types-and-interfaces",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": "Fixed in place after round 5; not re-reviewed. Accepted by the operator after round 5.",
+      "first_round": 5,
+      "last_round": 5,
+      "occurrences": [
+        {
+          "round": 5,
+          "severity": "minor",
+          "claim": "The anchor floor and the coverage rule are inconsistent. Row validation admits any anchor shorter than 20 characters provided it equals the whole normalised deleted text of *some* deleted block; the coverage rule then lets any valid anchor cover any block it is a substring of, with no length or equality restriction. So a short anchor that is legitimately valid for one small block (a short heading, a one-line bullet) silently covers every other deleted block containing that phrase — the spurious coverage the floor was designed to prevent.",
+          "spec_anchor": "3-what-vocabulary-types-and-interfaces"
+        }
+      ]
+    },
+    {
+      "lens": "QA",
+      "severity": "minor",
+      "claim": "The DONE item \"Table separator rows and letterless blocks are exempt; a table header row is exempt only when its whole table is deleted, and a heading only when its whole section is deleted\" is required behaviour, but no scenario in section 5 exercises any exemption path, and the tests DONE item only demands \"each scenario in section 5 and each row-error kind\" — exemption is neither, so a spec-compliant test suite may omit it entirely.",
+      "evidence": "`### From HOW (behaviour)` exemption DONE item vs. the fifteen fenced scenarios in `## 5. SCENARIOS`, none of which deletes a table separator, a header row, or a heading-with-partially-deleted-section.",
+      "predicted_consequence": "A build that mis-implements exemption — e.g. treats any deleted heading as exempt, or exempts a header row when only some rows of its table are deleted — passes every scenario and every row-error test while letting a rule carried in a heading or header escape the check unquoted. That is precisely the false-negative the check exists to prevent, and nothing in the spec's own acceptance surface would catch it.",
+      "spec_anchor": "from-how-behaviour",
+      "disposition": "fixed",
+      "refutation": null,
+      "disposition_rationale": "Fixed in place after round 5; not re-reviewed. Accepted by the operator after round 5.",
+      "first_round": 5,
+      "last_round": 5,
+      "occurrences": [
+        {
+          "round": 5,
+          "severity": "minor",
+          "claim": "The DONE item \"Table separator rows and letterless blocks are exempt; a table header row is exempt only when its whole table is deleted, and a heading only when its whole section is deleted\" is required behaviour, but no scenario in section 5 exercises any exemption path, and the tests DONE item only demands \"each scenario in section 5 and each row-error kind\" — exemption is neither, so a spec-compliant test suite may omit it entirely.",
+          "spec_anchor": "from-how-behaviour"
+        }
+      ]
+    }
+  ]
+}
diff --git a/.github/workflows/validate.yml b/.github/workflows/validate.yml
index d074c41b8..9fc55131c 100644
--- a/.github/workflows/validate.yml
+++ b/.github/workflows/validate.yml
@@ -152,6 +152,45 @@ jobs:
               ;;
           esac
 
+      # FAFF-1428: every block of skill prose a PR deletes must be moved verbatim into other skill prose
+      # or quoted by a `## Rule inventory` row in a spec the PR adds. Same env-only base resolution as
+      # the region step above; the no-base command line stays literal for `faff gates discover`.
+      - name: Rule inventory covers deleted skill prose (FAFF-1428)
+        env:
+          EVENT: ${{ github.event_name }}
+          BASE_REF: ${{ github.base_ref }}
+          BEFORE: ${{ github.event.before }}
+        run: |
+          set -euo pipefail
+          quote() { node -e 'process.stdout.write(JSON.stringify(process.argv[1]))' -- "$1"; }
+          case "$EVENT" in
+            pull_request)
+              if [[ ! "$BASE_REF" =~ ^[A-Za-z0-9._/-]+$ || "$BASE_REF" == -* ]]; then
+                echo "::error::pull_request base_ref $(quote "$BASE_REF") is not a plain ref"
+                exit 1
+              fi
+              git fetch --depth=1 origin "+refs/heads/$BASE_REF:refs/remotes/origin/$BASE_REF"
+              node plugin/skills/faff/bin/faff rule-inventory check --base "origin/$BASE_REF" --summary "$GITHUB_STEP_SUMMARY"
+              ;;
+            push)
+              if [[ "$BEFORE" =~ ^0{40}$ ]]; then
+                node plugin/skills/faff/bin/faff rule-inventory check
+              elif [[ "$BEFORE" =~ ^[0-9a-f]{40}$ ]]; then
+                if ! git fetch --depth=1 origin "$BEFORE"; then
+                  echo "::error::cannot fetch the push's before commit $BEFORE (unreachable, likely after a force-push); deleted skill prose cannot be checked"
+                  exit 1
+                fi
+                node plugin/skills/faff/bin/faff rule-inventory check --base "$BEFORE" --summary "$GITHUB_STEP_SUMMARY"
+              else
+                echo "::error::push event before $(quote "$BEFORE") is neither a 40-hex commit nor all zeros"
+                exit 1
+              fi
+              ;;
+            *)
+              node plugin/skills/faff/bin/faff rule-inventory check
+              ;;
+          esac
+
       - name: Registry selftest battery — factory members (incl. the destructive worktree-prune, FAFF-581)
         run: node plugin/skills/faff/bin/faff regions selftest --region factory
 
diff --git a/docs/guide/cli.md b/docs/guide/cli.md
index ef3a779a9..546f3b124 100644
--- a/docs/guide/cli.md
+++ b/docs/guide/cli.md
@@ -56,6 +56,7 @@ install:
 Each entry is absolute or `~`/`~/…`-relative (a bare unquoted `~` parses as YAML null — quote it: `"~"`); a non-absolute, non-`~` entry is skipped with a stderr notice. Unset, or every entry unusable, falls back to the hardcoded pair above — in both `link-skills.sh --global` and `faff doctor`'s default scan set — byte-for-byte identical to before this key existed. Governs `--global` installs and doctor's default scan set only: never repo-local (non-`--global`) mode, `--target`, or `$CLAUDE_PLUGIN_ROOT`.
 | `validate-adapters [--skills-dir DIR]` | Lint the shipped slot-skills for conformance drift (CI / pre-commit). Includes the per-file byte ratchet over every `SKILL.md` and `references/*.md` against `plugin/skills/faff/prose-baseline.json`: growth prints `FAIL  <path> (prose bytes)` with the size, baseline and `+<delta>` and exits 1, as does a covered file with no entry or an entry with no file; a shrink prints a non-failing `RATCHET` line. A missing or malformed baseline fails on the bundled tree; with `--skills-dir` a missing one only prints an `INFO` line. |
 | `prose-size baseline --lower [--skills-dir DIR] [--json]`; `prose-size tally --from REF --to REF [--scope all\|hot] [--group LABEL=T1,T2,...]... [--repo DIR] [--json]` | **Skill prose size in bytes.** `baseline --lower` rewrites `prose-baseline.json`, lowering each entry whose file shrank; it never raises, adds or removes an entry and reports each grown, unlisted or missing file it left alone (exit 2 on a missing or malformed baseline or a write failure). `tally` reads git history only: for each first-parent commit in `REF..REF` it sizes the covered files (`hot` = the beep-boop, graft and prep `SKILL.md`) from `git ls-tree -l` and prints one row per commit that changed the total (ticket = the last parenthesised key in the subject), then each `--group`'s net, `other`, start, end and net; `--json` emits the same as an object. Exit 2 when the repo or a ref cannot be resolved. No `--selftest`; covered by `test/prose-size.test.mjs`. |
+| `rule-inventory check [--base REF] [--json] [--summary FILE]` | **Deleted skill prose must map to a rule-inventory row.** Compares REF's tree with HEAD's (pass a merge-base; without `--base`, the merge-base with `origin/HEAD`, else skipped `no-base`). Every deleted block of skill prose (the `prose-size` covered set) must either appear verbatim inside one block of skill prose at HEAD, or be quoted by a row of a `## Rule inventory` table in a spec the diff adds under the spec docs path (format: `docs/reference/skill-authoring.md#rule-inventory`). Skipped when no prose is deleted, or when no spec is committed and no `.faff/anchors/` path changed; a changed anchor with no spec fails. `--summary FILE` appends the row-covered blocks, `dropped` and `changed` first. Every printed line starts `rule-inventory: `. Exit 0 pass or skipped, 1 fail, 2 a bad ref, git failure, unreadable or over-1-MiB spec, or unreadable config. No `--selftest`; covered by `test/rule-inventory.test.mjs`. |
 | `validate-adapters --configured [--root DIR]` | Pre-flight *your* configured (swapped-in) slot occupants before an unattended run. |
 
 ## Eligibility & routing (pure — no tracker/network)
diff --git a/docs/reference/skill-authoring.md b/docs/reference/skill-authoring.md
index 1fb078468..41404112b 100644
--- a/docs/reference/skill-authoring.md
+++ b/docs/reference/skill-authoring.md
@@ -34,6 +34,29 @@ Run over every `SKILL.md`. A `FAIL <name> (<category>) ✗ <label>` line exits n
 
 **Honest limits.** The `validate-adapters` rules catch the realistic drift (a skill ballooning, a wall-of-text paragraph, copied prose, a stray war-story idiom, a broken cross-reference). They do **not** measure taste or skimmability — that stays human/agent review judgement. The `stray marker` rule is deliberately narrow (precise idioms, not a blanket ban); ticket/ADR refs are not its job — `faff lint-refs` owns that ban. The two hub files' zero-headroom ratchet has its own honest limit: `validate-adapters` is a **stateless** linter — it reads the working tree, never git history — so it cannot mechanically stop a contributor from hand-raising a `SKILL_LINE_BASELINE` value to fit growth instead of leaning the file. The real gate is that such a raise is a conspicuous, reviewable line in the diff, not a silent pass; a git-history check that asserts baselines never increase across commits is deferred (FAFF-584). The same holds for `prose-baseline.json`: `faff prose-size baseline --lower` only ever lowers an entry, so a raise (or a new or removed entry) is always a hand edit visible in the diff, and `faff prose-size tally --from <ref> --to <ref>` reconstructs every rise and fall per commit and per ticket from git history after the fact.
 
+## Rule inventory
+
+A spec that deletes skill prose (every `SKILL.md` and `references/*.md`, the same covered set as `prose bytes`) carries a `## Rule inventory`. `faff rule-inventory check` runs in the `validate` CI job and fails the PR when a deleted block of skill prose is neither moved word for word into another block of skill prose nor quoted by a row of an inventory in a spec the PR adds under the spec docs path. It proves coverage, never correctness: whether a row's claim is true stays with review and the holdout.
+
+```markdown
+## Rule inventory
+
+| Prose rule | Command behaviour | Covering test | Disposition |
+|---|---|---|---|
+| `Fail closed on an unreadable ledger, never a pass` | exit 2 on a read error | test/run-open.test.mjs: "unreadable ledger exits 2" | kept |
+| `Tick the heartbeat before and after the ladder` | the command ticks it | — | changed: the command ticks it itself |
+| `Log the round to graft.md as well` | none | — | dropped: the round record replaces it |
+```
+
+- **Section.** Any line starting `## Rule inventory` (a suffix such as `(slice A)` is fine). It runs to the next `## ` heading. Every table in it whose header has a `Prose rule` and a `Disposition` column is read; columns are found by name, case-insensitively, a qualifier after the name is allowed, and other columns are free. A header with one of the two and not the other is an error.
+- **Prose rule.** The first code span in the cell is the anchor. Quote the lines the PR deletes, not the block as it stood: when only part of a paragraph goes, the anchor must sit inside the deleted part. Matching ignores `*` and backticks and collapses whitespace, so quote with or without bold leads and code spans. An anchor shorter than 20 characters only covers a deleted block whose whole text it equals. An anchor containing a backtick uses a longer delimiter (``` `` like `this` `` ```); a literal pipe inside a cell is written `\|`.
+- **Covering test.** Zero or more `test/<path>.test.mjs` entries, each optionally followed by `: "<test name>"`, separated by `;` or `,`. Each file must exist, and a named test must appear in it as written. A `kept` row needs at least one, so a table with a `kept` row needs this column.
+- **Disposition.** Exactly one of `kept`, `changed: <reason>` or `dropped: <reason>`; a reason is required.
+
+What needs no row: text that still appears verbatim in one block of skill prose (a move, a rename, a reflow, a rule extended in place), table separator rows, letterless lines, and a heading or table header row deleted together with every line of its section or table, with nothing added in its place and none of that content reappearing elsewhere. A heading over an empty section is never exempt. A reworded rule needs a row, typically `changed: reworded, same rule`; prose moved to `docs/` needs one too, normally `dropped: moved to docs/<file>`.
+
+Scope follows the artifacts graft commits. The check applies when the PR adds a spec under the spec docs path; a PR that adds or modifies a path under `.faff/anchors/` but commits no spec fails; a PR with neither (a hand-written prose edit) is skipped with a notice. The `--summary` table on the check page lists every row-covered block, `dropped` and `changed` first, for the reviewer.
+
 ## Eval coverage — born with the ticket
 
 A judgement seam ships with its eval coverage; the net never plays catch-up (the FAFF-145 / ADR-0004 lesson — every seam used to ship first and the evals chased).
diff --git a/plugin/skills/faff/bin/faff b/plugin/skills/faff/bin/faff
index f2a2f2233..8b48d744e 100755
--- a/plugin/skills/faff/bin/faff
+++ b/plugin/skills/faff/bin/faff
@@ -49,6 +49,7 @@ const { cmdPrep } = lazy(() => require("./lib/prep-attach"), ["cmdPrep"]);
 const { cmdGraft } = lazy(() => require("./lib/graft-admit"), ["cmdGraft"]);
 const { cmdRun } = lazy(() => require("./lib/run"), ["cmdRun"]);
 const { cmdProseSize } = lazy(() => require("./lib/prose-size"), ["cmdProseSize"]);
+const { cmdRuleInventory } = lazy(() => require("./lib/rule-inventory"), ["cmdRuleInventory"]);
 const { cmdPr } = lazy(() => require("./lib/pr-open"), ["cmdPr"]);
 const { cmdWorktree } = lazy(() => require("./lib/worktree-ensure"), ["cmdWorktree"]);
 const { cmdClaimVerdict } = lazy(() => require("./lib/claim-verdict"), ["cmdClaimVerdict"]);
@@ -248,6 +249,7 @@ const COMMANDS = {
   graft: cmdGraft,
   run: cmdRun,
   "prose-size": cmdProseSize,
+  "rule-inventory": cmdRuleInventory,
   pr: cmdPr,
   worktree: cmdWorktree,
   "post-merge-check": cmdPostMergeCheck,
diff --git a/plugin/skills/faff/bin/lib/gates-report.js b/plugin/skills/faff/bin/lib/gates-report.js
index f9f097e27..269fe41ff 100644
--- a/plugin/skills/faff/bin/lib/gates-report.js
+++ b/plugin/skills/faff/bin/lib/gates-report.js
@@ -19,7 +19,7 @@ const { CI_COST_PENALTY, CI_RUNNERS, GATE_COST, discoverMakefile, discoverPkgScr
 // 2026-08-19-FAFF-848-639a-gate-discovery-sees-what-ci-sees-design.md.
 // ===========================================================================
 
-// The four invariant-lint patterns, reporting-only. Additive to CI_RUNNERS — never consulted by
+// The invariant-lint patterns, reporting-only. Additive to CI_RUNNERS — never consulted by
 // ciRunnerKind/runLadder. `regions selftest` matches BOTH CI variants (--region factory/governance)
 // as two distinct commands; report-only recognition of the destructive factory variant is safe
 // because 848 executes nothing it reports (human-ratified 2026-08-19 — see the spec §7).
@@ -28,6 +28,8 @@ const INVARIANT_LINT_PATTERNS = [
   { pattern: /(^|[^a-z])regions\s+check([^a-z]|$)/, kind: "STATIC_ANALYSIS" },
   { pattern: /(^|[^a-z])adr\s+validate([^a-z]|$)/, kind: "STATIC_ANALYSIS" },
   { pattern: /(^|[^a-z])prdr\s+validate([^a-z]|$)/, kind: "STATIC_ANALYSIS" },
+  // FAFF-1428: the rule-inventory diff check, beside `regions check` in the validate job.
+  { pattern: /(^|[^a-z])rule-inventory\s+check([^a-z]|$)/, kind: "STATIC_ANALYSIS" },
 ];
 
 // The reporting recogniser = CI_RUNNERS ∪ INVARIANT_LINT_PATTERNS. Reporting-only: never seen by
diff --git a/plugin/skills/faff/bin/lib/lint-cli-coverage.js b/plugin/skills/faff/bin/lib/lint-cli-coverage.js
index 16a03be98..2480ca029 100644
--- a/plugin/skills/faff/bin/lib/lint-cli-coverage.js
+++ b/plugin/skills/faff/bin/lib/lint-cli-coverage.js
@@ -68,6 +68,9 @@ const TEST_FILE_COVERAGE = {
   // prose-size (FAFF-1442): `faff prose-size baseline --lower` and `tally` have no `--selftest`; both, and
   // the validate-adapters byte ratchet, are exercised through the real CLI entrypoint and in-process.
   "prose-size": "test/prose-size.test.mjs",
+  // rule-inventory (FAFF-1428): `faff rule-inventory check` has no `--selftest`; it is exercised through the
+  // real CLI entrypoint over fixture git repos with a local bare origin, and in-process.
+  "rule-inventory": "test/rule-inventory.test.mjs",
   // spec-judge-accept-bar — the deterministic accept-bar roll-up (FAFF-945): a pure coercion
   // over two JSON inputs, no standalone `--selftest`; its level-aware floor + fail-closed
   // directions are exercised through the real CLI entrypoint here.
diff --git a/plugin/skills/faff/bin/lib/regions.js b/plugin/skills/faff/bin/lib/regions.js
index 6b519946e..f548c5d10 100644
--- a/plugin/skills/faff/bin/lib/regions.js
+++ b/plugin/skills/faff/bin/lib/regions.js
@@ -577,6 +577,8 @@ const REGION_MAP = {
   worktree: "factory",
   // FAFF-1442: prose-size reads the skills dir and git history only; validate-adapters (factory) calls it.
   "prose-size": "factory",
+  // FAFF-1428: rule-inventory reads git trees and committed specs only; it imports prose-size's isCovered.
+  "rule-inventory": "factory",
   // FAFF-363: governance-check references the SAME factory identifiers merge-gate does
   // (readAcComplete/readReviewVerdict/readHoldout from merge-gate.js, which themselves
   // call contract-defs.js's computeReviewVerdict) — for the identical reason merge-gate
@@ -819,6 +821,8 @@ const REGION_SELFTEST_ARGV = {
   worktree: null,
   // FAFF-1442: no --selftest (tests live in test/ only); lint-cli-coverage's TEST_FILE_COVERAGE names them.
   "prose-size": null,
+  // FAFF-1428: no --selftest (tests live in test/ only); lint-cli-coverage's TEST_FILE_COVERAGE names them.
+  "rule-inventory": null,
   "governance-check": ["governance-check", "--selftest"],
   "evidence-readiness": ["evidence-readiness", "--selftest"],
   "landing-comment": ["landing-comment", "--selftest"],
diff --git a/plugin/skills/faff/bin/lib/rule-inventory.js b/plugin/skills/faff/bin/lib/rule-inventory.js
new file mode 100644
index 000000000..d89b0370b
--- /dev/null
+++ b/plugin/skills/faff/bin/lib/rule-inventory.js
@@ -0,0 +1,826 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// ===========================================================================
+// === region:factory — rule-inventory — FAFF-1428: deleted skill prose must map to a rule-inventory row ===
+//
+// `faff rule-inventory check [--base REF]` compares HEAD's tree with the base's. Every block of skill
+// prose (prose-size's `isCovered` set) the diff deletes must either reappear verbatim inside one block of
+// skill prose at HEAD (moved), or be quoted by a row of a `## Rule inventory` table in a spec the diff adds
+// under the spec docs path. Exit 0 pass or skipped, 1 fail, 2 usage / git / read error (never a pass).
+// The check proves coverage, never correctness: whether a row's claim is true is review's job.
+// Format: docs/reference/skill-authoring.md#rule-inventory.
+// ===========================================================================
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { parseArgs } = require("./argv");
+const { isCovered } = require("./prose-size");
+const { loadConfig, resolveSpecDocsPath } = require("./config-core");
+class CheckError extends Error {
+}
+// FAFF-1463: a failed main-checkout probe passes through to the dispatch arm, which names git's message.
+function isProbeFailure(e) {
+    return e instanceof Error && e.message === "git-probe-failed";
+}
+const SKILLS_PREFIX = "plugin/skills/";
+const ANCHORS_PREFIX = ".faff/anchors/";
+const FORMAT_DOC = "docs/reference/skill-authoring.md#rule-inventory";
+const MIN_ANCHOR = 20;
+const MAX_SPEC_BYTES = 1024 * 1024;
+const MAX_VALUE = 200;
+const EXCERPT = 120;
+const PLAIN_REF = /^[A-Za-z0-9._/-]+$/;
+const TEST_PATH = /^test\/[A-Za-z0-9._/-]+\.test\.mjs$/;
+const SKIP_NOTICE = "::notice::rule-inventory: skipped, no spec committed";
+// ---------------------------------------------------------------------------
+// Text helpers.
+// ---------------------------------------------------------------------------
+// Delete every `*` and backtick, collapse whitespace runs to one space, trim.
+function normalise(s) {
+    return s.replace(/[*`]/g, "").replace(/\s+/g, " ").trim();
+}
+const codePoints = (s) => Array.from(s).length;
+// Strip control characters (ESC and newlines included) and cap at `cap` characters.
+function clean(s, cap = MAX_VALUE) {
+    // eslint-disable-next-line no-control-regex
+    const stripped = s.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ");
+    const cps = Array.from(stripped);
+    return cps.length > cap ? cps.slice(0, cap).join("") : stripped;
+}
+// Escape a spec-derived value for a markdown table cell on the rendered check page.
+function mdEscape(s) {
+    return clean(s)
+        .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+        .replace(/[\\`*_[\]()!|#]/g, (c) => `\\${c}`);
+}
+const isWatched = (p) => p.startsWith(SKILLS_PREFIX) && isCovered(p.slice(SKILLS_PREFIX.length));
+// ---------------------------------------------------------------------------
+// Block parsing (the authoring standard's markdown, not full CommonMark).
+// ---------------------------------------------------------------------------
+const FENCE_OPEN = /^(`{3,}|~{3,})/;
+const HEADING = /^(#{1,6})(\s|$)/;
+const LIST_ITEM = /^([-*+]|\d+\.)\s/;
+const SEPARATOR = /^\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?$/;
+function parseBlocks(file, text) {
+    const blocks = [];
+    const lines = text.split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    let cur = null;
+    let fence = null;
+    const open = (n, kind, level, line) => {
+        const b = { file, start: n, end: n, kind, level, lines: [line] };
+        blocks.push(b);
+        return b;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const n = i + 1;
+        const t = line.trim();
+        if (fence !== null && cur !== null) {
+            cur.lines.push(line);
+            cur.end = n;
+            const m = FENCE_OPEN.exec(t);
+            if (m && m[1] !== undefined && m[1][0] === fence.ch && m[1].length >= fence.len && t.slice(m[1].length).trim() === "") {
+                fence = null;
+                cur = null;
+            }
+            continue;
+        }
+        if (t === "") {
+            cur = null;
+            continue;
+        }
+        const f = FENCE_OPEN.exec(t);
+        if (f && f[1] !== undefined) {
+            cur = open(n, "fence", 0, line);
+            fence = { ch: f[1][0] ?? "`", len: f[1].length };
+            continue;
+        }
+        const h = HEADING.exec(t);
+        if (h && h[1] !== undefined) {
+            open(n, "heading", h[1].length, line);
+            cur = null;
+            continue;
+        }
+        if (t.startsWith("|")) {
+            open(n, "table", 0, line);
+            cur = null;
+            continue;
+        }
+        if (LIST_ITEM.test(t)) {
+            cur = open(n, "list", 0, line);
+            continue;
+        }
+        if (cur === null) {
+            cur = open(n, "para", 0, line);
+            continue;
+        }
+        cur.lines.push(line);
+        cur.end = n;
+    }
+    return blocks;
+}
+const blockText = (b) => normalise(b.lines.join(" "));
+function deletedLines(diff) {
+    const lines = new Set();
+    const replaced = new Set();
+    for (const m of diff.matchAll(/^@@ -(\d+)(?:,(\d+))? \+\d+(?:,(\d+))? @@/gm)) {
+        const start = Number(m[1]);
+        const count = m[2] === undefined ? 1 : Number(m[2]);
+        const added = m[3] === undefined ? 1 : Number(m[3]);
+        for (let k = 0; k < count; k++) {
+            lines.add(start + k);
+            if (added > 0)
+                replaced.add(start + k);
+        }
+    }
+    return { lines, replaced };
+}
+const hasLetter = (s) => /\p{L}/u.test(s);
+// The deleted blocks of one watched file. A heading or a table header row whose whole section or table
+// is deleted, with nothing added in its place, comes back with a `guard`: the normalised text of the section's or table's other lettered
+// blocks. It is exempt only when none of those reappears at HEAD (the check resolves that against the
+// head blocks): content that reappears means the section or table was rewritten, not removed, so its
+// heading or header change needs a row like any other edit.
+function deletedBlocks(file, baseText, deletions) {
+    const blocks = parseBlocks(file, baseText);
+    const deleted = deletions.lines;
+    const pure = (b) => {
+        for (let n = b.start; n <= b.end; n++)
+            if (deletions.replaced.has(n))
+                return false;
+        return true;
+    };
+    const touched = (b) => {
+        for (let n = b.start; n <= b.end; n++)
+            if (deleted.has(n))
+                return true;
+        return false;
+    };
+    const whole = (b) => {
+        for (let n = b.start; n <= b.end; n++)
+            if (!deleted.has(n))
+                return false;
+        return true;
+    };
+    const delText = (b) => {
+        const parts = [];
+        for (let n = b.start; n <= b.end; n++)
+            if (deleted.has(n))
+                parts.push(b.lines[n - b.start] ?? "");
+        return parts.join(" ");
+    };
+    // The guard for a structural block whose group (`members`, excluding the block itself) is wholly
+    // deleted by pure-deletion hunks and holds at least one lettered block; null when it is not exempt.
+    // A hunk that adds lines where the heading or header stood is a rewrite, and a rewrite needs a row.
+    const guardOf = (self, members) => {
+        if (!whole(self) || !members.every(whole))
+            return null;
+        if (!pure(self) || !members.every(pure))
+            return null;
+        const lettered = members.filter((m) => hasLetter(m.lines.join(" ")));
+        return lettered.length === 0 ? null : lettered.map(blockText);
+    };
+    const out = [];
+    for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
+        if (b === undefined || !touched(b))
+            continue;
+        const text = delText(b);
+        if (!hasLetter(text))
+            continue; // letterless
+        let guard = null;
+        if (b.kind === "table") {
+            const t = (b.lines[0] ?? "").trim();
+            if (SEPARATOR.test(t))
+                continue; // separator row
+            // A header row: the row directly above a separator. Its table is the contiguous run of rows after it.
+            const next = blocks[i + 1];
+            if (next !== undefined && next.kind === "table" && next.start === b.end + 1 && SEPARATOR.test((next.lines[0] ?? "").trim())) {
+                const rows = [];
+                for (let j = i + 1; j < blocks.length; j++) {
+                    const r = blocks[j];
+                    if (r === undefined || r.kind !== "table" || r.start !== (blocks[j - 1]?.end ?? -2) + 1)
+                        break;
+                    rows.push(r);
+                }
+                guard = guardOf(b, rows);
+            }
+        }
+        if (b.kind === "heading") {
+            // Its section runs to the next heading of the same or higher level.
+            const section = [];
+            for (let j = i + 1; j < blocks.length; j++) {
+                const r = blocks[j];
+                if (r === undefined || (r.kind === "heading" && r.level <= b.level))
+                    break;
+                section.push(r);
+            }
+            guard = guardOf(b, section);
+        }
+        let first = b.start;
+        while (first <= b.end && !deleted.has(first))
+            first++;
+        out.push({ file, base_line: first, text, norm: normalise(text), guard });
+    }
+    return out;
+}
+// Drop the structural blocks whose guard holds: none of the guarded text reappears in a head block.
+function resolveExempt(blocks, headBlocks) {
+    const moved = (t) => headBlocks.some((h) => h.includes(t));
+    return blocks.filter((b) => b.guard === null || b.guard.some(moved));
+}
+// ---------------------------------------------------------------------------
+// Inventory parsing.
+// ---------------------------------------------------------------------------
+// Split a table row on unescaped pipes, unescaping `\|` in each cell.
+function splitRow(line) {
+    let t = line.trim();
+    if (t.startsWith("|"))
+        t = t.slice(1);
+    if (t.endsWith("|") && !t.endsWith("\\|"))
+        t = t.slice(0, -1);
+    const cells = [];
+    let cur = "";
+    for (let i = 0; i < t.length; i++) {
+        const c = t[i];
+        if (c === "\\" && t[i + 1] === "|") {
+            cur += "|";
+            i++;
+            continue;
+        }
+        if (c === "|") {
+            cells.push(cur.trim());
+            cur = "";
+            continue;
+        }
+        cur += c;
+    }
+    cells.push(cur.trim());
+    return cells;
+}
+// The first code span's content (CommonMark backtick runs), or null.
+function firstCodeSpan(s) {
+    let i = 0;
+    while (i < s.length) {
+        if (s[i] !== "`") {
+            i++;
+            continue;
+        }
+        let j = i;
+        while (j < s.length && s[j] === "`")
+            j++;
+        const run = j - i;
+        let k = j;
+        while (k < s.length) {
+            if (s[k] !== "`") {
+                k++;
+                continue;
+            }
+            let e = k;
+            while (e < s.length && s[e] === "`")
+                e++;
+            if (e - k === run) {
+                let content = s.slice(j, k);
+                if (content.length >= 2 && content.startsWith(" ") && content.endsWith(" ") && content.trim() !== "")
+                    content = content.slice(1, -1);
+                return content;
+            }
+            k = e;
+        }
+        i = j;
+    }
+    return null;
+}
+// `test/<path>.test.mjs` entries, each optionally followed by `: "<name>"`, separated by `;` or `,`.
+function parseTests(cell) {
+    const tests = [];
+    const errors = [];
+    const s = cell.replace(/`/g, "").trim();
+    if (s === "" || s === "—" || s === "-")
+        return { tests, errors };
+    let i = 0;
+    while (i < s.length) {
+        while (i < s.length && /[\s;,]/.test(s[i] ?? ""))
+            i++;
+        if (i >= s.length)
+            break;
+        let p = "";
+        while (i < s.length && !/[\s:;,]/.test(s[i] ?? ""))
+            p += s[i++];
+        let name = null;
+        let k = i;
+        while (k < s.length && /\s/.test(s[k] ?? ""))
+            k++;
+        if (s[k] === ":") {
+            k++;
+            while (k < s.length && /\s/.test(s[k] ?? ""))
+                k++;
+            if (s[k] === "\"") {
+                const close = s.indexOf("\"", k + 1);
+                if (close === -1) {
+                    errors.push(`covering test ${p}: unterminated test name`);
+                    return { tests, errors };
+                }
+                name = s.slice(k + 1, close);
+                i = close + 1;
+            }
+            else {
+                errors.push(`covering test ${p}: a name after ":" must be in double quotes`);
+                return { tests, errors };
+            }
+        }
+        if (p === "") {
+            errors.push("covering test cell has an entry with no path");
+            break;
+        }
+        tests.push({ file: p, name });
+    }
+    return { tests, errors };
+}
+function parseDisposition(cell) {
+    const s = normalise(cell);
+    if (s === "kept")
+        return { disposition: "kept", reason: null, error: null };
+    const m = /^(changed|dropped):(.*)$/s.exec(s);
+    if (m && (m[1] === "changed" || m[1] === "dropped")) {
+        const reason = (m[2] ?? "").trim();
+        if (reason === "")
+            return { disposition: m[1], reason: null, error: `${m[1]} row gives no reason` };
+        return { disposition: m[1], reason, error: null };
+    }
+    return { disposition: "invalid", reason: null, error: "disposition is not kept, changed: <reason> or dropped: <reason>" };
+}
+// Every inventory table in every `## Rule inventory` section of one spec.
+function parseInventory(spec, text) {
+    const lines = text.split("\n");
+    const rows = [];
+    const errors = [];
+    let hasSection = false;
+    let inSection = false;
+    let fence = null;
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        const t = line.trim();
+        if (fence !== null) {
+            const m = FENCE_OPEN.exec(t);
+            if (m && m[1] !== undefined && m[1][0] === fence.ch && m[1].length >= fence.len && t.slice(m[1].length).trim() === "")
+                fence = null;
+            i++;
+            continue;
+        }
+        const f = FENCE_OPEN.exec(t);
+        if (f && f[1] !== undefined) {
+            fence = { ch: f[1][0] ?? "`", len: f[1].length };
+            i++;
+            continue;
+        }
+        if (line.startsWith("## ")) {
+            inSection = line.startsWith("## Rule inventory");
+            if (inSection)
+                hasSection = true;
+            i++;
+            continue;
+        }
+        if (!inSection || !t.startsWith("|")) {
+            i++;
+            continue;
+        }
+        // A table: consecutive lines starting `|`.
+        const start = i;
+        const table = [];
+        while (i < lines.length && (lines[i] ?? "").trim().startsWith("|"))
+            table.push(lines[i++] ?? "");
+        const header = splitRow(table[0] ?? "").map((c) => normalise(c).toLowerCase());
+        // Columns are found by header name, case-insensitively; a qualifier after the name ("Prose rule (§0a)") is allowed.
+        const col = (name) => header.findIndex((h) => h === name || h.startsWith(`${name} `) || h.startsWith(`${name}(`) || h === `${name}s`);
+        const ruleCol = col("prose rule");
+        const dispCol = col("disposition");
+        const testCol = col("covering test");
+        if (ruleCol === -1 && dispCol === -1)
+            continue; // a free table
+        if (ruleCol === -1 || dispCol === -1) {
+            errors.push({ spec, line: start + 1, reason: `inventory table header needs both a Prose rule and a Disposition column` });
+            continue;
+        }
+        let hasKept = false;
+        for (let r = 1; r < table.length; r++) {
+            const raw = table[r] ?? "";
+            if (SEPARATOR.test(raw.trim()))
+                continue;
+            const cells = splitRow(raw);
+            const lineNo = start + r + 1;
+            const span = firstCodeSpan(cells[ruleCol] ?? "");
+            const anchor = span === null ? null : normalise(span);
+            const disp = parseDisposition(cells[dispCol] ?? "");
+            const parsedTests = testCol === -1 ? { tests: [], errors: [] } : parseTests(cells[testCol] ?? "");
+            const row = { spec, line: lineNo, anchor: anchor === "" ? null : anchor, tests: parsedTests.tests, disposition: disp.disposition, reason: disp.reason };
+            rows.push(row);
+            if (disp.disposition === "kept")
+                hasKept = true;
+            if (disp.error !== null)
+                errors.push({ spec, line: lineNo, reason: disp.error });
+            for (const e of parsedTests.errors)
+                errors.push({ spec, line: lineNo, reason: e });
+        }
+        if (hasKept && testCol === -1)
+            errors.push({ spec, line: start + 1, reason: "a table with a kept row needs a Covering test column" });
+    }
+    return { hasSection, rows, errors };
+}
+// A valid anchor covers a deleted block when it is ≥ 20 characters and inside the block's deleted text,
+// or when it equals that whole text. A short anchor never covers a longer block that contains it.
+function covers(anchor, b) {
+    return (codePoints(anchor) >= MIN_ANCHOR && b.norm.includes(anchor)) || anchor === b.norm;
+}
+// ---------------------------------------------------------------------------
+// Git.
+// ---------------------------------------------------------------------------
+function defaultGit(repo) {
+    return (args, input) => {
+        const r = spawnSync("git", ["-c", "core.quotePath=false", ...args], {
+            cwd: repo, input, maxBuffer: 256 * 1024 * 1024, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+        });
+        return {
+            status: r.status === null ? 128 : r.status,
+            stdout: Buffer.isBuffer(r.stdout) ? r.stdout : Buffer.alloc(0),
+            stderr: Buffer.isBuffer(r.stderr) ? r.stderr.toString("utf8") : String(r.stderr ?? ""),
+        };
+    };
+}
+function must(git, args, what, input) {
+    const r = git(args, input);
+    if (r.status !== 0)
+        throw new CheckError(`git failed (${what}): ${clean(r.stderr.trim().split("\n")[0] ?? "", MAX_VALUE)}`);
+    return r.stdout;
+}
+const UTF8 = new TextDecoder("utf-8", { fatal: true });
+// `git diff -z --name-status` output. A path that is not valid UTF-8 is decoded only to test its prefix.
+function parseNameStatus(buf) {
+    const parts = [];
+    let s = 0;
+    for (let i = 0; i < buf.length; i++)
+        if (buf[i] === 0) {
+            parts.push(buf.subarray(s, i));
+            s = i + 1;
+        }
+    if (s < buf.length)
+        parts.push(buf.subarray(s));
+    const out = [];
+    for (let i = 0; i + 1 < parts.length; i += 2) {
+        const status = (parts[i] ?? Buffer.alloc(0)).toString("latin1");
+        const raw = parts[i + 1] ?? Buffer.alloc(0);
+        let p;
+        try {
+            p = UTF8.decode(raw);
+        }
+        catch {
+            const latin = raw.toString("latin1");
+            if (latin.startsWith(SKILLS_PREFIX))
+                throw new CheckError("a changed path under plugin/skills/ is not valid UTF-8");
+            p = latin;
+            if (latin.startsWith(ANCHORS_PREFIX)) {
+                out.push({ status, path: latin });
+                continue;
+            }
+            out.push({ status: "X", path: latin });
+            continue;
+        }
+        out.push({ status, path: p });
+    }
+    return out;
+}
+// The tree entry for <rev>:<path> from `git ls-tree -z`, or null when the path is absent there.
+// A failing git call is an error (exit 2), never read as absence.
+function treeEntry(git, rev, p) {
+    const out = must(git, ["--literal-pathspecs", "ls-tree", "-z", rev, "--", p], `ls-tree ${clean(p)}`).toString("utf8");
+    for (const rec of out.split("\0")) {
+        const m = /^\d+ (\S+) ([0-9a-f]+)\t([\s\S]*)$/.exec(rec);
+        if (m && m[3] === p && m[1] !== undefined && m[2] !== undefined)
+            return { type: m[1], id: m[2] };
+    }
+    return null;
+}
+// Read many blobs in one `git cat-file --batch`. A missing object throws.
+function readBlobs(git, revs) {
+    if (revs.length === 0)
+        return [];
+    for (const r of revs)
+        if (r.includes("\n"))
+            throw new CheckError("a path contains a newline");
+    const out = must(git, ["cat-file", "--batch"], "cat-file --batch", Buffer.from(revs.map((r) => `${r}\n`).join(""), "utf8"));
+    const texts = [];
+    let pos = 0;
+    for (const rev of revs) {
+        const nl = out.indexOf(0x0a, pos);
+        if (nl === -1)
+            throw new CheckError("git cat-file --batch output truncated");
+        const header = out.subarray(pos, nl).toString("utf8");
+        const m = /^[0-9a-f]+ (\S+) (\d+)$/.exec(header);
+        if (!m || m[1] !== "blob")
+            throw new CheckError(`cannot read ${clean(rev)}`);
+        const size = Number(m[2]);
+        texts.push(out.subarray(nl + 1, nl + 1 + size).toString("utf8"));
+        pos = nl + 1 + size + 1;
+    }
+    return texts;
+}
+// The configured spec docs path as a repo-relative posix prefix: `./records/specs/` and `records//specs`
+// both become `records/specs`. An absolute path or one that leaves the repo is a config error (exit 2).
+function specDocsDir(raw) {
+    const p = raw.trim().replace(/\\/g, "/");
+    if (p === "" || p.startsWith("/") || /^[A-Za-z]:/.test(p))
+        throw new CheckError(`tracking.spec_docs_path ${clean(raw)} must be a repo-relative path`);
+    const n = path.posix.normalize(p).replace(/^(\.\/)+/, "").replace(/\/+$/, "");
+    if (n === "" || n === "." || n === ".." || n.startsWith("../"))
+        throw new CheckError(`tracking.spec_docs_path ${clean(raw)} must be a directory inside the repo`);
+    return n;
+}
+function emptyResult() {
+    return {
+        result: "pass", skipped_reason: null, footprint_without_spec: false, base: "", specs: [],
+        blocks_deleted: 0, covered_moved: 0, covered_by_row: 0, row_covered: [], uncovered: [], row_errors: [], warnings: [],
+    };
+}
+// Run the check. Throws CheckError for every exit-2 condition.
+function check(opts) {
+    const git = opts.git ?? defaultGit(opts.repo);
+    const res = emptyResult();
+    // 1. Resolve the base.
+    let base;
+    if (opts.base !== null) {
+        if (!PLAIN_REF.test(opts.base) || opts.base.startsWith("-"))
+            throw new CheckError(`--base ${clean(opts.base)} is not a plain ref`);
+        const r = git(["rev-parse", "--verify", "--quiet", `${opts.base}^{commit}`]);
+        if (r.status !== 0)
+            throw new CheckError(`--base ${clean(opts.base)} names no commit`);
+        base = r.stdout.toString("utf8").trim();
+    }
+    else {
+        // for-each-ref exits 0 with no output when origin/HEAD is absent, so only a real absence skips;
+        // a failing git call is an error, never a no-base skip.
+        const head = must(git, ["for-each-ref", "--format=%(refname)", "refs/remotes/origin/HEAD"], "for-each-ref origin/HEAD").toString("utf8").trim();
+        if (head === "") {
+            res.result = "skipped";
+            res.skipped_reason = "no-base";
+            return { result: res, notice: false };
+        }
+        base = must(git, ["merge-base", "refs/remotes/origin/HEAD", "HEAD"], "merge-base refs/remotes/origin/HEAD HEAD").toString("utf8").trim();
+    }
+    if (!/^[0-9a-f]{40,64}$/.test(base))
+        throw new CheckError("the base did not resolve to a commit");
+    res.base = base;
+    must(git, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], "rev-parse HEAD");
+    // 2. Changed paths.
+    const changed = parseNameStatus(must(git, ["diff", "-z", "--no-renames", "--no-ext-diff", "--name-status", base, "HEAD"], "diff --name-status"));
+    let specDir;
+    try {
+        // A failed main-checkout probe in the shared lookup throws MainWorktreeProbeError (FAFF-1463).
+        const [cfg] = loadConfig(opts.repo);
+        specDir = specDocsDir(String(resolveSpecDocsPath(opts.repo, cfg, false)));
+    }
+    catch (e) {
+        if (e instanceof CheckError || isProbeFailure(e))
+            throw e;
+        throw new CheckError(`config unreadable: ${clean(e instanceof Error ? e.message : String(e))}`);
+    }
+    const watched = changed.filter((c) => isWatched(c.path));
+    const specs = changed.filter((c) => c.status === "A" && c.path.startsWith(`${specDir}/`) && c.path.endsWith("-design.md")).map((c) => c.path).sort();
+    const footprint = changed.some((c) => (c.status === "A" || c.status === "M" || c.status === "T") && c.path.startsWith(ANCHORS_PREFIX));
+    res.specs = specs;
+    // 3. Deleted blocks (structural exemptions still pending their guard).
+    const candidates = [];
+    const withBase = watched.filter((c) => c.status !== "A");
+    const baseTexts = readBlobs(git, withBase.map((c) => `${base}:${c.path}`));
+    withBase.forEach((c, k) => {
+        // --text: a binary or -diff attribute, or a NUL byte, must never hide a deletion behind "Binary files differ".
+        const diff = must(git, ["--literal-pathspecs", "diff", "-U0", "--text", "--no-renames", "--no-ext-diff", "--no-color", "--no-textconv", base, "HEAD", "--", c.path], `diff ${c.path}`).toString("utf8");
+        if (/^Binary files /m.test(diff) || (diff.trim() !== "" && !/^@@ /m.test(diff))) {
+            // No text hunk deletes nothing only when the content is unchanged (a mode-only change) or the
+            // base file was empty. Any other content change with no hunk is an error, never a skip.
+            const before = treeEntry(git, base, c.path);
+            const after = treeEntry(git, "HEAD", c.path);
+            if ((before !== null && after !== null && before.id === after.id) || (baseTexts[k] ?? "") === "")
+                return;
+            throw new CheckError(`git reported no text hunks for changed skill prose ${clean(c.path)}`);
+        }
+        candidates.push(...deletedBlocks(c.path, baseTexts[k] ?? "", deletedLines(diff)));
+    });
+    if (candidates.length === 0) {
+        res.result = "skipped";
+        res.skipped_reason = "no-prose-deleted";
+        return { result: res, notice: false };
+    }
+    // 4. Head blocks of every watched file at HEAD; resolve the structural exemptions against them.
+    const tree = must(git, ["ls-tree", "-r", "-z", "--name-only", "HEAD", "--", SKILLS_PREFIX], "ls-tree HEAD");
+    const headPaths = tree.toString("utf8").split("\0").filter((p) => p !== "" && isWatched(p));
+    const headTexts = readBlobs(git, headPaths.map((p) => `HEAD:${p}`));
+    const headBlocks = [];
+    headPaths.forEach((p, k) => { for (const b of parseBlocks(p, headTexts[k] ?? ""))
+        headBlocks.push(blockText(b)); });
+    const deleted = resolveExempt(candidates, headBlocks);
+    res.blocks_deleted = deleted.length;
+    // 5–6. Scope.
+    if (deleted.length === 0) {
+        res.result = "skipped";
+        res.skipped_reason = "no-prose-deleted";
+        return { result: res, notice: false };
+    }
+    if (specs.length === 0 && footprint) {
+        res.result = "fail";
+        res.footprint_without_spec = true;
+        return { result: res, notice: false };
+    }
+    if (specs.length === 0) {
+        res.result = "skipped";
+        res.skipped_reason = "no-spec-committed";
+        return { result: res, notice: true };
+    }
+    // 7. Rows.
+    const rows = [];
+    let anySection = false;
+    for (const spec of specs) {
+        const size = Number(must(git, ["cat-file", "-s", `HEAD:${spec}`], `cat-file -s ${spec}`).toString("utf8").trim());
+        if (!Number.isFinite(size) || size > MAX_SPEC_BYTES)
+            throw new CheckError(`committed spec ${clean(spec)} is larger than 1 MiB`);
+        const text = readBlobs(git, [`HEAD:${spec}`])[0] ?? "";
+        const parsed = parseInventory(spec, text);
+        if (parsed.hasSection)
+            anySection = true;
+        rows.push(...parsed.rows);
+        res.row_errors.push(...parsed.errors);
+    }
+    // 8. Validate rows.
+    const valid = [];
+    const rowErrorsAt = new Set(res.row_errors.map((e) => `${e.spec}\0${e.line}`));
+    for (const row of rows) {
+        const errs = [];
+        if (row.anchor === null)
+            errs.push("Prose rule cell has no code-span anchor");
+        else if (codePoints(row.anchor) < MIN_ANCHOR && !deleted.some((b) => b.norm === row.anchor))
+            errs.push("anchor shorter than 20 characters");
+        if (row.disposition === "kept" && row.tests.length === 0)
+            errs.push("kept row names no covering test");
+        for (const t of row.tests) {
+            if (!TEST_PATH.test(t.file) || t.file.split("/").includes("..")) {
+                errs.push(`covering test ${t.file} is not a test/<path>.test.mjs path`);
+                continue;
+            }
+            if (treeEntry(git, "HEAD", t.file)?.type !== "blob") {
+                errs.push(`covering test ${t.file} does not exist`);
+                continue;
+            }
+            if (t.name !== null) {
+                const body = readBlobs(git, [`HEAD:${t.file}`])[0] ?? "";
+                if (!body.includes(t.name))
+                    errs.push(`covering test ${t.file} has no test named "${t.name}"`);
+            }
+        }
+        for (const e of errs)
+            res.row_errors.push({ spec: row.spec, line: row.line, reason: e });
+        if (errs.length === 0 && !rowErrorsAt.has(`${row.spec}\0${row.line}`))
+            valid.push(row);
+    }
+    // 9. Classify each deleted block.
+    for (const b of deleted) {
+        if (headBlocks.some((h) => h.includes(b.norm))) {
+            res.covered_moved++;
+            continue;
+        }
+        const row = valid.find((r) => r.anchor !== null && covers(r.anchor, b));
+        if (row !== undefined) {
+            res.covered_by_row++;
+            res.row_covered.push({ file: b.file, base_line: b.base_line, disposition: row.disposition, reason: row.reason, spec: row.spec, spec_line: row.line });
+            continue;
+        }
+        res.uncovered.push({ file: b.file, base_line: b.base_line, excerpt: clean(b.text.trim(), EXCERPT) });
+    }
+    // 10. Rows that match nothing.
+    for (const row of valid) {
+        if (row.anchor !== null && !deleted.some((b) => covers(row.anchor ?? "", b))) {
+            res.warnings.push(`${row.spec}:${row.line}: anchor matches no deleted prose`);
+        }
+    }
+    // 11. No inventory at all while something is uncovered.
+    if (res.uncovered.length > 0 && !anySection) {
+        for (const spec of specs)
+            res.row_errors.push({ spec, line: 1, reason: "no ## Rule inventory section" });
+    }
+    res.result = res.uncovered.length > 0 || res.row_errors.length > 0 ? "fail" : "pass";
+    return { result: res, notice: false };
+}
+// Every spec-derived string in the result, stripped of control characters and capped.
+function cleanResult(r) {
+    return {
+        ...r,
+        specs: r.specs.map((s) => clean(s)),
+        row_covered: r.row_covered.map((c) => ({ ...c, file: clean(c.file), disposition: clean(c.disposition), reason: c.reason === null ? null : clean(c.reason), spec: clean(c.spec) })),
+        uncovered: r.uncovered.map((u) => ({ ...u, file: clean(u.file), excerpt: clean(u.excerpt, EXCERPT) })),
+        row_errors: r.row_errors.map((e) => ({ ...e, spec: clean(e.spec), reason: clean(e.reason) })),
+        warnings: r.warnings.map((w) => clean(w)),
+    };
+}
+const DISPOSITION_ORDER = { dropped: 0, changed: 1, kept: 2 };
+function renderSummary(r) {
+    const out = ["", "### rule-inventory", ""];
+    if (r.result === "skipped") {
+        out.push(`rule-inventory: skipped (${r.skipped_reason ?? ""})`, "");
+        return out.join("\n");
+    }
+    out.push(`rule-inventory: ${r.result} — ${r.blocks_deleted} deleted block(s), ${r.covered_moved} moved, ${r.covered_by_row} covered by a row, ${r.uncovered.length} uncovered`, "");
+    const rows = [...r.row_covered].sort((a, b) => (DISPOSITION_ORDER[a.disposition] ?? 3) - (DISPOSITION_ORDER[b.disposition] ?? 3));
+    if (rows.length > 0) {
+        out.push("| Disposition | Reason | Deleted block | Inventory row |", "|---|---|---|---|");
+        for (const c of rows) {
+            out.push(`| ${mdEscape(c.disposition)} | ${c.reason === null ? "" : mdEscape(c.reason)} | ${mdEscape(c.file)}:${c.base_line} | ${mdEscape(c.spec)}:${c.spec_line} |`);
+        }
+        out.push("");
+    }
+    return out.join("\n");
+}
+function renderText(r) {
+    const out = [];
+    for (const u of r.uncovered)
+        out.push(`rule-inventory: uncovered ${u.file}:${u.base_line}: ${u.excerpt} (format: ${FORMAT_DOC})`);
+    for (const e of r.row_errors)
+        out.push(`rule-inventory: row-error ${e.spec}:${e.line}: ${e.reason}`);
+    for (const w of r.warnings)
+        out.push(`rule-inventory: warning ${w}`);
+    if (r.footprint_without_spec)
+        out.push(`rule-inventory: agent footprint (.faff/anchors/) with no committed spec; deleted skill prose needs a spec with a Rule inventory (format: ${FORMAT_DOC})`);
+    const counts = r.result === "skipped"
+        ? `${r.skipped_reason ?? ""}`
+        : `${r.blocks_deleted} deleted, ${r.covered_moved} moved, ${r.covered_by_row} by row, ${r.uncovered.length} uncovered, ${r.row_errors.length} row error(s)`;
+    out.push(`rule-inventory: ${r.result} (${counts})`);
+    return `${out.join("\n")}\n`;
+}
+// ---------------------------------------------------------------------------
+// CLI.
+// ---------------------------------------------------------------------------
+const CHECK_SPEC = { flags: { "--base": { arity: 1 }, "--json": { arity: 0 }, "--summary": { arity: 1 } } };
+const USAGE = "rule-inventory: usage: faff rule-inventory check [--base REF] [--json] [--summary FILE]\n" +
+    "rule-inventory: --base REF compares REF's tree with HEAD's; pass a merge-base (without it, the merge-base with origin/HEAD).";
+function fail2(msg) {
+    process.stderr.write(`rule-inventory: ${msg}\n${USAGE}\n`);
+    return 2;
+}
+function cmdCheck(args) {
+    const { values, positionals, errors } = parseArgs(args, CHECK_SPEC);
+    if (errors.length)
+        return fail2(clean(String(errors[0]?.detail ?? "bad arguments")));
+    if (positionals.length)
+        return fail2(`unexpected argument ${clean(String(positionals[0]))}`);
+    const base = typeof values["--base"] === "string" ? values["--base"] : null;
+    const summary = typeof values["--summary"] === "string" ? values["--summary"] : null;
+    let repo;
+    try {
+        const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" });
+        if (r.status !== 0)
+            return fail2("not inside a git repository");
+        repo = String(r.stdout).trim();
+    }
+    catch {
+        return fail2("git is not runnable");
+    }
+    let outcome;
+    try {
+        outcome = check({ repo, base });
+    }
+    catch (e) {
+        if (e instanceof CheckError)
+            return fail2(e.message);
+        if (isProbeFailure(e))
+            throw e;
+        return fail2(`unexpected error: ${clean(e instanceof Error ? e.message : String(e))}`);
+    }
+    const result = cleanResult(outcome.result);
+    if (summary !== null) {
+        try {
+            fs.appendFileSync(path.resolve(summary), renderSummary(result));
+        }
+        catch (e) {
+            return fail2(`cannot write --summary file: ${clean(e instanceof Error ? e.message : String(e))}`);
+        }
+    }
+    if (values["--json"] === true)
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    else {
+        if (outcome.notice)
+            process.stdout.write(`${SKIP_NOTICE}\n`);
+        process.stdout.write(renderText(result));
+    }
+    return result.result === "fail" ? 1 : 0;
+}
+function cmdRuleInventory(args) {
+    const sub = args[0];
+    if (sub === "check")
+        return cmdCheck(args.slice(1));
+    return fail2(sub === undefined ? "missing subcommand" : `unknown subcommand ${clean(sub)}`);
+}
+module.exports = {
+    normalise, clean, mdEscape, isWatched, specDocsDir, resolveExempt, parseBlocks, deletedLines, deletedBlocks, splitRow, firstCodeSpan,
+    parseTests, parseDisposition, parseInventory, covers, parseNameStatus, check, renderText, renderSummary,
+    cmdRuleInventory, CheckError, MIN_ANCHOR, SKIP_NOTICE,
+};
diff --git a/plugin/skills/faff/bin/lib/rule-inventory.ts b/plugin/skills/faff/bin/lib/rule-inventory.ts
new file mode 100644
index 000000000..4df90b23d
--- /dev/null
+++ b/plugin/skills/faff/bin/lib/rule-inventory.ts
@@ -0,0 +1,760 @@
+"use strict";
+// ===========================================================================
+// === region:factory — rule-inventory — FAFF-1428: deleted skill prose must map to a rule-inventory row ===
+//
+// `faff rule-inventory check [--base REF]` compares HEAD's tree with the base's. Every block of skill
+// prose (prose-size's `isCovered` set) the diff deletes must either reappear verbatim inside one block of
+// skill prose at HEAD (moved), or be quoted by a row of a `## Rule inventory` table in a spec the diff adds
+// under the spec docs path. Exit 0 pass or skipped, 1 fail, 2 usage / git / read error (never a pass).
+// The check proves coverage, never correctness: whether a row's claim is true is review's job.
+// Format: docs/reference/skill-authoring.md#rule-inventory.
+// ===========================================================================
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { parseArgs } = require("./argv");
+const { isCovered } = require("./prose-size");
+const { loadConfig, resolveSpecDocsPath } = require("./config-core");
+
+export type Status = "A" | "M" | "D" | "T" | "U" | "X";
+export type ChangedPath = { status: string; path: string };
+
+export type Block = {
+  file: string;
+  start: number;          // 1-based base line of the block's first line
+  end: number;            // 1-based base line of its last line
+  kind: "para" | "list" | "heading" | "table" | "fence";
+  level: number;          // heading level, 0 otherwise
+  lines: string[];
+};
+
+export type DeletedBlock = { file: string; base_line: number; text: string; norm: string; guard: string[] | null };
+
+export type TestRef = { file: string; name: string | null };
+
+export type InventoryRow = {
+  spec: string;
+  line: number;
+  anchor: string | null;
+  tests: TestRef[];
+  disposition: "kept" | "changed" | "dropped" | "invalid";
+  reason: string | null;
+};
+
+export type RowError = { spec: string; line: number; reason: string };
+
+export type CheckResult = {
+  result: "pass" | "fail" | "skipped";
+  skipped_reason: "no-prose-deleted" | "no-spec-committed" | "no-base" | null;
+  footprint_without_spec: boolean;
+  base: string;
+  specs: string[];
+  blocks_deleted: number;
+  covered_moved: number;
+  covered_by_row: number;
+  row_covered: { file: string; base_line: number; disposition: string; reason: string | null; spec: string; spec_line: number }[];
+  uncovered: { file: string; base_line: number; excerpt: string }[];
+  row_errors: RowError[];
+  warnings: string[];
+};
+
+export type GitRun = (args: string[], input?: Buffer) => { status: number; stdout: Buffer; stderr: string };
+
+class CheckError extends Error {}
+
+// FAFF-1463: a failed main-checkout probe passes through to the dispatch arm, which names git's message.
+function isProbeFailure(e: unknown): boolean {
+  return e instanceof Error && e.message === "git-probe-failed";
+}
+
+const SKILLS_PREFIX = "plugin/skills/";
+const ANCHORS_PREFIX = ".faff/anchors/";
+const FORMAT_DOC = "docs/reference/skill-authoring.md#rule-inventory";
+const MIN_ANCHOR = 20;
+const MAX_SPEC_BYTES = 1024 * 1024;
+const MAX_VALUE = 200;
+const EXCERPT = 120;
+const PLAIN_REF = /^[A-Za-z0-9._/-]+$/;
+const TEST_PATH = /^test\/[A-Za-z0-9._/-]+\.test\.mjs$/;
+const SKIP_NOTICE = "::notice::rule-inventory: skipped, no spec committed";
+
+// ---------------------------------------------------------------------------
+// Text helpers.
+// ---------------------------------------------------------------------------
+
+// Delete every `*` and backtick, collapse whitespace runs to one space, trim.
+function normalise(s: string): string {
+  return s.replace(/[*`]/g, "").replace(/\s+/g, " ").trim();
+}
+
+const codePoints = (s: string): number => Array.from(s).length;
+
+// Strip control characters (ESC and newlines included) and cap at `cap` characters.
+function clean(s: string, cap: number = MAX_VALUE): string {
+  // eslint-disable-next-line no-control-regex
+  const stripped = s.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ");
+  const cps = Array.from(stripped);
+  return cps.length > cap ? cps.slice(0, cap).join("") : stripped;
+}
+
+// Escape a spec-derived value for a markdown table cell on the rendered check page.
+function mdEscape(s: string): string {
+  return clean(s)
+    .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+    .replace(/[\\`*_[\]()!|#]/g, (c) => `\\${c}`);
+}
+
+const isWatched = (p: string): boolean => p.startsWith(SKILLS_PREFIX) && isCovered(p.slice(SKILLS_PREFIX.length));
+
+// ---------------------------------------------------------------------------
+// Block parsing (the authoring standard's markdown, not full CommonMark).
+// ---------------------------------------------------------------------------
+
+const FENCE_OPEN = /^(`{3,}|~{3,})/;
+const HEADING = /^(#{1,6})(\s|$)/;
+const LIST_ITEM = /^([-*+]|\d+\.)\s/;
+const SEPARATOR = /^\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?$/;
+
+function parseBlocks(file: string, text: string): Block[] {
+  const blocks: Block[] = [];
+  const lines = text.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  let cur: Block | null = null;
+  let fence: { ch: string; len: number } | null = null;
+  const open = (n: number, kind: Block["kind"], level: number, line: string): Block => {
+    const b: Block = { file, start: n, end: n, kind, level, lines: [line] };
+    blocks.push(b);
+    return b;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const n = i + 1;
+    const t = line.trim();
+    if (fence !== null && cur !== null) {
+      cur.lines.push(line);
+      cur.end = n;
+      const m = FENCE_OPEN.exec(t);
+      if (m && m[1] !== undefined && m[1][0] === fence.ch && m[1].length >= fence.len && t.slice(m[1].length).trim() === "") {
+        fence = null;
+        cur = null;
+      }
+      continue;
+    }
+    if (t === "") { cur = null; continue; }
+    const f = FENCE_OPEN.exec(t);
+    if (f && f[1] !== undefined) {
+      cur = open(n, "fence", 0, line);
+      fence = { ch: f[1][0] ?? "`", len: f[1].length };
+      continue;
+    }
+    const h = HEADING.exec(t);
+    if (h && h[1] !== undefined) { open(n, "heading", h[1].length, line); cur = null; continue; }
+    if (t.startsWith("|")) { open(n, "table", 0, line); cur = null; continue; }
+    if (LIST_ITEM.test(t)) { cur = open(n, "list", 0, line); continue; }
+    if (cur === null) { cur = open(n, "para", 0, line); continue; }
+    cur.lines.push(line);
+    cur.end = n;
+  }
+  return blocks;
+}
+
+const blockText = (b: Block): string => normalise(b.lines.join(" "));
+
+// Deleted base line numbers from `git diff -U0` hunk headers, and the subset deleted by a hunk that also
+// adds lines (a replacement, not a pure deletion).
+export type Deletions = { lines: Set<number>; replaced: Set<number> };
+
+function deletedLines(diff: string): Deletions {
+  const lines = new Set<number>();
+  const replaced = new Set<number>();
+  for (const m of diff.matchAll(/^@@ -(\d+)(?:,(\d+))? \+\d+(?:,(\d+))? @@/gm)) {
+    const start = Number(m[1]);
+    const count = m[2] === undefined ? 1 : Number(m[2]);
+    const added = m[3] === undefined ? 1 : Number(m[3]);
+    for (let k = 0; k < count; k++) {
+      lines.add(start + k);
+      if (added > 0) replaced.add(start + k);
+    }
+  }
+  return { lines, replaced };
+}
+
+const hasLetter = (s: string): boolean => /\p{L}/u.test(s);
+
+// The deleted blocks of one watched file. A heading or a table header row whose whole section or table
+// is deleted, with nothing added in its place, comes back with a `guard`: the normalised text of the section's or table's other lettered
+// blocks. It is exempt only when none of those reappears at HEAD (the check resolves that against the
+// head blocks): content that reappears means the section or table was rewritten, not removed, so its
+// heading or header change needs a row like any other edit.
+function deletedBlocks(file: string, baseText: string, deletions: Deletions): DeletedBlock[] {
+  const blocks = parseBlocks(file, baseText);
+  const deleted = deletions.lines;
+  const pure = (b: Block): boolean => {
+    for (let n = b.start; n <= b.end; n++) if (deletions.replaced.has(n)) return false;
+    return true;
+  };
+  const touched = (b: Block): boolean => {
+    for (let n = b.start; n <= b.end; n++) if (deleted.has(n)) return true;
+    return false;
+  };
+  const whole = (b: Block): boolean => {
+    for (let n = b.start; n <= b.end; n++) if (!deleted.has(n)) return false;
+    return true;
+  };
+  const delText = (b: Block): string => {
+    const parts: string[] = [];
+    for (let n = b.start; n <= b.end; n++) if (deleted.has(n)) parts.push(b.lines[n - b.start] ?? "");
+    return parts.join(" ");
+  };
+  // The guard for a structural block whose group (`members`, excluding the block itself) is wholly
+  // deleted by pure-deletion hunks and holds at least one lettered block; null when it is not exempt.
+  // A hunk that adds lines where the heading or header stood is a rewrite, and a rewrite needs a row.
+  const guardOf = (self: Block, members: Block[]): string[] | null => {
+    if (!whole(self) || !members.every(whole)) return null;
+    if (!pure(self) || !members.every(pure)) return null;
+    const lettered = members.filter((m) => hasLetter(m.lines.join(" ")));
+    return lettered.length === 0 ? null : lettered.map(blockText);
+  };
+  const out: DeletedBlock[] = [];
+  for (let i = 0; i < blocks.length; i++) {
+    const b = blocks[i];
+    if (b === undefined || !touched(b)) continue;
+    const text = delText(b);
+    if (!hasLetter(text)) continue;                              // letterless
+    let guard: string[] | null = null;
+    if (b.kind === "table") {
+      const t = (b.lines[0] ?? "").trim();
+      if (SEPARATOR.test(t)) continue;                           // separator row
+      // A header row: the row directly above a separator. Its table is the contiguous run of rows after it.
+      const next = blocks[i + 1];
+      if (next !== undefined && next.kind === "table" && next.start === b.end + 1 && SEPARATOR.test((next.lines[0] ?? "").trim())) {
+        const rows: Block[] = [];
+        for (let j = i + 1; j < blocks.length; j++) {
+          const r = blocks[j];
+          if (r === undefined || r.kind !== "table" || r.start !== (blocks[j - 1]?.end ?? -2) + 1) break;
+          rows.push(r);
+        }
+        guard = guardOf(b, rows);
+      }
+    }
+    if (b.kind === "heading") {
+      // Its section runs to the next heading of the same or higher level.
+      const section: Block[] = [];
+      for (let j = i + 1; j < blocks.length; j++) {
+        const r = blocks[j];
+        if (r === undefined || (r.kind === "heading" && r.level <= b.level)) break;
+        section.push(r);
+      }
+      guard = guardOf(b, section);
+    }
+    let first = b.start;
+    while (first <= b.end && !deleted.has(first)) first++;
+    out.push({ file, base_line: first, text, norm: normalise(text), guard });
+  }
+  return out;
+}
+
+// Drop the structural blocks whose guard holds: none of the guarded text reappears in a head block.
+function resolveExempt(blocks: DeletedBlock[], headBlocks: string[]): DeletedBlock[] {
+  const moved = (t: string): boolean => headBlocks.some((h) => h.includes(t));
+  return blocks.filter((b) => b.guard === null || b.guard.some(moved));
+}
+
+// ---------------------------------------------------------------------------
+// Inventory parsing.
+// ---------------------------------------------------------------------------
+
+// Split a table row on unescaped pipes, unescaping `\|` in each cell.
+function splitRow(line: string): string[] {
+  let t = line.trim();
+  if (t.startsWith("|")) t = t.slice(1);
+  if (t.endsWith("|") && !t.endsWith("\\|")) t = t.slice(0, -1);
+  const cells: string[] = [];
+  let cur = "";
+  for (let i = 0; i < t.length; i++) {
+    const c = t[i];
+    if (c === "\\" && t[i + 1] === "|") { cur += "|"; i++; continue; }
+    if (c === "|") { cells.push(cur.trim()); cur = ""; continue; }
+    cur += c;
+  }
+  cells.push(cur.trim());
+  return cells;
+}
+
+// The first code span's content (CommonMark backtick runs), or null.
+function firstCodeSpan(s: string): string | null {
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] !== "`") { i++; continue; }
+    let j = i;
+    while (j < s.length && s[j] === "`") j++;
+    const run = j - i;
+    let k = j;
+    while (k < s.length) {
+      if (s[k] !== "`") { k++; continue; }
+      let e = k;
+      while (e < s.length && s[e] === "`") e++;
+      if (e - k === run) {
+        let content = s.slice(j, k);
+        if (content.length >= 2 && content.startsWith(" ") && content.endsWith(" ") && content.trim() !== "") content = content.slice(1, -1);
+        return content;
+      }
+      k = e;
+    }
+    i = j;
+  }
+  return null;
+}
+
+// `test/<path>.test.mjs` entries, each optionally followed by `: "<name>"`, separated by `;` or `,`.
+function parseTests(cell: string): { tests: TestRef[]; errors: string[] } {
+  const tests: TestRef[] = [];
+  const errors: string[] = [];
+  const s = cell.replace(/`/g, "").trim();
+  if (s === "" || s === "—" || s === "-") return { tests, errors };
+  let i = 0;
+  while (i < s.length) {
+    while (i < s.length && /[\s;,]/.test(s[i] ?? "")) i++;
+    if (i >= s.length) break;
+    let p = "";
+    while (i < s.length && !/[\s:;,]/.test(s[i] ?? "")) p += s[i++];
+    let name: string | null = null;
+    let k = i;
+    while (k < s.length && /\s/.test(s[k] ?? "")) k++;
+    if (s[k] === ":") {
+      k++;
+      while (k < s.length && /\s/.test(s[k] ?? "")) k++;
+      if (s[k] === "\"") {
+        const close = s.indexOf("\"", k + 1);
+        if (close === -1) { errors.push(`covering test ${p}: unterminated test name`); return { tests, errors }; }
+        name = s.slice(k + 1, close);
+        i = close + 1;
+      } else {
+        errors.push(`covering test ${p}: a name after ":" must be in double quotes`);
+        return { tests, errors };
+      }
+    }
+    if (p === "") { errors.push("covering test cell has an entry with no path"); break; }
+    tests.push({ file: p, name });
+  }
+  return { tests, errors };
+}
+
+function parseDisposition(cell: string): { disposition: InventoryRow["disposition"]; reason: string | null; error: string | null } {
+  const s = normalise(cell);
+  if (s === "kept") return { disposition: "kept", reason: null, error: null };
+  const m = /^(changed|dropped):(.*)$/s.exec(s);
+  if (m && (m[1] === "changed" || m[1] === "dropped")) {
+    const reason = (m[2] ?? "").trim();
+    if (reason === "") return { disposition: m[1], reason: null, error: `${m[1]} row gives no reason` };
+    return { disposition: m[1], reason, error: null };
+  }
+  return { disposition: "invalid", reason: null, error: "disposition is not kept, changed: <reason> or dropped: <reason>" };
+}
+
+export type ParsedInventory = { hasSection: boolean; rows: InventoryRow[]; errors: RowError[] };
+
+// Every inventory table in every `## Rule inventory` section of one spec.
+function parseInventory(spec: string, text: string): ParsedInventory {
+  const lines = text.split("\n");
+  const rows: InventoryRow[] = [];
+  const errors: RowError[] = [];
+  let hasSection = false;
+  let inSection = false;
+  let fence: { ch: string; len: number } | null = null;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const t = line.trim();
+    if (fence !== null) {
+      const m = FENCE_OPEN.exec(t);
+      if (m && m[1] !== undefined && m[1][0] === fence.ch && m[1].length >= fence.len && t.slice(m[1].length).trim() === "") fence = null;
+      i++;
+      continue;
+    }
+    const f = FENCE_OPEN.exec(t);
+    if (f && f[1] !== undefined) { fence = { ch: f[1][0] ?? "`", len: f[1].length }; i++; continue; }
+    if (line.startsWith("## ")) {
+      inSection = line.startsWith("## Rule inventory");
+      if (inSection) hasSection = true;
+      i++;
+      continue;
+    }
+    if (!inSection || !t.startsWith("|")) { i++; continue; }
+    // A table: consecutive lines starting `|`.
+    const start = i;
+    const table: string[] = [];
+    while (i < lines.length && (lines[i] ?? "").trim().startsWith("|")) table.push(lines[i++] ?? "");
+    const header = splitRow(table[0] ?? "").map((c) => normalise(c).toLowerCase());
+    // Columns are found by header name, case-insensitively; a qualifier after the name ("Prose rule (§0a)") is allowed.
+    const col = (name: string): number => header.findIndex((h) => h === name || h.startsWith(`${name} `) || h.startsWith(`${name}(`) || h === `${name}s`);
+    const ruleCol = col("prose rule");
+    const dispCol = col("disposition");
+    const testCol = col("covering test");
+    if (ruleCol === -1 && dispCol === -1) continue;                      // a free table
+    if (ruleCol === -1 || dispCol === -1) {
+      errors.push({ spec, line: start + 1, reason: `inventory table header needs both a Prose rule and a Disposition column` });
+      continue;
+    }
+    let hasKept = false;
+    for (let r = 1; r < table.length; r++) {
+      const raw = table[r] ?? "";
+      if (SEPARATOR.test(raw.trim())) continue;
+      const cells = splitRow(raw);
+      const lineNo = start + r + 1;
+      const span = firstCodeSpan(cells[ruleCol] ?? "");
+      const anchor = span === null ? null : normalise(span);
+      const disp = parseDisposition(cells[dispCol] ?? "");
+      const parsedTests = testCol === -1 ? { tests: [], errors: [] } : parseTests(cells[testCol] ?? "");
+      const row: InventoryRow = { spec, line: lineNo, anchor: anchor === "" ? null : anchor, tests: parsedTests.tests, disposition: disp.disposition, reason: disp.reason };
+      rows.push(row);
+      if (disp.disposition === "kept") hasKept = true;
+      if (disp.error !== null) errors.push({ spec, line: lineNo, reason: disp.error });
+      for (const e of parsedTests.errors) errors.push({ spec, line: lineNo, reason: e });
+    }
+    if (hasKept && testCol === -1) errors.push({ spec, line: start + 1, reason: "a table with a kept row needs a Covering test column" });
+  }
+  return { hasSection, rows, errors };
+}
+
+// A valid anchor covers a deleted block when it is ≥ 20 characters and inside the block's deleted text,
+// or when it equals that whole text. A short anchor never covers a longer block that contains it.
+function covers(anchor: string, b: DeletedBlock): boolean {
+  return (codePoints(anchor) >= MIN_ANCHOR && b.norm.includes(anchor)) || anchor === b.norm;
+}
+
+// ---------------------------------------------------------------------------
+// Git.
+// ---------------------------------------------------------------------------
+
+function defaultGit(repo: string): GitRun {
+  return (args, input) => {
+    const r = spawnSync("git", ["-c", "core.quotePath=false", ...args], {
+      cwd: repo, input, maxBuffer: 256 * 1024 * 1024, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+    });
+    return {
+      status: r.status === null ? 128 : r.status,
+      stdout: Buffer.isBuffer(r.stdout) ? r.stdout : Buffer.alloc(0),
+      stderr: Buffer.isBuffer(r.stderr) ? r.stderr.toString("utf8") : String(r.stderr ?? ""),
+    };
+  };
+}
+
+function must(git: GitRun, args: string[], what: string, input?: Buffer): Buffer {
+  const r = git(args, input);
+  if (r.status !== 0) throw new CheckError(`git failed (${what}): ${clean(r.stderr.trim().split("\n")[0] ?? "", MAX_VALUE)}`);
+  return r.stdout;
+}
+
+const UTF8 = new TextDecoder("utf-8", { fatal: true });
+
+// `git diff -z --name-status` output. A path that is not valid UTF-8 is decoded only to test its prefix.
+function parseNameStatus(buf: Buffer): ChangedPath[] {
+  const parts: Buffer[] = [];
+  let s = 0;
+  for (let i = 0; i < buf.length; i++) if (buf[i] === 0) { parts.push(buf.subarray(s, i)); s = i + 1; }
+  if (s < buf.length) parts.push(buf.subarray(s));
+  const out: ChangedPath[] = [];
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    const status = (parts[i] ?? Buffer.alloc(0)).toString("latin1");
+    const raw = parts[i + 1] ?? Buffer.alloc(0);
+    let p: string;
+    try { p = UTF8.decode(raw); } catch {
+      const latin = raw.toString("latin1");
+      if (latin.startsWith(SKILLS_PREFIX)) throw new CheckError("a changed path under plugin/skills/ is not valid UTF-8");
+      p = latin;
+      if (latin.startsWith(ANCHORS_PREFIX)) { out.push({ status, path: latin }); continue; }
+      out.push({ status: "X", path: latin });
+      continue;
+    }
+    out.push({ status, path: p });
+  }
+  return out;
+}
+
+// The tree entry for <rev>:<path> from `git ls-tree -z`, or null when the path is absent there.
+// A failing git call is an error (exit 2), never read as absence.
+function treeEntry(git: GitRun, rev: string, p: string): { type: string; id: string } | null {
+  const out = must(git, ["--literal-pathspecs", "ls-tree", "-z", rev, "--", p], `ls-tree ${clean(p)}`).toString("utf8");
+  for (const rec of out.split("\0")) {
+    const m = /^\d+ (\S+) ([0-9a-f]+)\t([\s\S]*)$/.exec(rec);
+    if (m && m[3] === p && m[1] !== undefined && m[2] !== undefined) return { type: m[1], id: m[2] };
+  }
+  return null;
+}
+
+// Read many blobs in one `git cat-file --batch`. A missing object throws.
+function readBlobs(git: GitRun, revs: string[]): string[] {
+  if (revs.length === 0) return [];
+  for (const r of revs) if (r.includes("\n")) throw new CheckError("a path contains a newline");
+  const out = must(git, ["cat-file", "--batch"], "cat-file --batch", Buffer.from(revs.map((r) => `${r}\n`).join(""), "utf8"));
+  const texts: string[] = [];
+  let pos = 0;
+  for (const rev of revs) {
+    const nl = out.indexOf(0x0a, pos);
+    if (nl === -1) throw new CheckError("git cat-file --batch output truncated");
+    const header = out.subarray(pos, nl).toString("utf8");
+    const m = /^[0-9a-f]+ (\S+) (\d+)$/.exec(header);
+    if (!m || m[1] !== "blob") throw new CheckError(`cannot read ${clean(rev)}`);
+    const size = Number(m[2]);
+    texts.push(out.subarray(nl + 1, nl + 1 + size).toString("utf8"));
+    pos = nl + 1 + size + 1;
+  }
+  return texts;
+}
+
+// The configured spec docs path as a repo-relative posix prefix: `./records/specs/` and `records//specs`
+// both become `records/specs`. An absolute path or one that leaves the repo is a config error (exit 2).
+function specDocsDir(raw: string): string {
+  const p = raw.trim().replace(/\\/g, "/");
+  if (p === "" || p.startsWith("/") || /^[A-Za-z]:/.test(p)) throw new CheckError(`tracking.spec_docs_path ${clean(raw)} must be a repo-relative path`);
+  const n = path.posix.normalize(p).replace(/^(\.\/)+/, "").replace(/\/+$/, "");
+  if (n === "" || n === "." || n === ".." || n.startsWith("../")) throw new CheckError(`tracking.spec_docs_path ${clean(raw)} must be a directory inside the repo`);
+  return n;
+}
+
+// ---------------------------------------------------------------------------
+// The check.
+// ---------------------------------------------------------------------------
+
+export type CheckOptions = { repo: string; base: string | null; git?: GitRun };
+
+function emptyResult(): CheckResult {
+  return {
+    result: "pass", skipped_reason: null, footprint_without_spec: false, base: "", specs: [],
+    blocks_deleted: 0, covered_moved: 0, covered_by_row: 0, row_covered: [], uncovered: [], row_errors: [], warnings: [],
+  };
+}
+
+// Run the check. Throws CheckError for every exit-2 condition.
+function check(opts: CheckOptions): { result: CheckResult; notice: boolean } {
+  const git = opts.git ?? defaultGit(opts.repo);
+  const res = emptyResult();
+  // 1. Resolve the base.
+  let base: string;
+  if (opts.base !== null) {
+    if (!PLAIN_REF.test(opts.base) || opts.base.startsWith("-")) throw new CheckError(`--base ${clean(opts.base)} is not a plain ref`);
+    const r = git(["rev-parse", "--verify", "--quiet", `${opts.base}^{commit}`]);
+    if (r.status !== 0) throw new CheckError(`--base ${clean(opts.base)} names no commit`);
+    base = r.stdout.toString("utf8").trim();
+  } else {
+    // for-each-ref exits 0 with no output when origin/HEAD is absent, so only a real absence skips;
+    // a failing git call is an error, never a no-base skip.
+    const head = must(git, ["for-each-ref", "--format=%(refname)", "refs/remotes/origin/HEAD"], "for-each-ref origin/HEAD").toString("utf8").trim();
+    if (head === "") { res.result = "skipped"; res.skipped_reason = "no-base"; return { result: res, notice: false }; }
+    base = must(git, ["merge-base", "refs/remotes/origin/HEAD", "HEAD"], "merge-base refs/remotes/origin/HEAD HEAD").toString("utf8").trim();
+  }
+  if (!/^[0-9a-f]{40,64}$/.test(base)) throw new CheckError("the base did not resolve to a commit");
+  res.base = base;
+  must(git, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], "rev-parse HEAD");
+
+  // 2. Changed paths.
+  const changed = parseNameStatus(must(git, ["diff", "-z", "--no-renames", "--no-ext-diff", "--name-status", base, "HEAD"], "diff --name-status"));
+  let specDir: string;
+  try {
+    // A failed main-checkout probe in the shared lookup throws MainWorktreeProbeError (FAFF-1463).
+    const [cfg] = loadConfig(opts.repo);
+    specDir = specDocsDir(String(resolveSpecDocsPath(opts.repo, cfg, false)));
+  } catch (e: unknown) {
+    if (e instanceof CheckError || isProbeFailure(e)) throw e;
+    throw new CheckError(`config unreadable: ${clean(e instanceof Error ? e.message : String(e))}`);
+  }
+  const watched = changed.filter((c) => isWatched(c.path));
+  const specs = changed.filter((c) => c.status === "A" && c.path.startsWith(`${specDir}/`) && c.path.endsWith("-design.md")).map((c) => c.path).sort();
+  const footprint = changed.some((c) => (c.status === "A" || c.status === "M" || c.status === "T") && c.path.startsWith(ANCHORS_PREFIX));
+  res.specs = specs;
+
+  // 3. Deleted blocks (structural exemptions still pending their guard).
+  const candidates: DeletedBlock[] = [];
+  const withBase = watched.filter((c) => c.status !== "A");
+  const baseTexts = readBlobs(git, withBase.map((c) => `${base}:${c.path}`));
+  withBase.forEach((c, k) => {
+    // --text: a binary or -diff attribute, or a NUL byte, must never hide a deletion behind "Binary files differ".
+    const diff = must(git, ["--literal-pathspecs", "diff", "-U0", "--text", "--no-renames", "--no-ext-diff", "--no-color", "--no-textconv", base, "HEAD", "--", c.path], `diff ${c.path}`).toString("utf8");
+    if (/^Binary files /m.test(diff) || (diff.trim() !== "" && !/^@@ /m.test(diff))) {
+      // No text hunk deletes nothing only when the content is unchanged (a mode-only change) or the
+      // base file was empty. Any other content change with no hunk is an error, never a skip.
+      const before = treeEntry(git, base, c.path);
+      const after = treeEntry(git, "HEAD", c.path);
+      if ((before !== null && after !== null && before.id === after.id) || (baseTexts[k] ?? "") === "") return;
+      throw new CheckError(`git reported no text hunks for changed skill prose ${clean(c.path)}`);
+    }
+    candidates.push(...deletedBlocks(c.path, baseTexts[k] ?? "", deletedLines(diff)));
+  });
+  if (candidates.length === 0) { res.result = "skipped"; res.skipped_reason = "no-prose-deleted"; return { result: res, notice: false }; }
+
+  // 4. Head blocks of every watched file at HEAD; resolve the structural exemptions against them.
+  const tree = must(git, ["ls-tree", "-r", "-z", "--name-only", "HEAD", "--", SKILLS_PREFIX], "ls-tree HEAD");
+  const headPaths = tree.toString("utf8").split("\0").filter((p) => p !== "" && isWatched(p));
+  const headTexts = readBlobs(git, headPaths.map((p) => `HEAD:${p}`));
+  const headBlocks: string[] = [];
+  headPaths.forEach((p, k) => { for (const b of parseBlocks(p, headTexts[k] ?? "")) headBlocks.push(blockText(b)); });
+  const deleted = resolveExempt(candidates, headBlocks);
+  res.blocks_deleted = deleted.length;
+
+  // 5–6. Scope.
+  if (deleted.length === 0) { res.result = "skipped"; res.skipped_reason = "no-prose-deleted"; return { result: res, notice: false }; }
+  if (specs.length === 0 && footprint) { res.result = "fail"; res.footprint_without_spec = true; return { result: res, notice: false }; }
+  if (specs.length === 0) { res.result = "skipped"; res.skipped_reason = "no-spec-committed"; return { result: res, notice: true }; }
+
+  // 7. Rows.
+  const rows: InventoryRow[] = [];
+  let anySection = false;
+  for (const spec of specs) {
+    const size = Number(must(git, ["cat-file", "-s", `HEAD:${spec}`], `cat-file -s ${spec}`).toString("utf8").trim());
+    if (!Number.isFinite(size) || size > MAX_SPEC_BYTES) throw new CheckError(`committed spec ${clean(spec)} is larger than 1 MiB`);
+    const text = readBlobs(git, [`HEAD:${spec}`])[0] ?? "";
+    const parsed = parseInventory(spec, text);
+    if (parsed.hasSection) anySection = true;
+    rows.push(...parsed.rows);
+    res.row_errors.push(...parsed.errors);
+  }
+
+  // 8. Validate rows.
+  const valid: InventoryRow[] = [];
+  const rowErrorsAt = new Set(res.row_errors.map((e) => `${e.spec}\0${e.line}`));
+  for (const row of rows) {
+    const errs: string[] = [];
+    if (row.anchor === null) errs.push("Prose rule cell has no code-span anchor");
+    else if (codePoints(row.anchor) < MIN_ANCHOR && !deleted.some((b) => b.norm === row.anchor)) errs.push("anchor shorter than 20 characters");
+    if (row.disposition === "kept" && row.tests.length === 0) errs.push("kept row names no covering test");
+    for (const t of row.tests) {
+      if (!TEST_PATH.test(t.file) || t.file.split("/").includes("..")) { errs.push(`covering test ${t.file} is not a test/<path>.test.mjs path`); continue; }
+      if (treeEntry(git, "HEAD", t.file)?.type !== "blob") { errs.push(`covering test ${t.file} does not exist`); continue; }
+      if (t.name !== null) {
+        const body = readBlobs(git, [`HEAD:${t.file}`])[0] ?? "";
+        if (!body.includes(t.name)) errs.push(`covering test ${t.file} has no test named "${t.name}"`);
+      }
+    }
+    for (const e of errs) res.row_errors.push({ spec: row.spec, line: row.line, reason: e });
+    if (errs.length === 0 && !rowErrorsAt.has(`${row.spec}\0${row.line}`)) valid.push(row);
+  }
+
+  // 9. Classify each deleted block.
+  for (const b of deleted) {
+    if (headBlocks.some((h) => h.includes(b.norm))) { res.covered_moved++; continue; }
+    const row = valid.find((r) => r.anchor !== null && covers(r.anchor, b));
+    if (row !== undefined) {
+      res.covered_by_row++;
+      res.row_covered.push({ file: b.file, base_line: b.base_line, disposition: row.disposition, reason: row.reason, spec: row.spec, spec_line: row.line });
+      continue;
+    }
+    res.uncovered.push({ file: b.file, base_line: b.base_line, excerpt: clean(b.text.trim(), EXCERPT) });
+  }
+
+  // 10. Rows that match nothing.
+  for (const row of valid) {
+    if (row.anchor !== null && !deleted.some((b) => covers(row.anchor ?? "", b))) {
+      res.warnings.push(`${row.spec}:${row.line}: anchor matches no deleted prose`);
+    }
+  }
+
+  // 11. No inventory at all while something is uncovered.
+  if (res.uncovered.length > 0 && !anySection) {
+    for (const spec of specs) res.row_errors.push({ spec, line: 1, reason: "no ## Rule inventory section" });
+  }
+
+  res.result = res.uncovered.length > 0 || res.row_errors.length > 0 ? "fail" : "pass";
+  return { result: res, notice: false };
+}
+
+// Every spec-derived string in the result, stripped of control characters and capped.
+function cleanResult(r: CheckResult): CheckResult {
+  return {
+    ...r,
+    specs: r.specs.map((s) => clean(s)),
+    row_covered: r.row_covered.map((c) => ({ ...c, file: clean(c.file), disposition: clean(c.disposition), reason: c.reason === null ? null : clean(c.reason), spec: clean(c.spec) })),
+    uncovered: r.uncovered.map((u) => ({ ...u, file: clean(u.file), excerpt: clean(u.excerpt, EXCERPT) })),
+    row_errors: r.row_errors.map((e) => ({ ...e, spec: clean(e.spec), reason: clean(e.reason) })),
+    warnings: r.warnings.map((w) => clean(w)),
+  };
+}
+
+const DISPOSITION_ORDER: { [k: string]: number } = { dropped: 0, changed: 1, kept: 2 };
+
+function renderSummary(r: CheckResult): string {
+  const out: string[] = ["", "### rule-inventory", ""];
+  if (r.result === "skipped") {
+    out.push(`rule-inventory: skipped (${r.skipped_reason ?? ""})`, "");
+    return out.join("\n");
+  }
+  out.push(`rule-inventory: ${r.result} — ${r.blocks_deleted} deleted block(s), ${r.covered_moved} moved, ${r.covered_by_row} covered by a row, ${r.uncovered.length} uncovered`, "");
+  const rows = [...r.row_covered].sort((a, b) => (DISPOSITION_ORDER[a.disposition] ?? 3) - (DISPOSITION_ORDER[b.disposition] ?? 3));
+  if (rows.length > 0) {
+    out.push("| Disposition | Reason | Deleted block | Inventory row |", "|---|---|---|---|");
+    for (const c of rows) {
+      out.push(`| ${mdEscape(c.disposition)} | ${c.reason === null ? "" : mdEscape(c.reason)} | ${mdEscape(c.file)}:${c.base_line} | ${mdEscape(c.spec)}:${c.spec_line} |`);
+    }
+    out.push("");
+  }
+  return out.join("\n");
+}
+
+function renderText(r: CheckResult): string {
+  const out: string[] = [];
+  for (const u of r.uncovered) out.push(`rule-inventory: uncovered ${u.file}:${u.base_line}: ${u.excerpt} (format: ${FORMAT_DOC})`);
+  for (const e of r.row_errors) out.push(`rule-inventory: row-error ${e.spec}:${e.line}: ${e.reason}`);
+  for (const w of r.warnings) out.push(`rule-inventory: warning ${w}`);
+  if (r.footprint_without_spec) out.push(`rule-inventory: agent footprint (.faff/anchors/) with no committed spec; deleted skill prose needs a spec with a Rule inventory (format: ${FORMAT_DOC})`);
+  const counts = r.result === "skipped"
+    ? `${r.skipped_reason ?? ""}`
+    : `${r.blocks_deleted} deleted, ${r.covered_moved} moved, ${r.covered_by_row} by row, ${r.uncovered.length} uncovered, ${r.row_errors.length} row error(s)`;
+  out.push(`rule-inventory: ${r.result} (${counts})`);
+  return `${out.join("\n")}\n`;
+}
+
+// ---------------------------------------------------------------------------
+// CLI.
+// ---------------------------------------------------------------------------
+const CHECK_SPEC = { flags: { "--base": { arity: 1 }, "--json": { arity: 0 }, "--summary": { arity: 1 } } };
+const USAGE = "rule-inventory: usage: faff rule-inventory check [--base REF] [--json] [--summary FILE]\n" +
+  "rule-inventory: --base REF compares REF's tree with HEAD's; pass a merge-base (without it, the merge-base with origin/HEAD).";
+
+function fail2(msg: string): number {
+  process.stderr.write(`rule-inventory: ${msg}\n${USAGE}\n`);
+  return 2;
+}
+
+function cmdCheck(args: string[]): number {
+  const { values, positionals, errors } = parseArgs(args, CHECK_SPEC);
+  if (errors.length) return fail2(clean(String(errors[0]?.detail ?? "bad arguments")));
+  if (positionals.length) return fail2(`unexpected argument ${clean(String(positionals[0]))}`);
+  const base = typeof values["--base"] === "string" ? values["--base"] : null;
+  const summary = typeof values["--summary"] === "string" ? values["--summary"] : null;
+  let repo: string;
+  try {
+    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" });
+    if (r.status !== 0) return fail2("not inside a git repository");
+    repo = String(r.stdout).trim();
+  } catch { return fail2("git is not runnable"); }
+  let outcome: { result: CheckResult; notice: boolean };
+  try { outcome = check({ repo, base }); } catch (e: unknown) {
+    if (e instanceof CheckError) return fail2(e.message);
+    if (isProbeFailure(e)) throw e;
+    return fail2(`unexpected error: ${clean(e instanceof Error ? e.message : String(e))}`);
+  }
+  const result = cleanResult(outcome.result);
+  if (summary !== null) {
+    try { fs.appendFileSync(path.resolve(summary), renderSummary(result)); } catch (e: unknown) {
+      return fail2(`cannot write --summary file: ${clean(e instanceof Error ? e.message : String(e))}`);
+    }
+  }
+  if (values["--json"] === true) process.stdout.write(`${JSON.stringify(result)}\n`);
+  else {
+    if (outcome.notice) process.stdout.write(`${SKIP_NOTICE}\n`);
+    process.stdout.write(renderText(result));
+  }
+  return result.result === "fail" ? 1 : 0;
+}
+
+function cmdRuleInventory(args: string[]): number {
+  const sub = args[0];
+  if (sub === "check") return cmdCheck(args.slice(1));
+  return fail2(sub === undefined ? "missing subcommand" : `unknown subcommand ${clean(sub)}`);
+}
+
+module.exports = {
+  normalise, clean, mdEscape, isWatched, specDocsDir, resolveExempt, parseBlocks, deletedLines, deletedBlocks, splitRow, firstCodeSpan,
+  parseTests, parseDisposition, parseInventory, covers, parseNameStatus, check, renderText, renderSummary,
+  cmdRuleInventory, CheckError, MIN_ANCHOR, SKIP_NOTICE,
+};
diff --git a/plugin/skills/faff/build-manifest.json b/plugin/skills/faff/build-manifest.json
index e07e8b6d7..556f38fad 100644
--- a/plugin/skills/faff/build-manifest.json
+++ b/plugin/skills/faff/build-manifest.json
@@ -6,7 +6,7 @@
     "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="
   },
   "config": {
-    "tsconfig.json": "1f424d9cea8dc3d289701678a367e5b067b8304ca5cb5a2f1bcd16178c3be252"
+    "tsconfig.json": "ea97fac0be78e0e67b96ff67d4e495441877104c992c438e3f18ffbdfacdc4cb"
   },
   "lock": {
     "package-lock.json": "b64bb7ba6298d47694b5700301c5fbec5aec2d5ce8351937d1cda8873fc5697a",
@@ -33,6 +33,7 @@
     "bin/lib/producer-auth.ts": "fcaed615b47929a0db1d307553291ac8d15aca206003cdedd5e6807fc3914272",
     "bin/lib/prose-size.ts": "a359145a4d7d807f8b97cfe4e0f84eb03f6091baeaf2fbe658016832b671e9aa",
     "bin/lib/result.ts": "9faed77603fd2095150b6b405444d9fe4c6783a0da9339e8dc6121cb1921c4a3",
+    "bin/lib/rule-inventory.ts": "c4cb6d85b49519c4bca68d3b30b63a603eaf0590b8d31edbd7eaffe60dff4621",
     "bin/lib/run-checkpoint.ts": "9bee010306fced736b573cd2b7f377b08a1be140d1c9fa7ff3ca07405162ea98",
     "bin/lib/run-close.ts": "4f6f57ee9305f04f076285af97953ba0a4c69a37c01288748fac5c38cce97fa4",
     "bin/lib/run-open.ts": "ce538c68a6de316a5d5372c8fe9ec52ea6a25802cbcca2a0e06810569ae0a337",
@@ -65,6 +66,7 @@
     "bin/lib/producer-auth.js": "6ef8d8a93c885992b0f58c3156f1e2df96518cbedd4df95cd7e2b72fa9009baf",
     "bin/lib/prose-size.js": "df29582b5c00b007ad6dd3f135859edae851c540c2f254b5e7cf869981d5c5a7",
     "bin/lib/result.js": "09f1ec919a2ff84a38e1fe1e8ac5ed983ddabb90f75bfa8647cfccce561ff03e",
+    "bin/lib/rule-inventory.js": "e4cc399a8b003fb062065d612f5b28b578fb14cc371611568f68b47150b9e69d",
     "bin/lib/run-checkpoint.js": "55718b976a814ef789c62578a60c3aa44bd1e72de37f04aec242b4166700de35",
     "bin/lib/run-close.js": "ebfdac166fd6586f0fc75ee14967babe5c5e2db68bc8672aac6931760c289ea2",
     "bin/lib/run-open.js": "68f9978aadb0cbaad1887be23443e2667ed1678b12c4403e9cd518c5686a553c",
@@ -76,5 +78,5 @@
     "bin/lib/spec-review-round.js": "b02ecc242ee01d37719f7660252f2ba273abc334b79a6d64d2c40e66cb5bc678",
     "bin/lib/worktree-ensure.js": "e9b115786f6867b8b7835ef11322cf15e37a1dd459ea0dda272da45152da1207"
   },
-  "output_digest": "d998a01fd4a996a2166521dd94e8dde179bceec972e55d3aa39eb3105cc3cca2"
+  "output_digest": "8d9556ccfb7fd60a71913a985b0e266fc1f4a7af32f87e9a5fbff81319237644"
 }
diff --git a/plugin/skills/faff/prose-baseline.json b/plugin/skills/faff/prose-baseline.json
index bc18b385c..fb44d45b5 100644
--- a/plugin/skills/faff/prose-baseline.json
+++ b/plugin/skills/faff/prose-baseline.json
@@ -51,7 +51,7 @@
 
     "faffter-dark-methodology-agile-delivery/SKILL.md": 45057,
 
-    "faffter-dark-nlspec/SKILL.md": 18443,
+    "faffter-dark-nlspec/SKILL.md": 18680,
 
     "faffter-dark-spec-review/SKILL.md": 40715,
 
diff --git a/plugin/skills/faff/tsconfig.json b/plugin/skills/faff/tsconfig.json
index 5f5c0ee0f..022818336 100644
--- a/plugin/skills/faff/tsconfig.json
+++ b/plugin/skills/faff/tsconfig.json
@@ -46,6 +46,7 @@
     "bin/lib/run.ts",
     "bin/lib/run-checkpoint.ts",
     "bin/lib/prose-size.ts",
+    "bin/lib/rule-inventory.ts",
     "bin/lib/run-open.ts",
     "bin/lib/run-close.ts",
     "bin/lib/pr-open.ts",
diff --git a/plugin/skills/faffter-dark-nlspec/SKILL.md b/plugin/skills/faffter-dark-nlspec/SKILL.md
index 18069c43b..b45611512 100644
--- a/plugin/skills/faffter-dark-nlspec/SKILL.md
+++ b/plugin/skills/faffter-dark-nlspec/SKILL.md
@@ -123,6 +123,8 @@ Emit only above the complexity bar (same judgement as Scenarios): a spike, a nov
 
 **Anti-patterns:** near the section they affect, document what NOT to do and why. Format: `**Anti-pattern:** X. Why: Y.`
 
+**Rule inventory:** a spec whose build deletes skill prose carries a `## Rule inventory` in the format at `docs/reference/skill-authoring.md#rule-inventory`, one row per deleted rule; `faff rule-inventory check` fails the PR otherwise.
+
 ### 5. SCENARIOS — born-verifiable main objectives
 
 A dedicated `## Scenarios` section, after HOW, expressing the spec's **main objectives** as scenarios so what the work must achieve is born verifiable — not just prose the verifier has to re-derive.
diff --git a/records/specs/2026-11-04-FAFF-1428-fail-an-extraction-pr-when-a-deleted-skill-prose-rule-has-no-rule-inventory-entry-design.md b/records/specs/2026-11-04-FAFF-1428-fail-an-extraction-pr-when-a-deleted-skill-prose-rule-has-no-rule-inventory-entry-design.md
new file mode 100644
index 000000000..5a3d60d38
--- /dev/null
+++ b/records/specs/2026-11-04-FAFF-1428-fail-an-extraction-pr-when-a-deleted-skill-prose-rule-has-no-rule-inventory-entry-design.md
@@ -0,0 +1,430 @@
+# FAFF-1428: faff rule-inventory check fails a PR whose deleted skill prose maps to no rule-inventory row
+
+> Spec: faffter-dark-nlspec · 2026-11-04 · interactive · claude-code/unknown · faff 0.44.0 · confidence: high. Full spec on Linear FAFF-1428.
+
+This spec is for the build agent and the human reviewers of FAFF-1428. It defines a new factory command, `faff rule-inventory check`, which runs in the `validate` CI job. The command compares a PR's head with its base, finds every block of skill prose the PR deletes, and fails unless each block is either moved verbatim into other skill prose or quoted by a row of the `## Rule inventory` in a spec the PR commits.
+
+## 1. WHY — Problem and Principles
+
+**The load-bearing model.** A deleted rule is only safe when something says where it went. The check makes that statement mechanical: every deleted block of skill prose must either reappear word for word in other skill prose, or be quoted by an inventory row that says what happened to it (`kept` with a test that exists, or `changed` / `dropped` with a reason). A deleted block that is neither moved nor quoted fails the PR.
+
+**Problem.** Moving skill prose into commands deletes rules from `SKILL.md`, and today nothing checks that each deleted rule was implemented or deliberately dropped. The 2026-10-29 audit found one rule lost and one dangling prose reference in FAFF-1404, because that spec mapped prose in blocks rather than rule by rule (FAFF-1429). The holdout checks the command against the spec, the line and byte ratchets only stop prose growing back, and the wiring lints only catch stale call shapes, so none of them sees a rule that both the spec and the code forgot.
+
+**Design principles.**
+
+- **Quote, don't count.** A row identifies the prose it covers by quoting it, never by line number. A rebase moves line numbers; it changes the quoted text only when upstream edits the same lines, and then the fix is one amend to the committed spec.
+- **Coverage is mechanical; correctness stays with review.** The check proves every deleted block has a row and every named test exists. Whether the row's claim is true is the reviewer's and the holdout's job. The check must never be described as proving a rule was implemented.
+- **Fail closed inside scope.** Within the PRs it applies to, any doubt (an unparseable inventory, a git error, an unreadable spec) fails or errors. It never turns into a pass.
+- **No new Commissaire surface.** This is a factory-region `faff` command. It touches no `faff commissaire` verb and no governance-check input. It reads only whether the diff adds or modifies a path under `.faff/anchors/`, never an anchor's content.
+- **The threat is forgetting, not lying.** The rows are written by the agent the check gates, so a row can be false. The check's job is to force a written, quoted answer for every deleted block and to put the risky answers (`dropped`, `changed`) in front of the reviewer, not to stop an author who writes a false row. The reviewer, the independent review and the holdout own that. The same holds for the moved test: echoing a rule's text into other prose satisfies it, and review catches that.
+
+**Reference context.**
+
+| System | Language | Relevance |
+|---|---|---|
+| `plugin/skills/faff/bin/lib/regions.js` (`regions check --base`) | JavaScript | The precedent for a base-relative ratchet: `--base REF` with a plain-ref guard, and a no-base mode |
+| `.github/workflows/validate.yml`, the "Enforce the region require-graph … TS-first leg" step | YAML / bash | The env-only `pull_request` / `push` base-resolution block this command's CI step copies |
+| `.github/workflows/governance.yml` (`on-missing: pass`) | YAML | The precedent for scoping a gate by artifact footprint: agent PRs carry an artifact, hand-authored PRs do not |
+| `plugin/skills/faff/bin/lib/config-core.js` (`resolveSpecDocsPath`) | JavaScript | Resolves `tracking.spec_docs_path` (this repo: `records/specs/`) |
+| `plugin/skills/faff/bin/lib/prose-size.ts` | TypeScript | The sibling prose ratchet; defines which files count as skill prose |
+| `records/specs/2026-11-03-FAFF-1418-…-design.md`, `records/specs/2026-10-30-FAFF-1435-…-design.md` | Markdown | Existing `## Rule inventory` tables: a `Prose rule` column, a `Disposition` column, and (in FAFF-1435) a `Covering test` column |
+| `plugin/skills/faff/bin/lib/lint-cli-coverage.js`, `regions.js` `REGION_SELFTEST_ARGV`, `docs/guide/cli.md` | JavaScript / Markdown | Registration a new command needs |
+| `docs/reference/skill-authoring.md` | Markdown | The home for the inventory format |
+| `plugin/skills/faffter-dark-nlspec/SKILL.md` | Markdown | This repo's spec producer; gains a pointer to the format |
+| `plugin/skills/faff/bin/lib/spec-commit.ts` | TypeScript | Commits the builder view of the spec, holdout blocks withheld, everything else byte for byte |
+
+**Scope.** One new check in the `validate` job, one documented table format, one pointer in the spec producer. It sits beside `regions check` and `validate-adapters` as a repository lint.
+
+## 2. OUT OF SCOPE
+
+- **Checking the operator's test-repoint rule.** In an extraction PR, a test that pinned removed prose may be repointed at the command only with a guarantee-to-test map and a mutation proof for each guarantee. A check that a PR which edits such a test carries that map is a separate concern: it reads test diffs, not prose diffs, and a mutation proof is not machine-checkable from the diff. **Why excluded:** a different input and a judgement this check cannot make. **Extension point:** a second verb on the same module (`faff rule-inventory tests`), reading the same spec's guarantee table. See the non-blocking Punt in section 7.
+- **Proving a row's claim.** The check does not read the command code to confirm a `kept` rule is implemented. **Why excluded:** that is the holdout's and the reviewer's job; a mechanical "implemented" check would be a false assurance. **Extension point:** none planned.
+- **Back-filling old specs.** Inventories already on `main` lack the quoted anchor. **Why excluded:** the check is diff-scoped, so a spec already merged is never read. **Extension point:** none needed.
+- **Prose outside the `prose-size` covered set.** `docs/`, ADRs and code comments are not watched. **Why excluded:** the ticket scopes the runtime prompt prose. **Extension point:** `prose-size`'s `isCovered`, which both gates share.
+- **Rewording detection by similarity.** A one-word edit to a rule (for example "fail closed" to "fail open") is a deletion like any other. **Why excluded:** a fuzzy "edited in place" exemption would wave through exactly the edits the check exists to catch. **Extension point:** none; see the noise failure mode in section 4.
+- **A PR label or commit trailer that skips the check.** **Why excluded:** no workflow in this repo reads a label or trailer to skip a gate, so there is no precedent. The scope rule in section 3 (the footprint test) does the job instead. **Extension point:** the scope function in the module.
+
+## 3. WHAT — Vocabulary, Types and Interfaces
+
+**Vocabulary.**
+
+| Term | Meaning |
+|---|---|
+| Watched file | A path under `plugin/skills/` that `prose-size`'s exported `isCovered` accepts (every `<skill>/SKILL.md` and every `<skill>/references/*.md`), at base or at head. The check imports that predicate rather than keeping its own list, so it and the byte ratchet always agree on what skill prose is |
+| Block | One markdown unit of a watched file as it stands at base: a paragraph, a list item with its continuation lines, a table row, a heading, or a fenced code block from fence to fence |
+| Deleted block | A block with at least one line the diff deletes. Its **deleted text** is those deleted lines, joined with single spaces |
+| Exempt block | A deleted block that states no rule, decided per block by shape and by what else is deleted: a table separator row (`|---|`); a block whose deleted text has no letters; a table's header row (the row directly above its separator in the base file) when every row of that table is deleted too; or a heading when every block of its section (up to the next heading of the same or higher level) is deleted too. A heading or header row deleted or reworded on its own is not exempt, so a rule carried in a heading needs a row. Blank lines are not blocks; they only end one |
+| Moved | A deleted block whose normalised deleted text is a substring of the normalised text of a single block of a watched file at HEAD. Head blocks are parsed exactly as base blocks are and never joined to each other, so a match cannot straddle two unrelated blocks, and a reflowed paragraph matches its own head block whether or not some of its lines were left unchanged |
+| Committed spec | A file the diff adds (status `A` against the base) under the configured spec docs path whose name ends `-design.md`. A spec already on the base and only modified is not read, so a PR never inherits an older spec's rows |
+| Agent footprint | The diff adds or modifies (status `A` or `M`) at least one path under `.faff/anchors/`, which graft's Step 9b commits on every agent PR. A follow-up PR that only updates an existing anchor still carries the footprint |
+| Anchor | The first code span in a row's `Prose rule` cell |
+| Normalise | Delete every `*` and every backtick, collapse every run of whitespace to one space, and trim. Applied identically to anchors, deleted text and head blocks, so an author may quote a rule with or without its bold lead and code spans |
+
+**The inventory format** (documented in `docs/reference/skill-authoring.md`).
+
+- The section is any heading line matching `## Rule inventory` at its start (so `## Rule inventory (slice A)` counts). It runs to the next `## ` heading.
+- Every markdown table in the section whose header has a `Prose rule` cell and a `Disposition` cell is an inventory table. Columns are found by header name, case-insensitively; other columns are free.
+- **Prose rule cell:** must contain a code span whose content is the anchor. CommonMark backtick-run rules apply: an anchor that itself contains a backtick is written with a longer delimiter (``` `` like `this` `` ```). Inside a table cell, a literal pipe is written `\|` and is unescaped before matching. Quote the lines the PR deletes, not the block as it stood: when only part of a paragraph is deleted, the anchor must sit inside the deleted part.
+- **Covering test cell** (optional column): zero or more entries of the form `test/<path>.test.mjs`, each optionally followed by `: "<test name>"`. Separated by `;` or `,`. A path must match `^test/[A-Za-z0-9._/-]+\.test\.mjs$` and contain no `..` segment; anything else is a row error, and the file is never looked up.
+- **Disposition cell:** exactly one of `kept`, `changed: <reason>`, `dropped: <reason>`. A reason is non-empty after trimming.
+- A preamble sentence naming a default test file (as the FAFF-1418 inventory has) is not read. Each `kept` row names its own test, so a table with any `kept` row needs a `Covering test` column.
+
+```
+RECORD InventoryRow:
+  spec: Path                  # the committed spec it came from
+  line: Int                   # 1-based line in that spec, for error messages
+  anchor: String | null       # normalised; null when the cell has no code span
+  tests: List<TestRef>        # empty when the column is absent or the cell is empty or "—"
+  disposition: "kept" | "changed" | "dropped" | "invalid"
+  reason: String | null
+
+RECORD TestRef:
+  file: Path                  # repo-relative, must start "test/" and end ".test.mjs"
+  name: String | null
+
+RECORD CheckResult:
+  result: "pass" | "fail" | "skipped"
+  skipped_reason: "no-prose-deleted" | "no-spec-committed" | "no-base" | null
+  footprint_without_spec: Bool   # true when the diff has an agent footprint but no committed spec (a fail)
+  base: String                # the resolved base commit, or "" when skipped for no-base
+  specs: List<Path>
+  blocks_deleted: Int         # non-exempt deleted blocks
+  covered_moved: Int
+  covered_by_row: Int
+  row_covered: List<{ file: Path, base_line: Int, disposition: String, reason: String | null, spec: Path, spec_line: Int }>
+  uncovered: List<{ file: Path, base_line: Int, excerpt: String }>   # excerpt ≤ 120 chars
+  row_errors: List<{ spec: Path, line: Int, reason: String }>
+  warnings: List<String>      # e.g. a row whose anchor matches no deleted block
+```
+
+**Command surface.**
+
+```
+faff rule-inventory check [--base REF] [--json] [--summary FILE]
+  exit 0  pass or skipped
+  exit 1  fail (uncovered blocks, row errors, or an agent footprint with no spec)
+  exit 2  usage error, a REF that is not a plain ref or names no commit, a git failure,
+          an unreadable committed spec, or an unreadable config
+```
+
+Without `--json` it prints one line per uncovered block, `rule-inventory: uncovered <file>:<base_line>: <excerpt>`, one per row error, `rule-inventory: row-error <spec>:<line>: <reason>`, one per warning, `rule-inventory: warning <spec>:<line>: <text>`, then `rule-inventory: <result> (<counts>)`. With `--json` it prints the `CheckResult` object on stdout. Every message about an uncovered block names `docs/reference/skill-authoring.md#rule-inventory` so the author learns the format from the failure. With `--summary FILE` it also appends a markdown table of every row-covered block, `dropped` and `changed` rows first, to FILE; the CI step passes `$GITHUB_STEP_SUMMARY`, so the reviewer sees each dropped rule on the PR's check page.
+
+**Output hygiene.** The committed spec is untrusted input, and its text reaches the CI log. Every printed line starts with the fixed prefix `rule-inventory: `, so no spec text can start a line, which is where GitHub reads `::error::`-style workflow commands. The one exception is the skip notice, a fixed literal with no spec-derived text: `::notice::rule-inventory: skipped, no spec committed`. Every spec-derived value is stripped of control characters (including ESC and newlines) and capped at 200 characters before it is printed, written to the summary or put in the JSON. In the `--summary` table every spec-derived value is also escaped for markdown: backslash, backtick, `*`, `_`, `[`, `]`, `(`, `)`, `!`, `|` and `#` each get a backslash, and `<`, `>` and `&` become `&lt;`, `&gt;` and `&amp;`, so a value can neither break the table, add a link or image, nor inject HTML into the rendered check page. A committed spec larger than 1 MiB is not parsed: exit 2.
+
+**Design decisions.**
+
+**How a deleted block maps to a row.** Options: each row cites a line range; each row carries a quoted anchor; or a deletion counts as covered when any row quotes it. Line ranges break on every rebase and on any upstream edit to the same file. A quoted anchor survives both. "Any row quotes it" is the same as the anchor option once the quote must sit inside the block's deleted text.
+**Chosen:** a quoted anchor. A row covers a deleted block when its normalised anchor, at least 20 characters long, is a substring of the block's normalised deleted text. One row may cover several blocks that contain the same text (duplicated prose). The 20-character floor stops an anchor like `` `faff next` `` from covering every block that mentions the command. A deleted block shorter than 20 characters is covered by an anchor equal to its whole normalised deleted text, and such a short anchor covers only blocks whose whole deleted text it equals, never a longer block that merely contains it.
+
+**Where it runs.** Options: a new `faff` command run by `governance-check`; a leg of `validate-adapters`; a new command run as its own step in the `validate` job.
+**Chosen:** a new command, `faff rule-inventory check`, written in TypeScript in the factory region, run as its own step in `validate.yml` beside `regions check`. `governance-check` is Commissaire's anchor-driven floor; adding a prose-diff input to it would grow Commissaire, which is not allowed. `validate-adapters` is a whole-tree lint with no base, and it is a legacy JavaScript module, whereas new code must be TypeScript. `regions check --base` already shows the base-relative pattern this needs, including the env-only base resolution in CI. Tests go in `test/rule-inventory.test.mjs`, registered as `REGION_SELFTEST_ARGV["rule-inventory"] = null` with a `TEST_FILE_COVERAGE` entry.
+
+**Pure prose edits.** Options: a PR label; a commit trailer; scope by artifact footprint; no exemption at all.
+**Chosen:** scope by artifact footprint, with no label or trailer. The check applies when the PR commits a spec under the spec docs path or carries an agent footprint. Graft commits the spec (`faff spec commit`, Step 4) and an anchor (Step 9b) on every agent build, so every agent PR that deletes prose is checked, and an agent PR that deletes prose with an anchor but no spec fails (`footprint_without_spec`) instead of skipping. A hand-authored prose edit carries neither, so it passes with `skipped_reason: "no-spec-committed"` and a `::notice::` line in the log. This is the same footprint test `governance-check` already uses (`on-missing: pass`), with the same accepted residual: an actor who strips both the spec and the anchor presents as a human PR. When `governance.yml` flips to `on-missing: fail` because the branch has become agent-only, this check's no-spec skip should flip to a fail with it; that is a one-line change to the scope function. No workflow here reads labels or trailers to skip a gate. Inside scope there is no exemption: a reworded rule needs a row like any other deletion, typically `changed: reworded, same rule`. A verbatim move or a reflow needs none, because the moved test covers it.
+
+**Blocking from day one, or report first.** Options: block immediately; report as a warning for a period, then block.
+**Chosen:** block from day one. Nine extraction PRs (FAFF-1414 through FAFF-1418, and FAFF-1434 to FAFF-1437) have shipped with inventories, so the table format is proven. Three things are new: the code-span anchor, the closed disposition grammar, and a covering test on every `kept` row. Old rows written as "kept in prose" map onto the grammar without loss: a rule still present word for word is not deleted and needs no row, and a rule reworded but still in prose is `changed: reworded in prose`. Every failure message names the format doc. The repo's one advisory size gate (`size-census --gate`, with `--enforce` still commented out) shows that a report-only gate is not acted on. The check is diff-scoped, so no merged spec needs back-filling. Open PR #1086 edits `faff-graft/SKILL.md` but commits no spec, so the footprint scope skips it.
+
+**Base when `--base` is absent (local runs).** Options: skip; compare with `origin/HEAD`; compare with a configured base branch.
+**Chosen:** compare with `git merge-base HEAD origin/HEAD` when `origin/HEAD` resolves, otherwise exit 0 with `skipped_reason: "no-base"`. There is no base-branch key in config, and `origin/HEAD` is what `git clone` sets. CI always passes `--base`, so CI never takes the skip. The no-base command line stays literal in `validate.yml` so `faff gates discover` finds it as a local rung for graft's ladder.
+
+**Covering-test requirement by disposition.** Options: require a test on every row; on `kept` only; never.
+**Chosen:** a `kept` row must name at least one test; `changed` and `dropped` rows may name none, but must give a reason. Any test a row names must exist. A `kept` rule moved into code with no test is the exact gap FAFF-1430 found; a `dropped` rule has nothing to test.
+
+## 4. HOW — Behaviour
+
+**Summary.** Resolve the base, decide whether the check applies, parse the deleted blocks and the inventories, then mark each deleted block moved, covered or uncovered.
+
+```
+PROCEDURE rule_inventory_check(base_flag, json):
+  1. Resolve the base.
+     a. IF base_flag given: reject it unless it matches ^[A-Za-z0-9._/-]+$ and does not start with "-" (exit 2);
+        verify it names a commit (git rev-parse --verify REF^{commit}), else exit 2.
+        base := REF itself. The diff is REF's tree against HEAD's tree, as `regions check --base` compares.
+     b. ELSE IF origin/HEAD resolves: base := git merge-base origin/HEAD HEAD.
+     c. ELSE: return skipped("no-base").
+  2. List changed paths: git -c core.quotePath=false diff -z --no-renames --name-status base HEAD.
+     Every git call that lists or reads paths uses -z or passes paths as separate arguments, never parses
+     quoted output. A path under plugin/skills/ the parser cannot decode is an exit 2, never a skip.
+     watched_changed := paths that are watched files.
+     specs := paths with status A under resolveSpecDocsPath() whose name ends "-design.md".
+     footprint := some path with status A or M starts ".faff/anchors/".
+  3. FOR each watched file in watched_changed:
+       base_text := git show base:<path> (empty when the file is added)
+       deleted_lines := line numbers from git diff -U0 --no-renames base HEAD -- <path> hunk headers
+       head_text := git show HEAD:<path> (empty when the file is deleted)
+     blocks := parse base_text into blocks; keep those with ≥1 deleted line; drop exempt blocks.
+  4. IF no non-exempt deleted block: return skipped("no-prose-deleted").
+  5. IF specs is empty AND footprint: return fail with footprint_without_spec = true.
+     IF specs is empty: print the fixed skip notice and return skipped("no-spec-committed").
+  6. head_blocks := [normalise(joined text of b) for every block b of every watched file at HEAD,
+     including watched files the diff does not touch].
+  7. rows := for each spec, read it at HEAD (exit 2 if unreadable or over 1 MiB), parse every inventory table.
+     A spec with no "## Rule inventory" section contributes no rows.
+  8. Validate each row:
+     - anchor null → row_error "Prose rule cell has no code-span anchor"
+     - anchor shorter than 20 characters and not equal to the whole normalised deleted text
+       of some deleted block → row_error "anchor shorter than 20 characters"
+     - disposition invalid, or changed/dropped with an empty reason → row_error
+     - kept with no tests → row_error "kept row names no covering test"
+     - each TestRef: file must match ^test/[A-Za-z0-9._/-]+\.test\.mjs$ with no ".." segment, else row_error
+       (and no lookup); then it must exist at HEAD (git cat-file -e HEAD:<file>), else row_error;
+       if name given, the file text must contain the name as written, else row_error
+  9. FOR each deleted block b:
+       IF normalise(b.deleted_text) is a substring of some single element of head_blocks: covered_moved += 1
+       ELSE IF some valid row's anchor A covers b, where A covers b when
+            (len(A) ≥ 20 AND A is a substring of normalise(b.deleted_text)) OR A == normalise(b.deleted_text):
+         covered_by_row += 1; row_covered += { b, that row's disposition, reason, spec, line }
+       ELSE: uncovered += { b.file, b.first_deleted_base_line, first 120 chars of the deleted text }
+ 10. FOR each valid row whose anchor matches no deleted block: warning "anchor matches no deleted prose".
+ 11. IF uncovered is non-empty AND no spec has a "## Rule inventory" section:
+       add one row_error per spec: "no ## Rule inventory section".
+     (A PR whose deleted blocks are all moved needs no inventory section.)
+ 12. result := fail IF uncovered or row_errors are non-empty, ELSE pass.
+ 13. IF --summary FILE: append the row_covered table to FILE, dropped and changed rows first.
+```
+
+**Block parsing.** Parse the base file line by line, tracking fence state. A fence opens on a line whose trimmed form starts with three or more backticks or tildes and closes on the next matching fence; the whole fenced region is one block. Outside fences, a blank line ends a block; a heading line, a table row (trimmed line starting `|`) and a list-item line (trimmed line starting `-`, `*`, `+` or `N.` followed by a space) each start a new block; any other line continues the current block. This only has to be as good as the authoring standard's markdown, not a full CommonMark parser.
+
+**CI step.** A new step in the `validate` job of `validate.yml`, right after the region step, using the same env-only block: on `pull_request`, check `BASE_REF` is a plain ref, `git fetch --depth=1 origin +refs/heads/$BASE_REF:refs/remotes/origin/$BASE_REF`, then `node plugin/skills/faff/bin/faff rule-inventory check --base "origin/$BASE_REF" --summary "$GITHUB_STEP_SUMMARY"`; on `push`, use `BEFORE` the same way, and the all-zeros case runs the literal no-base line. Event values reach the script only through `env`. On `pull_request` the checkout is the PR's merge commit, so its tree against the base tip is exactly the PR's change, and a depth-1 fetch is enough because only the two trees are read. On `push`, `BEFORE` against HEAD is the pushed change. A local run with `--base` on a branch that is behind compares trees directly, so upstream changes would show as deletions; the help text says to pass a merge-base, and the no-base default computes one.
+
+**Edge cases.**
+
+- **A whole watched file deleted.** Every block of it is a deleted block.
+- **A watched file renamed.** `--no-renames` makes it a delete plus an add; its unchanged text is in the head blocks of the new path, so every block is moved.
+- **A paragraph reflowed.** Its deleted lines are a substring of the paragraph's own head block, so it is moved, including when some of its lines were left unchanged.
+- **A rule extended in place** ("fail closed on X" becomes "fail closed on X and Y"). The old text is still inside the head block, so it is moved; nothing was lost.
+- **Prose moved into a non-watched file** (for example `docs/`). Not moved; it needs a row, normally `dropped: moved to docs/<file>`.
+- **A spec modified but not added** (a PR that edits an older spec). Not a committed spec; its rows are not read, and old inventories without a `Covering test` column never need retrofitting.
+- **Several committed specs.** Their rows are pooled.
+- **A committed spec at a path outside the spec docs path.** Not read.
+- **Base equals HEAD.** No changed paths, so `skipped("no-prose-deleted")`.
+
+**Error categories.**
+
+| Situation | Exit | Note |
+|---|---|---|
+| Bad `--base` value, unknown flag, extra positional | 2 | usage |
+| Git command fails, merge-base not found | 2 | never a pass |
+| Committed spec unreadable at HEAD, config unreadable | 2 | never a pass |
+| Uncovered block or row error | 1 | lists every one, not just the first |
+| No base resolvable without `--base` | 0 | `skipped`, local only |
+
+**Anti-pattern:** treating a malformed inventory table as "no inventory" and skipping. Why: that turns a typo into a pass. A table whose header has `Prose rule` but no `Disposition` is a row error on its header line.
+
+**Anti-pattern:** reading the spec from the tracker or from `.faff/`. Why: the check must run in CI from the checkout alone; the committed spec is the record.
+
+**Failure modes.**
+
+- **The check is noisy on feature PRs.** Every reworded line of skill prose needs a row, so a feature PR that edits a lot of prose could need many. **How you'd know:** graft forks or reviewers report rows that only say `changed: reworded`, for many PRs in a row. **What it means:** narrow, by revisiting the rewording exemption as its own ticket, not by weakening this check in place.
+- **Anchors drift into fragments.** An author picks a 20-character anchor that sits inside the block but names nothing about the rule. **How you'd know:** review finds rows whose anchor is a stock phrase. **What it means:** proceed; this is a review-quality issue, and the 20-character floor is a floor, not the standard.
+- **An agent PR commits neither a spec nor an anchor.** It would be skipped as a human PR. **How you'd know:** the `::notice::` skip line on a PR that the run ledger or the PR body shows graft opened. **What it means:** graft's `faff spec commit` and `faff pr open` both require their artifacts, so this is a graft defect to file; the long-term fix is the `on-missing: fail` flip above, not a label.
+- **The moved test matches by containment, not meaning.** A short deleted block can appear inside an unrelated head block, and an edit that wraps a rule in new words ("fail closed on X" becoming "never fail closed on X") still contains the old text. **How you'd know:** a review finds a block counted as moved whose meaning changed. **What it means:** proceed; the diff shows the edit to the reviewer, the threat model is forgetting, and a negation is a deliberate edit, not a forgotten rule.
+
+**Scenario fixtures.** Each scenario in section 5 runs against a fixture git repository with a local bare `origin`, `tracking.spec_docs_path: records/specs/` in its config, and a commit on a branch compared with `--base origin/main`.
+
+## 5. SCENARIOS
+
+> 6 holdout scenario(s) withheld from this view — evaluated code-blind against the running feature; full spec on the tracker.
+
+```
+Given a branch that deletes a paragraph from plugin/skills/faff-graft/SKILL.md
+And the branch commits records/specs/2026-11-04-FAFF-9-x-design.md with no "## Rule inventory" section
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 1
+And the JSON result is "fail" with one uncovered entry naming plugin/skills/faff-graft/SKILL.md
+And row_errors names the spec with "no ## Rule inventory section"
+```
+
+```
+Given a branch that deletes two bullets from plugin/skills/faff-prep/SKILL.md
+And commits a spec whose Rule inventory has one row per bullet, each quoting 30 characters of its bullet in a code span
+And each row is "kept" naming an existing test/x.test.mjs
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 0
+And the JSON reports covered_by_row 2 and uncovered []
+```
+
+```
+Given a branch that deletes a paragraph from plugin/skills/faff-graft/SKILL.md and commits no file under records/specs/
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 0
+And skipped_reason is "no-spec-committed"
+```
+
+```
+Given a branch that deletes a paragraph from plugin/skills/faff-graft/SKILL.md
+And adds .faff/anchors/FAFF-9/anchor.json but commits no file under records/specs/
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 1
+And footprint_without_spec is true
+```
+
+```
+Given a branch that deletes a bullet and commits a spec with a valid row for it plus a second "dropped: obsolete" row quoting text that appears in no deleted block
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 0
+And warnings contains "anchor matches no deleted prose"
+```
+
+```
+Given a branch that deletes a bullet and commits a spec whose row for it reads "dropped: ::error::forged"
+When faff rule-inventory check --base origin/main runs
+Then no line of its output starts with "::error::"
+```
+
+```
+Given a branch that deletes two bullets and commits a spec with a "kept" row naming an existing test/x.test.mjs for one and a "dropped: superseded by faff x" row for the other
+When faff rule-inventory check --base origin/main --summary out.md runs
+Then it exits 0
+And the first table row in out.md is the dropped one
+```
+
+```
+Given a branch that deletes a bullet and commits a spec whose row for it is "kept" with an empty Covering test cell
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 1
+And row_errors contains "kept row names no covering test"
+```
+
+```
+Given a branch that changes the text of one heading in plugin/skills/faff-graft/SKILL.md and nothing else
+And commits a spec with an empty Rule inventory table
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 1
+And the uncovered entry is the heading's base line
+```
+
+```
+Given a branch that deletes a bullet and commits a spec larger than 1 MiB
+When faff rule-inventory check --base origin/main runs
+Then it exits 2
+```
+
+```
+Given a branch that deletes a whole "### Example" section of plugin/skills/faff-graft/SKILL.md: its heading and one paragraph
+And commits a spec whose one row quotes 30 characters of the paragraph, "dropped: obsolete example"
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 0
+And blocks_deleted is 1
+```
+
+```
+Given a branch that deletes one line of only "---" from plugin/skills/faff-graft/SKILL.md
+And commits a spec with no Rule inventory section
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 0
+And skipped_reason is "no-prose-deleted"
+```
+
+```
+Given a branch that deletes two bullets, "- Fails loud." and a longer bullet containing "Fails loud." among other words
+And commits a spec whose only row has the anchor "- Fails loud." and "dropped: merged"
+When faff rule-inventory check --base origin/main --json runs
+Then it exits 1
+And the uncovered entry is the longer bullet
+```
+
+```
+Given faff rule-inventory check is run with --base "-x"
+When it runs
+Then it exits 2
+And nothing is printed on stdout
+```
+
+- The check MUST NOT exit 0 when a git command it runs fails.
+
+## 6. DESIGN DECISION RATIONALE
+
+| Decision | Options considered | Outcome |
+|---|---|---|
+| How a deleted block maps to a row | line range (breaks on rebase); quoted anchor (survives rebase); any-row-quotes (same as anchor) | **Chosen:** a quoted code-span anchor of at least 20 characters (or the whole text of a shorter block), matched as a substring of the block's deleted text |
+| Where it runs | `governance-check` (grows Commissaire); `validate-adapters` leg (no base, legacy JS); new command in `validate` | **Chosen:** new TypeScript factory command `faff rule-inventory check`, its own `validate.yml` step beside `regions check` |
+| Pure prose edits | PR label or trailer (no precedent); footprint scope (precedent in `governance.yml`); no exemption | **Chosen:** footprint scope — applies when the PR commits a spec or an anchor, fails an anchor with no spec; no label or trailer |
+| Blocking or report first | block now; warn then block | **Chosen:** block from day one; the format is proven by nine shipped inventories and advisory gates here go unenforced |
+| Base without `--base` | skip; `origin/HEAD`; configured branch (no key exists) | **Chosen:** merge-base with `origin/HEAD`, else skip with `no-base`; CI always passes `--base` |
+| Covering test by disposition | always; `kept` only; never | **Chosen:** `kept` needs at least one test; any named test must exist; `changed`/`dropped` need a reason |
+
+At the time of writing there is no base-branch key in `.faffrc.yaml`; if one is added, the no-base default should read it.
+
+## 7. OPEN QUESTIONS AND ASSUMPTIONS
+
+**Open questions.**
+
+- **Checking the test-repoint rule.** The operator's standing rule lets an extraction PR repoint a test that pinned removed prose, provided the PR carries a guarantee-to-test map and a mutation proof for each guarantee. This check could later verify the map exists and names real tests, using the same table parser.
+  **Punt:** add a `faff rule-inventory tests` verb for the guarantee map, or keep that rule review-only — needs human (decides: product) (non-blocking). See OUT OF SCOPE, "Checking the operator's test-repoint rule". This increment does not depend on it: the prose check stands alone.
+
+**Assumptions.** None open. Two facts were checked against the tree at prep:
+
+- Graft's Step 4 `faff spec commit` commits the builder view to `<spec-docs-path>/YYYY-MM-DD-<issue>-<slug>-design.md` as the branch's first commit. The builder view withholds only holdout scenario blocks (`dodSplit`), so a `## Rule inventory` table reaches the committed spec intact.
+- `validate` is the branch-protection-required check (the FAFF-987 comment in `validate.yml`), so a failing step blocks merge.
+
+## 8. DONE — Definition of Done
+
+### From WHY
+- [ ] A PR that deletes a non-exempt block of skill prose, commits a spec, and has no row or move covering the block fails `faff rule-inventory check` with exit 1, naming the file and base line.
+
+### From WHAT (interfaces)
+- [ ] `faff rule-inventory check [--base REF] [--json] [--summary FILE]` exists, with exits 0 / 1 / 2 as section 3 defines.
+- [ ] `--json` output has every `CheckResult` field.
+- [ ] The inventory format (section heading, `Prose rule` code-span anchor, `Covering test`, `Disposition`) is documented in `docs/reference/skill-authoring.md` under a `Rule inventory` heading, and every uncovered-block message names that anchor.
+- [ ] `plugin/skills/faffter-dark-nlspec/SKILL.md` gains one line telling the producer that a spec deleting skill prose carries a `## Rule inventory` in that format, and `prose-baseline.json` is raised by exactly that file's growth.
+- [ ] The command is TypeScript (`rule-inventory.ts` with its committed `.js` emit and `build-manifest.json`), in the factory region, with `REGION_SELFTEST_ARGV["rule-inventory"] = null`, a `TEST_FILE_COVERAGE` entry for `test/rule-inventory.test.mjs`, and a `docs/guide/cli.md` row; `faff regions check`, `faff lint-cli-coverage` and `faff lint-cli-doc` pass.
+
+### From HOW (behaviour)
+- [ ] A row's anchor covers a block only when it is at least 20 characters and a substring of the block's normalised deleted text, or when it equals that whole text; a short anchor never covers a longer block containing it.
+- [ ] A deleted block whose text sits inside a single head block of any watched file counts as moved, with no row needed, including a reflow that leaves some lines unchanged.
+- [ ] The watched set is `prose-size`'s exported `isCovered`, imported, not a second list.
+- [ ] Path listing uses `-z` with `core.quotePath=false`; a watched-looking path the parser cannot decode exits 2.
+- [ ] A move into a non-watched file is not moved.
+- [ ] Table separator rows and letterless blocks are exempt; a table header row is exempt only when its whole table is deleted, and a heading only when its whole section is deleted.
+- [ ] Normalise deletes `*` and backticks and collapses whitespace, on anchors, deleted text and head blocks alike.
+- [ ] Only specs the diff adds are read; a modified older spec contributes no rows.
+- [ ] A diff that adds or modifies a path under `.faff/anchors/` but commits no spec fails with `footprint_without_spec: true`.
+- [ ] `--summary` escapes markdown metacharacters and HTML in every spec-derived value.
+- [ ] A covering-test path outside `^test/…\.test\.mjs$` or with a `..` segment is a row error and is never looked up.
+- [ ] Every printed line starts with `rule-inventory: `; spec-derived values are stripped of control characters and capped at 200 characters; a committed spec over 1 MiB exits 2.
+- [ ] `--summary FILE` appends the row-covered table, `dropped` and `changed` first, and the CI step passes `$GITHUB_STEP_SUMMARY`.
+- [ ] A row whose anchor matches no deleted block produces the warning `anchor matches no deleted prose` and does not fail the check.
+- [ ] `kept` rows with no test, `changed`/`dropped` rows with no reason, and rows naming a missing test file or a test name absent from the file are row errors.
+- [ ] A PR that commits no spec is `skipped` with `no-spec-committed`; one that deletes no non-exempt prose is `skipped` with `no-prose-deleted`.
+- [ ] Without `--base`, the base is the merge-base with `origin/HEAD`, or the result is `skipped` with `no-base`.
+- [ ] A failing git command, an unreadable committed spec, or a bad `--base` exits 2, never 0.
+- [ ] `validate.yml` runs the check on `pull_request` with `--base origin/$BASE_REF` and on `push` with `BEFORE`, with event values reaching the script only through `env`, an unfetchable `BEFORE` failing the step, and the literal no-base line present for `faff gates discover`.
+
+### From HOW (tests)
+- [ ] `test/rule-inventory.test.mjs` covers each scenario in section 5, each row-error kind and each exemption rule (separator, letterless, header row with and without its whole table, heading with and without its whole section), using fixture repos with a local bare origin, and passes under `node --test`.
+- [ ] A mutation test shows each check bites: removing the anchor-length floor, the kept-needs-test rule, or the moved test each makes at least one case in the file fail.
+
+### Integration smoke test
+
+```
+1. Make a fixture repo with a bare origin; commit a SKILL.md with three bullets to main; push.
+2. Branch; delete bullet two; add records/specs/2026-11-04-FAFF-9-x-design.md with a
+   Rule inventory row quoting bullet two, "kept", naming test/a.test.mjs; add test/a.test.mjs.
+3. Run faff rule-inventory check --base origin/main --json  → exit 0, covered_by_row 1.
+4. Remove the row; run again → exit 1, one uncovered entry for bullet two.
+```
+
+## Methodology critique
+
+*Lens: faffter-dark-methodology-agile-delivery, issue-critique.*
+
+- **Right-sized?** No issues. One command, one CI step, one documented format and a one-line producer pointer is a single 1–3 day unit, and the parts always ship together: the command without the documented format would fail every author with no way to learn the fix.
+- **Workstream fit?** No issues. It is the guardrail for the skill-to-determinism track, which the 2026-10-22 review's extractions created, and it lands before the next batch of extractions rather than after.
+- **Deps surfaced?** No issues. Nothing blocks it. FAFF-1429 and FAFF-1430 are the losses this would have caught; they are related, not blockers, and either can land first.
+- **Risk profile?** Low integration risk; the one real risk is noise on feature PRs that reword prose, which the spec names as a failure mode with its observable and its response. No de-risking spike is warranted: the cost of being wrong is rows, not broken builds.
+
+confidence: high
+build-tier: complex
+admissibility: admissible
+spec-review: accept (human, after round 5)
+
+```faff-contract:spec-readiness
+{ "confidence": "high",
+  "decisions": [
+    { "marker": "chosen" }, { "marker": "chosen" }, { "marker": "chosen" },
+    { "marker": "chosen" }, { "marker": "chosen" }, { "marker": "chosen" },
+    { "marker": "punt" }
+  ] }
+```
diff --git a/test/check-no-boundary-cast.test.mjs b/test/check-no-boundary-cast.test.mjs
index fca28babd..2d59c4845 100644
--- a/test/check-no-boundary-cast.test.mjs
+++ b/test/check-no-boundary-cast.test.mjs
@@ -71,7 +71,7 @@ test("S3: each assertion FORM is detected (not just `as`)", { skip }, () => {
 });
 
 test("S3: realSources() lists the fifteen tsconfig include entries", () => {
-  assert.deepEqual(realSources().map((f) => path.relative(LIB, f)), ["producer-auth.ts", "commissaire.ts", "commissaire-governor-client.ts", "commissaire-trust.ts", "commissaire-verify.ts", "ids.ts", "result.ts", "decision-policy.ts", "governor.ts", "governor-install.ts", "governor-admin.ts", "peer-cred.ts", "prep-attach.ts", "judge-dispositions.ts", "merge-authorize.ts", "graft-admit.ts", "gates-progress.ts", "land.ts", "spec-commit.ts", "run-summary.ts", "run.ts", "run-checkpoint.ts", "prose-size.ts", "run-open.ts", "run-close.ts", "pr-open.ts", "worktree-ensure.ts", "spec-review-round.ts", "spec-review-hold.ts", "run-trigger.ts"]);
+  assert.deepEqual(realSources().map((f) => path.relative(LIB, f)), ["producer-auth.ts", "commissaire.ts", "commissaire-governor-client.ts", "commissaire-trust.ts", "commissaire-verify.ts", "ids.ts", "result.ts", "decision-policy.ts", "governor.ts", "governor-install.ts", "governor-admin.ts", "peer-cred.ts", "prep-attach.ts", "judge-dispositions.ts", "merge-authorize.ts", "graft-admit.ts", "gates-progress.ts", "land.ts", "spec-commit.ts", "run-summary.ts", "run.ts", "run-checkpoint.ts", "prose-size.ts", "rule-inventory.ts", "run-open.ts", "run-close.ts", "pr-open.ts", "worktree-ensure.ts", "spec-review-round.ts", "spec-review-hold.ts", "run-trigger.ts"]);
 });
 
 test("S3: the real cluster sources are clean (exit 0)", { skip }, () => {
diff --git a/test/gates-ci-source.test.mjs b/test/gates-ci-source.test.mjs
index 2f17b33e8..389a43587 100644
--- a/test/gates-ci-source.test.mjs
+++ b/test/gates-ci-source.test.mjs
@@ -159,6 +159,8 @@ test("FAFF-1149: on a Linux host the selected-rung set and discovery are unchang
     "node plugin/skills/faff/bin/faff adr validate",
     "node plugin/skills/faff/bin/faff prdr validate",
     "node plugin/skills/faff/bin/faff regions check",
+    // FAFF-1428: the rule-inventory step's literal no-base line is a local rung, beside regions check.
+    "node plugin/skills/faff/bin/faff rule-inventory check",
     "node --import ./test/hermetic-env.mjs --test",
     "node --import ./test/hermetic-env.mjs --test test/env.test.mjs test/holdout-evaluate-integration.test.mjs",
     // FAFF-1171: the Node 24 typecheck job's source-lane checks are discovered as runnable rungs too.
diff --git a/test/rule-inventory.test.mjs b/test/rule-inventory.test.mjs
new file mode 100644
index 000000000..127366186
--- /dev/null
+++ b/test/rule-inventory.test.mjs
@@ -0,0 +1,892 @@
+// FAFF-1428 — `faff rule-inventory check`: every block of skill prose a branch deletes must be moved
+// verbatim into other skill prose or quoted by a `## Rule inventory` row in a spec the branch adds.
+// Each case builds a fixture git repo with a local bare origin, commits skill prose to main, edits it
+// on a branch and runs the real CLI with `--base origin/main`. A mutation case at the end copies the
+// emitted module, breaks one rule at a time and shows a case here then fails.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { chmodSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO = join(HERE, "..");
+const LIB = join(REPO, "plugin", "skills", "faff", "bin", "lib");
+const CLI = join(REPO, "plugin", "skills", "faff", "bin", "faff");
+const require = createRequire(import.meta.url);
+const ri = require("../plugin/skills/faff/bin/lib/rule-inventory.js");
+
+const GIT_ENV = {
+  ...process.env,
+  GIT_AUTHOR_NAME: "t", GIT_AUTHOR_EMAIL: "t@example.invalid", GIT_COMMITTER_NAME: "t", GIT_COMMITTER_EMAIL: "t@example.invalid",
+  GIT_CONFIG_NOSYSTEM: "1", GIT_TERMINAL_PROMPT: "0",
+};
+
+function sh(cwd, ...args) {
+  const r = spawnSync("git", ["-c", "core.hooksPath=/dev/null", "-c", "commit.gpgsign=false", ...args], { cwd, encoding: "utf8", env: GIT_ENV });
+  if (r.status !== 0) throw new Error(`git ${args.join(" ")}: ${r.stderr}`);
+  return r.stdout;
+}
+
+const GRAFT = `# Graft
+
+## Step one
+
+The first paragraph states that the build always fails closed on an unreadable ledger file.
+
+- Push the branch before review so a stall never costs a rebuild.
+- Tick the heartbeat before and after the gate ladder runs.
+- Fails loud.
+- When the probe is indeterminate it says - Fails loud. and never counts as a pass.
+
+---
+
+| Token | Action |
+|---|---|
+| ready | continue to the next step without asking |
+| park | write the park comment and stop the build |
+| hold | release the claim and requeue the issue |
+
+### Example
+
+An example paragraph that only illustrates the flow for a reader of this file.
+
+## Step two
+
+\`\`\`bash
+faff gates run --json
+\`\`\`
+`;
+
+const PREP = `# Prep
+
+- Stage the spec before rendering it into the conversation, every time.
+- Confirm the attach with the returned comment id after posting.
+`;
+
+const KERNEL = `# Kernel
+
+A long paragraph about the shared rules that every faff skill applies
+when it loads, written across several lines so that it can be reflowed
+without changing a single word of it.
+`;
+
+// A fixture: bare origin + work clone on branch `feat`, main holding the base skill prose.
+function fixture(files = {}) {
+  const root = mkdtempSync(join(tmpdir(), "faff-ri-"));
+  const origin = join(root, "origin.git");
+  const dir = join(root, "work");
+  sh(root, "init", "-q", "--bare", "-b", "main", origin);
+  sh(root, "init", "-q", "-b", "main", dir);
+  sh(dir, "remote", "add", "origin", origin);
+  const base = {
+    ".faff/config.yaml": "tracking:\n    spec_docs_path: records/specs/\n",
+    "plugin/skills/faff-graft/SKILL.md": GRAFT,
+    "plugin/skills/faff-prep/SKILL.md": PREP,
+    "plugin/skills/faff/references/kernel.md": KERNEL,
+    "test/x.test.mjs": 'test("x behaves", () => {});\n',
+    ...files,
+  };
+  const fx = {
+    root, dir,
+    write(p, content) { mkdirSync(dirname(join(dir, p)), { recursive: true }); writeFileSync(join(dir, p), content); return fx; },
+    read(p) { return readFileSync(join(dir, p), "utf8"); },
+    edit(p, from, to) { const s = fx.read(p); assert.ok(s.includes(from), `fixture edit: ${from}`); return fx.write(p, s.replace(from, to)); },
+    rm(p) { rmSync(join(dir, p)); return fx; },
+    commit(msg = "change") { sh(dir, "add", "-A"); sh(dir, "commit", "-q", "--allow-empty", "-m", msg); return fx; },
+    run(args, opts = {}) { return spawnSync(process.execPath, [CLI, "rule-inventory", "check", ...args], { cwd: dir, encoding: "utf8", ...opts }); },
+    json(extra = []) {
+      const r = fx.run(["--base", "origin/main", "--json", ...extra]);
+      return { status: r.status, out: r.stdout ? JSON.parse(r.stdout) : null, stderr: r.stderr };
+    },
+    cleanup() { rmSync(root, { recursive: true, force: true }); },
+  };
+  for (const [p, c] of Object.entries(base)) fx.write(p, c);
+  fx.commit("base");
+  sh(dir, "push", "-q", "origin", "main");
+  sh(dir, "fetch", "-q", "origin");
+  // git 2.48+ creates origin/HEAD on fetch; older git does not. Start every case without it, on any
+  // git version; a case that needs it sets it with `remote set-head`. --no-deref deletes the symref
+  // itself, never refs/remotes/origin/main it points at.
+  sh(dir, "update-ref", "--no-deref", "-d", "refs/remotes/origin/HEAD");
+  sh(dir, "checkout", "-q", "-b", "feat");
+  return fx;
+}
+
+const SPEC = "records/specs/2026-11-04-FAFF-9-x-design.md";
+const spec = (rows, { header = "| Prose rule | Covering test | Disposition |", section = true } = {}) =>
+  `# FAFF-9\n\nIntro.\n\n${section ? "## Rule inventory\n\n" : ""}${header}\n|---|---|---|\n${rows.join("\n")}\n\n## Done\n`;
+const row = (anchor, test, disp) => `| \`${anchor}\` | ${test} | ${disp} |`;
+
+const BULLET1 = "- Push the branch before review so a stall never costs a rebuild.";
+const BULLET2 = "- Tick the heartbeat before and after the gate ladder runs.";
+const PARA = "The first paragraph states that the build always fails closed on an unreadable ledger file.";
+
+test("a deleted paragraph with a committed spec and no inventory section fails, naming the file and the missing section", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, "# FAFF-9\n\nNo inventory.\n").commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.equal(out.result, "fail");
+    assert.equal(out.uncovered.length, 1);
+    assert.equal(out.uncovered[0].file, "plugin/skills/faff-graft/SKILL.md");
+    assert.equal(out.uncovered[0].base_line, 5);
+    assert.deepEqual(out.row_errors, [{ spec: SPEC, line: 1, reason: "no ## Rule inventory section" }]);
+    for (const k of ["result", "skipped_reason", "footprint_without_spec", "base", "specs", "blocks_deleted", "covered_moved", "covered_by_row", "row_covered", "uncovered", "row_errors", "warnings"]) assert.ok(k in out, k);
+    const text = fx.run(["--base", "origin/main"]);
+    assert.match(text.stdout, /^rule-inventory: uncovered plugin\/skills\/faff-graft\/SKILL\.md:5: .*docs\/reference\/skill-authoring\.md#rule-inventory/m);
+  } finally { fx.cleanup(); }
+});
+
+test("two deleted bullets each quoted by a kept row naming an existing test pass", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-prep/SKILL.md", "- Stage the spec before rendering it into the conversation, every time.\n", "")
+      .edit("plugin/skills/faff-prep/SKILL.md", "- Confirm the attach with the returned comment id after posting.\n", "")
+      .write(SPEC, spec([row("Stage the spec before rendering it", "test/x.test.mjs", "kept"), row("Confirm the attach with the returned", "test/x.test.mjs: \"x behaves\"", "kept")]))
+      .commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 0, JSON.stringify(out));
+    assert.equal(out.covered_by_row, 2);
+    assert.deepEqual(out.uncovered, []);
+    assert.deepEqual(out.row_errors, []);
+  } finally { fx.cleanup(); }
+});
+
+test("deleted prose with no spec committed is skipped with no-spec-committed and the fixed notice", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 0);
+    assert.equal(out.result, "skipped");
+    assert.equal(out.skipped_reason, "no-spec-committed");
+    const text = fx.run(["--base", "origin/main"]);
+    assert.equal(text.status, 0);
+    assert.equal(text.stdout.split("\n")[0], "::notice::rule-inventory: skipped, no spec committed");
+  } finally { fx.cleanup(); }
+});
+
+test("an added or modified .faff/anchors/ path with deleted prose and no spec fails with footprint_without_spec", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(".faff/anchors/FAFF-9/anchor.json", "{}\n").commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.equal(out.footprint_without_spec, true);
+    assert.equal(out.result, "fail");
+  } finally { fx.cleanup(); }
+  const fy = fixture({ ".faff/anchors/FAFF-8/anchor.json": "{}\n" });
+  try {
+    fy.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(".faff/anchors/FAFF-8/anchor.json", "{\"v\":2}\n").commit();
+    assert.equal(fy.json().out.footprint_without_spec, true, "a modified anchor is a footprint too");
+  } finally { fy.cleanup(); }
+});
+
+test("a row whose anchor matches no deleted prose warns and does not fail", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "")
+      .write(SPEC, spec([row("Push the branch before review so a stall", "—", "dropped: graft pushes itself"), row("text that appears in no deleted block at all", "—", "dropped: obsolete")]))
+      .commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 0, JSON.stringify(out));
+    assert.ok(out.warnings.some((w) => w.includes("anchor matches no deleted prose")));
+  } finally { fx.cleanup(); }
+});
+
+test("a spec-derived workflow command never starts an output line", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "")
+      .write(SPEC, spec([row("Push the branch before review so a stall", "—", "dropped: ::error::forged"), "| `::error::x` | — | bogus |"]))
+      .commit();
+    const r = fx.run(["--base", "origin/main"]);
+    assert.ok(r.stdout.length > 0);
+    for (const line of r.stdout.split("\n")) assert.ok(!line.startsWith("::error::"), line);
+    for (const line of r.stdout.split("\n").filter(Boolean)) assert.ok(line.startsWith("rule-inventory: "), line);
+  } finally { fx.cleanup(); }
+});
+
+test("--summary appends the row-covered table with dropped rows first", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n${BULLET2}\n`, "")
+      .write(SPEC, spec([row("Push the branch before review so a stall", "test/x.test.mjs", "kept"), row("Tick the heartbeat before and after", "—", "dropped: superseded by faff x")]))
+      .commit();
+    const out = join(fx.root, "out.md");
+    writeFileSync(out, "existing\n");
+    const r = fx.run(["--base", "origin/main", "--summary", out]);
+    assert.equal(r.status, 0, r.stdout);
+    const md = readFileSync(out, "utf8");
+    assert.ok(md.startsWith("existing\n"), "appends");
+    const rows = md.split("\n").filter((l) => l.startsWith("| ") && !l.startsWith("| Disposition"));
+    assert.equal(rows.length, 2);
+    assert.match(rows[0], /^\| dropped \|/);
+    assert.match(rows[1], /^\| kept \|/);
+  } finally { fx.cleanup(); }
+});
+
+test("a kept row with an empty Covering test cell is a row error", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "")
+      .write(SPEC, spec([row("Push the branch before review so a stall", "", "kept")])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.ok(out.row_errors.some((e) => e.reason === "kept row names no covering test"));
+  } finally { fx.cleanup(); }
+});
+
+test("a reworded heading alone is not exempt: it needs a row", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", "## Step one\n", "## Step 1\n").write(SPEC, spec([])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.equal(out.uncovered.length, 1);
+    assert.equal(out.uncovered[0].base_line, 3);
+  } finally { fx.cleanup(); }
+});
+
+test("a committed spec over 1 MiB exits 2", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "").write(SPEC, `# big\n\n${"x".repeat(1024 * 1024 + 10)}\n`).commit();
+    const r = fx.run(["--base", "origin/main"]);
+    assert.equal(r.status, 2);
+    assert.equal(r.stdout, "");
+  } finally { fx.cleanup(); }
+});
+
+test("a whole section deleted counts only its paragraph: the heading is exempt", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", "### Example\n\nAn example paragraph that only illustrates the flow for a reader of this file.\n\n", "")
+      .write(SPEC, spec([row("An example paragraph that only illustrates", "—", "dropped: obsolete example")])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 0, JSON.stringify(out));
+    assert.equal(out.blocks_deleted, 1);
+  } finally { fx.cleanup(); }
+});
+
+test("a deleted thematic break alone is letterless and exempt", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", "---\n\n", "").write(SPEC, "# FAFF-9\n").commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 0);
+    assert.equal(out.skipped_reason, "no-prose-deleted");
+  } finally { fx.cleanup(); }
+});
+
+test("a short anchor covers only a block whose whole text it equals, never a longer block containing it", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", "- Fails loud.\n- When the probe is indeterminate it says - Fails loud. and never counts as a pass.\n", "")
+      .write(SPEC, spec([row("- Fails loud.", "—", "dropped: merged")])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.equal(out.covered_by_row, 1);
+    assert.equal(out.uncovered.length, 1);
+    assert.match(out.uncovered[0].excerpt, /indeterminate/);
+    assert.deepEqual(out.row_errors, []);
+  } finally { fx.cleanup(); }
+});
+
+test("a --base that is not a plain ref exits 2 and prints nothing on stdout", () => {
+  const fx = fixture();
+  try {
+    for (const bad of ["-x", "a;b", "main^", "nope/not-a-ref"]) {
+      const r = fx.run(["--base", bad]);
+      assert.equal(r.status, 2, bad);
+      assert.equal(r.stdout, "", bad);
+    }
+    assert.equal(fx.run(["--bogus"]).status, 2);
+    assert.equal(fx.run(["--base", "origin/main", "extra"]).status, 2);
+  } finally { fx.cleanup(); }
+});
+
+test("row errors: no code span, short anchor, bad disposition, empty reason, bad or missing test path, absent test name", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "")
+      .write(SPEC, spec([
+        "| no code span here | — | dropped: x |",
+        row("too short", "—", "dropped: x"),
+        row("Push the branch before review so a stall", "—", "moved"),
+        row("Push the branch before review so a stall", "—", "changed:   "),
+        row("Push the branch before review so a stall", "src/a.js", "kept"),
+        row("Push the branch before review so a stall", "test/../escape.test.mjs", "kept"),
+        row("Push the branch before review so a stall", "test/missing.test.mjs", "kept"),
+        row("Push the branch before review so a stall", "test/x.test.mjs: \"no such test\"", "kept"),
+      ])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    const reasons = out.row_errors.map((e) => `${e.line}:${e.reason}`);
+    const has = (re) => assert.ok(reasons.some((r) => re.test(r)), `${re} in ${JSON.stringify(reasons)}`);
+    has(/^9:Prose rule cell has no code-span anchor$/);
+    has(/^10:anchor shorter than 20 characters$/);
+    has(/^11:disposition is not kept/);
+    has(/^12:changed row gives no reason$/);
+    has(/^13:covering test src\/a\.js is not a test\/<path>\.test\.mjs path$/);
+    has(/^14:covering test test\/\.\.\/escape\.test\.mjs is not a test/);
+    has(/^15:covering test test\/missing\.test\.mjs does not exist$/);
+    has(/^16:covering test test\/x\.test\.mjs has no test named "no such test"$/);
+    // Line numbers point at the spec line, so the text output names spec:line.
+    assert.match(fx.run(["--base", "origin/main"]).stdout, new RegExp(`^rule-inventory: row-error ${SPEC.replace(/[.]/g, "\\.")}:12: `, "m"));
+  } finally { fx.cleanup(); }
+});
+
+test("an inventory table header with a Prose rule column but no Disposition column is a row error, never a skip", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "")
+      .write(SPEC, spec([row("Push the branch before review so a stall", "—", "dropped: x")], { header: "| Prose rule | Covering test | Outcome |" })).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.ok(out.row_errors.some((e) => /needs both a Prose rule and a Disposition column/.test(e.reason)));
+    assert.equal(out.uncovered.length, 1);
+  } finally { fx.cleanup(); }
+});
+
+test("a qualified header (`Prose rule (§2)`) is read; a kept row in a table with no Covering test column is a row error", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n${BULLET2}\n`, "")
+      .write(SPEC, "# F\n\n## Rule inventory (slice A)\n\n| # | Prose rule (§2) | Disposition |\n|---|---|---|\n" +
+        "| 1 | `Push the branch before review so a stall` | **dropped:** graft pushes |\n| 2 | `Tick the heartbeat before and after` | `kept` |\n").commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.equal(out.covered_by_row, 1);
+    assert.ok(out.row_errors.some((e) => e.reason === "a table with a kept row needs a Covering test column"));
+  } finally { fx.cleanup(); }
+});
+
+test("exemptions: separator rows are exempt; a header row is exempt only with its whole table", () => {
+  const whole = "| Token | Action |\n|---|---|\n| ready | continue to the next step without asking |\n| park | write the park comment and stop the build |\n| hold | release the claim and requeue the issue |\n\n";
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", whole, "")
+      .write(SPEC, spec([row("continue to the next step without", "—", "dropped: a"), row("write the park comment and stop", "—", "dropped: b"), row("release the claim and requeue", "—", "dropped: c")]))
+      .commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 0, JSON.stringify(out));
+    assert.equal(out.blocks_deleted, 3, "three data rows; header and separator exempt");
+  } finally { fx.cleanup(); }
+  const fy = fixture();
+  try {
+    fy.edit("plugin/skills/faff-graft/SKILL.md", "| Token | Action |\n", "| Token | What to do |\n").write(SPEC, spec([])).commit();
+    const { status, out } = fy.json();
+    assert.equal(status, 1);
+    assert.equal(out.uncovered.length, 1, "a header row reworded on its own needs a row");
+    assert.equal(out.uncovered[0].base_line, 14);
+  } finally { fy.cleanup(); }
+  const fz = fixture();
+  try {
+    fz.edit("plugin/skills/faff-graft/SKILL.md", "| hold | release the claim and requeue the issue |\n", "").write(SPEC, spec([])).commit();
+    const { out } = fz.json();
+    assert.equal(out.blocks_deleted, 1, "one data row, its table's header kept");
+  } finally { fz.cleanup(); }
+});
+
+test("text moved verbatim into another skill file, or reflowed in place, is moved and needs no row", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-prep/SKILL.md", "- Confirm the attach with the returned comment id after posting.\n", "")
+      .edit("plugin/skills/faff-graft/SKILL.md", "## Step two\n", "## Step two\n\n- Confirm the attach with the returned comment id after posting.\n")
+      .edit("plugin/skills/faff/references/kernel.md", "applies\nwhen it loads, written across several lines so that it can be reflowed\n", "applies when it\nloads, written across several lines so that it can be reflowed\n")
+      .write(SPEC, "# FAFF-9\n\nNo inventory needed.\n").commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 0, JSON.stringify(out));
+    assert.equal(out.covered_moved, 2);
+    assert.deepEqual(out.row_errors, []);
+  } finally { fx.cleanup(); }
+});
+
+test("text moved into a non-watched file is not moved", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-prep/SKILL.md", "- Confirm the attach with the returned comment id after posting.\n", "")
+      .write("docs/guide/prep.md", "- Confirm the attach with the returned comment id after posting.\n")
+      .write(SPEC, spec([])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.equal(out.uncovered[0].file, "plugin/skills/faff-prep/SKILL.md");
+  } finally { fx.cleanup(); }
+});
+
+test("only specs the diff adds are read: an older spec the branch modifies contributes no rows", () => {
+  const fx = fixture({ "records/specs/2026-01-01-FAFF-1-old-design.md": spec([row("Push the branch before review so a stall", "—", "dropped: x")]) });
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "").edit("records/specs/2026-01-01-FAFF-1-old-design.md", "Intro.", "Intro, edited.").commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 0);
+    assert.equal(out.skipped_reason, "no-spec-committed");
+    assert.deepEqual(out.specs, []);
+  } finally { fx.cleanup(); }
+});
+
+test("without --base: merge-base with origin/HEAD, else skipped no-base", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, spec([])).commit();
+    const none = fx.run(["--json"]);
+    assert.equal(none.status, 0);
+    assert.equal(JSON.parse(none.stdout).skipped_reason, "no-base");
+    sh(fx.dir, "remote", "set-head", "origin", "main");
+    sh(fx.dir, "fetch", "-q", "origin");
+    const withHead = fx.run(["--json"]);
+    assert.equal(withHead.status, 1);
+    const out = JSON.parse(withHead.stdout);
+    assert.equal(out.base, sh(fx.dir, "rev-parse", "origin/main").trim());
+    assert.equal(out.uncovered.length, 1);
+  } finally { fx.cleanup(); }
+});
+
+test("a failing git command exits 2, never 0", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, spec([])).commit();
+    const real = (args, input) => {
+      const r = spawnSync("git", ["-c", "core.quotePath=false", ...args], { cwd: fx.dir, input });
+      return { status: r.status ?? 128, stdout: r.stdout, stderr: String(r.stderr) };
+    };
+    for (const breaks of ["diff", "cat-file", "ls-tree"]) {
+      const git = (args, input) => (args[0] === breaks ? { status: 128, stdout: Buffer.alloc(0), stderr: "fatal: broken" } : real(args, input));
+      assert.throws(() => ri.check({ repo: fx.dir, base: "origin/main", git }), ri.CheckError, breaks);
+    }
+    assert.equal(fx.run(["--base", "refs/heads/nonexistent"]).status, 2);
+    const notRepo = mkdtempSync(join(tmpdir(), "faff-ri-norepo-"));
+    try { assert.equal(spawnSync(process.execPath, [CLI, "rule-inventory", "check"], { cwd: notRepo, encoding: "utf8", env: { ...GIT_ENV, GIT_CEILING_DIRECTORIES: dirname(notRepo) } }).status, 2); } finally { rmSync(notRepo, { recursive: true, force: true }); }
+  } finally { fx.cleanup(); }
+});
+
+test("an unreadable config exits 2, never a pass", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, spec([])).write(".faff/config.yaml", "- not\n- a mapping\n").commit();
+    const r = fx.run(["--base", "origin/main"]);
+    assert.equal(r.status, 2, r.stdout + r.stderr);
+    assert.equal(r.stdout, "");
+  } finally { fx.cleanup(); }
+});
+
+test("a changed path under plugin/skills/ that is not valid UTF-8 is an error, never a skip", () => {
+  const bad = Buffer.concat([Buffer.from("M\0plugin/skills/x/SKILL"), Buffer.from([0xff, 0xfe]), Buffer.from(".md\0")]);
+  assert.throws(() => ri.parseNameStatus(bad), ri.CheckError);
+  const other = Buffer.concat([Buffer.from("M\0docs/"), Buffer.from([0xff]), Buffer.from(".md\0A\0plugin/skills/x/SKILL.md\0")]);
+  assert.deepEqual(ri.parseNameStatus(other).map((c) => c.status), ["X", "A"]);
+});
+
+test("normalise, clean and mdEscape", () => {
+  assert.equal(ri.normalise("  **Fail** `closed`\n  on\terror  "), "Fail closed on error");
+  assert.equal(ri.clean("a\u001b[31mb\nc"), "a [31mb c");
+  assert.equal(Array.from(ri.clean("x".repeat(500))).length, 200);
+  const e = ri.mdEscape("x | ![p](https://example.invalid/p.png) <b>&# _*`\\");
+  assert.ok(!/(^|[^\\])!\[/.test(e), e);
+  assert.ok(!/(^|[^\\])\|/.test(e), e);
+  assert.ok(!e.includes("<") && !e.includes(">"), e);
+  assert.match(e, /&amp;\\#/);
+});
+
+test("splitRow, firstCodeSpan and parseTests", () => {
+  assert.deepEqual(ri.splitRow("| a \\| b | `c` |"), ["a | b", "`c`"]);
+  assert.equal(ri.firstCodeSpan("x `` a `b` c `` y `z`"), "a `b` c");
+  assert.equal(ri.firstCodeSpan("no span"), null);
+  assert.deepEqual(ri.parseTests('test/a.test.mjs: "n, m"; test/b.test.mjs').tests, [{ file: "test/a.test.mjs", name: "n, m" }, { file: "test/b.test.mjs", name: null }]);
+  assert.deepEqual(ri.parseTests("—").tests, []);
+});
+
+test("the CLI registration: a factory command with no selftest", () => {
+  const regions = require("../plugin/skills/faff/bin/lib/regions.js");
+  const map = regions.REGION_MAP ?? {};
+  const argv = regions.REGION_SELFTEST_ARGV ?? {};
+  if (Object.keys(map).length) assert.equal(map["rule-inventory"], "factory");
+  if (Object.keys(argv).length) assert.equal(argv["rule-inventory"], null);
+  const r = spawnSync(process.execPath, [CLI, "rule-inventory"], { encoding: "utf8" });
+  assert.equal(r.status, 2);
+});
+
+// --- Review round 1 (FAFF-1428): each case closes an escape the first build allowed. ---------------
+
+const EXAMPLE_HEAD = "### Example\n";
+const EXAMPLE_PARA = "An example paragraph that only illustrates the flow for a reader of this file.";
+
+test("a binary or -diff attribute, or a NUL byte at HEAD, never hides a deletion (review: binary diff)", () => {
+  for (const [label, extra, nul] of [
+    ["*.md -diff attribute", { ".gitattributes": "*.md -diff\n" }, false],
+    ["SKILL.md binary attribute", { ".gitattributes": "SKILL.md binary\n" }, false],
+    ["NUL byte at HEAD", {}, true],
+  ]) {
+    const fx = fixture(extra);
+    try {
+      fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, nul ? "\u0000\n\n" : "").write(SPEC, spec([])).commit();
+      const { status, out, stderr } = fx.json();
+      assert.equal(status, 1, `${label}: ${stderr}`);
+      assert.equal(out.uncovered.length, 1, label);
+      assert.equal(out.uncovered[0].base_line, 5, label);
+    } finally { fx.cleanup(); }
+  }
+});
+
+test("a watched file whose diff has no text hunk is an error, never a skip (review: binary diff)", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, spec([])).commit();
+    const real = (args, input) => {
+      const r = spawnSync("git", ["-c", "core.quotePath=false", ...args], { cwd: fx.dir, input });
+      return { status: r.status ?? 128, stdout: r.stdout, stderr: String(r.stderr) };
+    };
+    for (const fake of ["Binary files a/x and b/x differ\n", "diff --git a/x b/x\nindex 1..2 100644\n"]) {
+      const git = (args, input) => (args.includes("-U0") ? { status: 0, stdout: Buffer.from(fake), stderr: "" } : real(args, input));
+      assert.throws(() => ri.check({ repo: fx.dir, base: "origin/main", git }), ri.CheckError, fake);
+    }
+  } finally { fx.cleanup(); }
+});
+
+test("a mode-only change or an empty watched file's deletion deletes nothing; a content change with no hunk still exits 2 (review round 2: no-hunk guard)", () => {
+  const fx = fixture({ "plugin/skills/faff-empty/SKILL.md": "" });
+  try {
+    chmodSync(join(fx.dir, "plugin/skills/faff-graft/SKILL.md"), 0o755);
+    fx.rm("plugin/skills/faff-empty/SKILL.md").write(SPEC, spec([])).commit();
+    const { status, out, stderr } = fx.json();
+    assert.equal(status, 0, stderr);
+    assert.equal(out.skipped_reason, "no-prose-deleted");
+  } finally { fx.cleanup(); }
+  const fy = fixture();
+  try {
+    fy.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, spec([])).commit();
+    const real = (args, input) => {
+      const r = spawnSync("git", ["-c", "core.quotePath=false", ...args], { cwd: fy.dir, input });
+      return { status: r.status ?? 128, stdout: r.stdout, stderr: String(r.stderr) };
+    };
+    const git = (args, input) => (args.includes("-U0") ? { status: 0, stdout: Buffer.from("diff --git a/x b/x\nold mode 100644\nnew mode 100755\n"), stderr: "" } : real(args, input));
+    assert.throws(() => ri.check({ repo: fy.dir, base: "origin/main", git }), ri.CheckError, "content changed, no hunk");
+  } finally { fy.cleanup(); }
+});
+
+test("a heading deleted alone while its one-line paragraph is edited is not exempt (review round 2: pure members)", () => {
+  const fx = fixture({ "plugin/skills/faff-prep/SKILL.md": "# Prep\n\n### Never rebase main\n\nRebasing main rewrites history that every open branch was cut from.\n\n### Next\n\nMore text here for the reader of the prep skill.\n" });
+  try {
+    fx.edit("plugin/skills/faff-prep/SKILL.md", "### Never rebase main\n", "")
+      .edit("plugin/skills/faff-prep/SKILL.md", "was cut from.", "was cut from!")
+      .write(SPEC, spec([row("Rebasing main rewrites history that", "—", "changed: punctuation")])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1, JSON.stringify(out));
+    assert.deepEqual(out.uncovered.map((u) => u.base_line), [3]);
+  } finally { fx.cleanup(); }
+});
+
+test("a reworded heading over a partly edited section is not exempt (review: section exemption)", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", EXAMPLE_HEAD, "### Merging\n")
+      .edit("plugin/skills/faff-graft/SKILL.md", EXAMPLE_PARA, EXAMPLE_PARA.replace("reader", "Reader"))
+      .write(SPEC, spec([row("An example paragraph that only illustrates", "—", "changed: capitalised")])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1, JSON.stringify(out));
+    assert.equal(out.uncovered.length, 1);
+    assert.equal(out.uncovered[0].base_line, 20, "the heading's base line");
+  } finally { fx.cleanup(); }
+});
+
+test("a renamed table header is not exempt when the table's rows reappear (review: table exemption)", () => {
+  const fx = fixture();
+  try {
+    const g = fx.read("plugin/skills/faff-graft/SKILL.md")
+      .replace("| Token | Action |\n|---|---|\n", "| Signal | Action | Note |\n|---|---|---|\n")
+      .replace("| ready | continue to the next step without asking |", "| ready | continue to the next step without asking | x |")
+      .replace("| park | write the park comment and stop the build |", "| park | write the park comment and stop the build | y |")
+      .replace("| hold | release the claim and requeue the issue |", "| hold | release the claim and requeue the issue | z |");
+    fx.write("plugin/skills/faff-graft/SKILL.md", g).write(SPEC, spec([])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1, JSON.stringify(out));
+    assert.equal(out.covered_moved, 3, "data rows reappear inside the widened rows");
+    assert.deepEqual(out.uncovered.map((u) => u.base_line), [14], "the header row needs a row");
+  } finally { fx.cleanup(); }
+});
+
+test("a section moved to another skill under a new heading is not exempt: its old heading needs a row (review: section exemption)", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${EXAMPLE_HEAD}\n${EXAMPLE_PARA}\n\n`, "")
+      .write("plugin/skills/faff-prep/SKILL.md", `${fx.read("plugin/skills/faff-prep/SKILL.md")}\n### Illustration\n\n${EXAMPLE_PARA}\n`)
+      .write(SPEC, spec([])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1, JSON.stringify(out));
+    assert.equal(out.covered_moved, 1);
+    assert.deepEqual(out.uncovered.map((u) => u.base_line), [20]);
+  } finally { fx.cleanup(); }
+});
+
+test("a heading with an empty section is not exempt when deleted (review: empty section)", () => {
+  const fx = fixture({ "plugin/skills/faff-prep/SKILL.md": "# Prep\n\n### A\n\n### B\n\nSome text under the second heading for a reader.\n" });
+  try {
+    fx.edit("plugin/skills/faff-prep/SKILL.md", "### A\n\n", "").write(SPEC, spec([])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1, JSON.stringify(out));
+    assert.deepEqual(out.uncovered.map((u) => u.base_line), [3]);
+  } finally { fx.cleanup(); }
+});
+
+test("a covering test that is a directory at HEAD does not exist (review: cat-file -t)", () => {
+  const fx = fixture({ "test/dir.test.mjs/inner.txt": "not a test file\n" });
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "")
+      .write(SPEC, spec([row("Push the branch before review so a stall", "test/dir.test.mjs", "kept")])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1);
+    assert.ok(out.row_errors.some((e) => e.reason === "covering test test/dir.test.mjs does not exist"), JSON.stringify(out.row_errors));
+  } finally { fx.cleanup(); }
+});
+
+test("spec_docs_path is normalised: ./records/specs/ finds the spec; an absolute path exits 2 (review: spec_docs_path)", () => {
+  const fx = fixture({ ".faff/config.yaml": "tracking:\n    spec_docs_path: ./records/specs/\n" });
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, "# FAFF-9\n\nNo inventory.\n").commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1, JSON.stringify(out));
+    assert.deepEqual(out.specs, [SPEC]);
+    fx.write(".faff/config.yaml", "tracking:\n    spec_docs_path: /abs/specs/\n").commit("abs");
+    const r = fx.run(["--base", "origin/main"]);
+    assert.equal(r.status, 2);
+    assert.equal(r.stdout, "");
+  } finally { fx.cleanup(); }
+});
+
+test("a watched path with glob characters is matched literally (review: literal pathspecs)", () => {
+  // `f[a]` as a glob pathspec also matches `fa`, so without --literal-pathspecs fa's hunks would be
+  // read against f[a]'s base text and report a deletion f[a] never had.
+  const fx = fixture({
+    "plugin/skills/f[a]/SKILL.md": "# F\n\nA paragraph in the skill whose directory name holds glob characters.\n",
+    "plugin/skills/fa/SKILL.md": "# F\n\nA paragraph in the plain sibling skill that this branch deletes outright.\n",
+  });
+  try {
+    fx.edit("plugin/skills/fa/SKILL.md", "A paragraph in the plain sibling skill that this branch deletes outright.\n", "")
+      .edit("plugin/skills/f[a]/SKILL.md", "holds glob characters.\n", "holds glob characters.\n\nAn added paragraph.\n")
+      .write(SPEC, spec([])).commit();
+    const { status, out } = fx.json();
+    assert.equal(status, 1, JSON.stringify(out));
+    assert.deepEqual(out.uncovered.map((u) => u.file), ["plugin/skills/fa/SKILL.md"]);
+    assert.equal(out.blocks_deleted, 1, "f[a] deleted nothing");
+    assert.equal(out.covered_moved, 0);
+  } finally { fx.cleanup(); }
+});
+
+// --- Holdout gap (FAFF-1428 scenarios:21): no failing git call may end in exit 0. ---------------
+
+const REAL_GIT = spawnSync("sh", ["-c", "command -v git"], { encoding: "utf8" }).stdout.trim();
+
+// A PATH `git` wrapper: counts every call in $GITWRAP_COUNT, and fails (exit 128) the call whose
+// arguments contain $GITWRAP_MATCH, or the $GITWRAP_NTH-th call.
+function gitWrapper() {
+  const bin = mkdtempSync(join(tmpdir(), "faff-ri-gitwrap-"));
+  writeFileSync(join(bin, "git"), `#!/bin/sh
+n=$(( $(cat "$GITWRAP_COUNT" 2>/dev/null || echo 0) + 1 )); echo "$n" > "$GITWRAP_COUNT"
+if [ -n "$GITWRAP_LOG" ]; then printf '%s\t%s\n' "$n" "$*" >> "$GITWRAP_LOG"; fi
+if [ -n "$GITWRAP_MATCH" ]; then case " $* " in *"$GITWRAP_MATCH"*) echo "fatal: injected failure" >&2; exit 128;; esac; fi
+if [ -n "$GITWRAP_NTH" ] && [ "$n" = "$GITWRAP_NTH" ]; then echo "fatal: injected failure" >&2; exit 128; fi
+exec ${JSON.stringify(REAL_GIT)} "$@"
+`);
+  chmodSync(join(bin, "git"), 0o755);
+  return bin;
+}
+
+// A linked worktree whose config lives only (untracked) in the main checkout, with
+// tracking.spec_docs_path: design/specs/. The branch deletes a paragraph and commits a spec with no inventory.
+function linkedWorktree() {
+  const fx = fixture();
+  sh(fx.dir, "checkout", "-q", "main");
+  sh(fx.dir, "rm", "-q", "--cached", ".faff/config.yaml");
+  sh(fx.dir, "commit", "-q", "-m", "untrack config");
+  sh(fx.dir, "push", "-q", "origin", "main");
+  sh(fx.dir, "fetch", "-q", "origin");
+  sh(fx.dir, "update-ref", "--no-deref", "-d", "refs/remotes/origin/HEAD"); // as in fixture(): absent on any git version
+  writeFileSync(join(fx.dir, ".faff/config.yaml"), "tracking:\n    spec_docs_path: design/specs/\n");
+  const wt = join(fx.root, "wt");
+  sh(fx.dir, "worktree", "add", "-q", "-b", "feat2", wt, "main");
+  const g = readFileSync(join(wt, "plugin/skills/faff-graft/SKILL.md"), "utf8");
+  writeFileSync(join(wt, "plugin/skills/faff-graft/SKILL.md"), g.replace(`${PARA}\n\n`, "").replace(`${BULLET1}\n`, ""));
+  mkdirSync(join(wt, "design/specs"), { recursive: true });
+  writeFileSync(join(wt, "design/specs/2026-11-04-FAFF-9-x-design.md"),
+    spec([row("Push the branch before review so a stall", "test/x.test.mjs", "kept")]));
+  sh(wt, "add", "-A");
+  sh(wt, "commit", "-q", "-m", "change");
+  return { fx, wt };
+}
+
+function runWrapped(cwd, bin, env, args = ["--base", "origin/main", "--json"]) {
+  const count = join(bin, "count");
+  const log = join(bin, "log");
+  rmSync(count, { force: true });
+  rmSync(log, { force: true });
+  const r = spawnSync(process.execPath, [CLI, "rule-inventory", "check", ...args], {
+    cwd, encoding: "utf8", env: { ...process.env, PATH: `${bin}:${process.env.PATH}`, GITWRAP_COUNT: count, GITWRAP_LOG: log, GITWRAP_MATCH: "", GITWRAP_NTH: "", ...env },
+  });
+  let calls = 0;
+  try { calls = Number(readFileSync(count, "utf8").trim()); } catch { calls = 0; }
+  let commands = [];
+  try { commands = readFileSync(log, "utf8").split("\n").filter(Boolean).map((l) => l.split("\t")[1] ?? ""); } catch { commands = []; }
+  return { ...r, calls, commands };
+}
+
+// FAFF-1463: the shared config lookup's main-checkout probe (`git -C <root> rev-parse --git-common-dir`)
+// raises MainWorktreeProbeError on failure, and the dispatch arm prints this one line.
+const PROBE_CALL = (cmd) => /^-C \S.* rev-parse --git-common-dir$/.test(cmd);
+const probeLine = (root) => `faff rule-inventory: cannot proceed — git could not resolve the main checkout for ${root}: fatal: injected failure`;
+
+test("a failed main-checkout lookup in the shared config resolution exits 2, never a no-spec skip (holdout scenarios:21)", () => {
+  const { fx, wt } = linkedWorktree();
+  const bin = gitWrapper();
+  try {
+    const healthy = runWrapped(wt, bin, {});
+    assert.equal(healthy.status, 1, healthy.stdout + healthy.stderr);
+    assert.deepEqual(JSON.parse(healthy.stdout).specs, ["design/specs/2026-11-04-FAFF-9-x-design.md"]);
+    const broken = runWrapped(wt, bin, { GITWRAP_MATCH: "rev-parse --git-common-dir" });
+    assert.equal(broken.status, 2, broken.stdout + broken.stderr);
+    assert.equal(broken.stdout, "");
+    assert.deepEqual(broken.stderr.split("\n").filter(Boolean), [probeLine(wt)]);
+  } finally { fx.cleanup(); rmSync(bin, { recursive: true, force: true }); }
+});
+
+test("a lost overlay fallback in a linked worktree exits 2 (FAFF-1463 shared lookup)", () => {
+  const fx = fixture();
+  try {
+    writeFileSync(join(fx.dir, ".faff/config.local.yaml"), "tracking:\n    spec_docs_path: design/specs/\n");
+    const wt = join(fx.root, "wt");
+    sh(fx.dir, "worktree", "add", "-q", "-b", "feat2", wt, "main");
+    const g = readFileSync(join(wt, "plugin/skills/faff-graft/SKILL.md"), "utf8");
+    writeFileSync(join(wt, "plugin/skills/faff-graft/SKILL.md"), g.replace(`${PARA}\n\n`, ""));
+    mkdirSync(join(wt, "design/specs"), { recursive: true });
+    writeFileSync(join(wt, "design/specs/2026-11-04-FAFF-9-x-design.md"), "# FAFF-9\n\nNo inventory.\n");
+    sh(wt, "add", "-A");
+    sh(wt, "commit", "-q", "-m", "change");
+    const bin = gitWrapper();
+    try {
+      const healthy = runWrapped(wt, bin, {});
+      assert.equal(healthy.status, 1, healthy.stdout + healthy.stderr);
+      assert.deepEqual(JSON.parse(healthy.stdout).specs, ["design/specs/2026-11-04-FAFF-9-x-design.md"], "the overlay in the main checkout sets the spec docs path");
+      const broken = runWrapped(wt, bin, { GITWRAP_MATCH: "rev-parse --git-common-dir" });
+      assert.equal(broken.status, 2, broken.stdout + broken.stderr);
+      assert.equal(broken.stdout, "");
+    } finally { rmSync(bin, { recursive: true, force: true }); }
+  } finally { fx.cleanup(); }
+});
+
+test("from a passing run, failing any single git call exits 2, with and without --base (holdout scenarios:21)", () => {
+  const fx = fixture();
+  const bin = gitWrapper();
+  try {
+    sh(fx.dir, "remote", "set-head", "origin", "main");
+    chmodSync(join(fx.dir, "plugin/skills/faff-prep/SKILL.md"), 0o755);
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "")
+      .write(SPEC, spec([row("Push the branch before review so a stall", "test/x.test.mjs: \"x behaves\"", "kept")])).commit();
+    const probes = [];
+    const mismatches = [];
+    for (const args of [["--base", "origin/main", "--json"], ["--json"]]) {
+      const healthy = runWrapped(fx.dir, bin, {}, args);
+      assert.equal(healthy.status, 0, `${args.join(" ")}: ${healthy.stdout}${healthy.stderr}`);
+      assert.equal(JSON.parse(healthy.stdout).result, "pass");
+      const reached = healthy.commands.join("\n");
+      assert.match(reached, /ls-tree -z \S+ -- plugin\/skills\/faff-prep\/SKILL\.md/, "the mode-only file reaches the blob comparison");
+      assert.match(reached, /ls-tree -z HEAD -- test\/x\.test\.mjs/, "the covering test reaches the blob lookup");
+      if (args.length === 1) assert.match(reached, /for-each-ref .*refs\/remotes\/origin\/HEAD/, "no --base reaches the origin/HEAD probe");
+      for (let n = 1; n <= healthy.calls; n++) {
+        const cmd = healthy.commands[n - 1] ?? "";
+        const r = runWrapped(fx.dir, bin, { GITWRAP_NTH: String(n) }, args);
+        const at = `${args.join(" ")}: failing call ${n} (git ${cmd})`;
+        if (r.status !== 2) mismatches.push(`${at} exited ${r.status}, not 2`);
+        if (r.stdout !== "") mismatches.push(`${at} wrote stdout: ${JSON.stringify(r.stdout.slice(0, 200))}`);
+        if (PROBE_CALL(cmd)) {
+          const lines = r.stderr.split("\n").filter(Boolean);
+          if (JSON.stringify(lines) !== JSON.stringify([probeLine(fx.dir)])) mismatches.push(`${at} stderr ${JSON.stringify(lines)}, not the one dispatch line`);
+          probes.push(`${args.join(" ")} #${n}`);
+        }
+      }
+    }
+    // Collected, then asserted once, so one run reports every failing call.
+    assert.deepEqual(mismatches, []);
+    // Pinned so a change on either side is noticed: the shared main-checkout probe runs once per run.
+    assert.equal(probes.length, 2, probes.join("\n"));
+  } finally { fx.cleanup(); rmSync(bin, { recursive: true, force: true }); }
+});
+
+test("without --base, the merge-base uses the full refs/remotes/origin/HEAD, never a local branch named origin/HEAD (review round 3)", () => {
+  const fx = fixture();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, spec([])).commit();
+    sh(fx.dir, "remote", "set-head", "origin", "main");
+    sh(fx.dir, "update-ref", "refs/heads/origin/HEAD", "HEAD");
+    const r = fx.run(["--json"]);
+    assert.equal(r.status, 1, r.stdout + r.stderr);
+    assert.equal(JSON.parse(r.stdout).base, sh(fx.dir, "rev-parse", "refs/remotes/origin/main").trim());
+  } finally { fx.cleanup(); }
+});
+
+test("without --base, a failing origin/HEAD lookup is an error, not a no-base skip (holdout scenarios:21)", () => {
+  const fx = fixture();
+  const bin = gitWrapper();
+  try {
+    fx.edit("plugin/skills/faff-graft/SKILL.md", `${PARA}\n\n`, "").write(SPEC, spec([])).commit();
+    const count = join(bin, "count");
+    const env = { ...process.env, PATH: `${bin}:${process.env.PATH}`, GITWRAP_COUNT: count, GITWRAP_NTH: "" };
+    const ok = spawnSync(process.execPath, [CLI, "rule-inventory", "check", "--json"], { cwd: fx.dir, encoding: "utf8", env: { ...env, GITWRAP_MATCH: "" } });
+    assert.equal(JSON.parse(ok.stdout).skipped_reason, "no-base");
+    const bad = spawnSync(process.execPath, [CLI, "rule-inventory", "check", "--json"], { cwd: fx.dir, encoding: "utf8", env: { ...env, GITWRAP_MATCH: "refs/remotes/origin/HEAD" } });
+    assert.equal(bad.status, 2, bad.stdout + bad.stderr);
+  } finally { fx.cleanup(); rmSync(bin, { recursive: true, force: true }); }
+});
+
+// --- Mutation proof: each rule bites. -------------------------------------------------------------
+function mutant(from, to) {
+  const src = readFileSync(join(LIB, "rule-inventory.js"), "utf8");
+  assert.ok(src.includes(from), `mutation anchor not found: ${from}`);
+  const dir = mkdtempSync(join(tmpdir(), "faff-ri-mut-"));
+  const body = src.replace(from, to).replace(/require\("\.\/([^"]+)"\)/g, (_m, mod) => `require(${JSON.stringify(join(LIB, mod))})`);
+  const file = join(dir, "rule-inventory.js");
+  writeFileSync(file, body);
+  return { mod: require(file), dir };
+}
+
+test("mutations: dropping the anchor-length floor, the kept-needs-test rule or the moved test each fail a case", () => {
+  const cases = [
+    {
+      name: "anchor-length floor",
+      mutate: ["const MIN_ANCHOR = 20;", "const MIN_ANCHOR = 0;"],
+      setup: (fx) => fx.edit("plugin/skills/faff-graft/SKILL.md", "- Fails loud.\n- When the probe is indeterminate it says - Fails loud. and never counts as a pass.\n", "")
+        .write(SPEC, spec([row("- Fails loud.", "—", "dropped: merged")])).commit(),
+      expect: (r) => r.result === "fail" && r.uncovered.length === 1,
+    },
+    {
+      name: "kept needs a test",
+      mutate: ['if (row.disposition === "kept" && row.tests.length === 0)', "if (false)"],
+      setup: (fx) => fx.edit("plugin/skills/faff-graft/SKILL.md", `${BULLET1}\n`, "")
+        .write(SPEC, spec([row("Push the branch before review so a stall", "", "kept")])).commit(),
+      expect: (r) => r.result === "fail" && r.row_errors.some((e) => e.reason === "kept row names no covering test"),
+    },
+    {
+      name: "moved test",
+      mutate: ["if (headBlocks.some((h) => h.includes(b.norm)))", "if (false)"],
+      setup: (fx) => fx.edit("plugin/skills/faff-prep/SKILL.md", "- Confirm the attach with the returned comment id after posting.\n", "")
+        .edit("plugin/skills/faff-graft/SKILL.md", "## Step two\n", "## Step two\n\n- Confirm the attach with the returned comment id after posting.\n")
+        .write(SPEC, "# FAFF-9\n").commit(),
+      expect: (r) => r.result === "pass" && r.covered_moved === 1,
+    },
+  ];
+  for (const c of cases) {
+    const fx = fixture();
+    const m = mutant(c.mutate[0], c.mutate[1]);
+    try {
+      c.setup(fx);
+      const good = ri.check({ repo: fx.dir, base: "origin/main" }).result;
+      assert.ok(c.expect(good), `${c.name}: the real module passes the case`);
+      const bad = m.mod.check({ repo: fx.dir, base: "origin/main" }).result;
+      assert.ok(!c.expect(bad), `${c.name}: the mutant must fail the case`);
+    } finally { fx.cleanup(); rmSync(m.dir, { recursive: true, force: true }); }
+  }
+});