@dzhechkov/skills-feature-adr 1.5.12 → 1.5.14

package/.dz-manifest.json

@@ -5,7 +5,7 @@
     "files": [
       {
         "path": "CHANGELOG.md",
-        "sha256": "88e0389016f697b90731ee8743a35e523f0ccb079426d59861d894f33e516392"
+        "sha256": "26fa03f89862d03ebfc6447c866cb5d4dcbd5591ae4f8fb3a3ea08b6c586e19d"
       },
       {
         "path": "LICENSE",
@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "e72e7ae2a5adc046598feb5de0bcac114d5aa961571f57d2aa530186c1dbb4b3"
+        "sha256": "8c96e82b41fb8479befb56797a367b3cc2119cc5b022b18fdd18f129ef8cd0f0"
       },
       {
         "path": "bin/cli.js",
@@ -25,7 +25,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "8b0f75ec75e5f2a4e121c65a625abe6c9a8fb4b12732349293b78232348b2234"
+        "sha256": "0cdd048a5aacd52294f72b5903b5a94c049ad61680dbcac532d5cb3fbd45c736"
       },
       {
         "path": "src/cli.js",
@@ -37,7 +37,7 @@
       },
       {
         "path": "src/commands/init.js",
-        "sha256": "fbc3853435048c5b632119bf37cc702c4c305cae7de656548891295f6b9e8947"
+        "sha256": "07ff9d955422979ea67aa5aa454c13303f5ae644efb32e5cc6f359a509638347"
       },
       {
         "path": "src/commands/list.js",
@@ -157,7 +157,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/08-qe.md",
-        "sha256": "7973676cc9a5a6d8429c0bcdbe163bb5dc16e2d2f28a72698e44ad72d234e199"
+        "sha256": "5355e2b36ab13b6acb65abe5b206685915ef2b08191b4a3130574620012b9135"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/09-fleet-qe.md",
@@ -249,7 +249,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs",
-        "sha256": "08e69d2e63350fe2dc64483226fcd30901b77a8e930ca6280ef71181c67675b4"
+        "sha256": "eb77822f121ade10bd6265b0f0145ec38507a07d2cb72ba5fa8336c962096bda"
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs",
@@ -317,7 +317,7 @@
       },
       {
         "path": "templates/.claude/workflows/feature-adr.js",
-        "sha256": "8900ff6bc777a078aa4e37d8e28a2ffbc612187354995f726daf93e6f87d3109"
+        "sha256": "6d1bb93be6fae296281ac8f9fc2f266e5f09336cf6e183912fab5ff3bd0d3fd8"
       },
       {
         "path": "templates/lib/memory-protocol.md",
@@ -329,5 +329,5 @@
       }
     ]
   },
-  "signature": "lPrCKcYVN87Vvd2+Xm6HFSVQdv8eu1AXQ1yGKm42Vad53oNafZvw3gF50Jm4pG1FkKd9vJ1SH/0zHJVNZi9bAQ=="
+  "signature": "+DKyJg37w6aHqhg/UhCpQ+y+w/e66HEEr9hgOv/TttSIMc6TokGEbvJpxEw2pdu19Q0SHlA/o6pSucM+h3KEDw=="
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [Unreleased]
+
+### Fixed — `init --force` больше не стирает локальную правку молча
+
+- Из трёх путей записи `init --force` был ЕДИНСТВЕННЫМ, который перезаписывал локально
+  изменённый файл без резервной копии и без строки в отчёте — при том, что баннер успеха
+  рекомендует именно эту команду. `update` сохраняет правку по трёхсторонней сверке,
+  `update --force` кладёт `.bak` с первого дня; расходился только `init --force`.
+- Теперь `init --force` копирует изменённый файл в `<file>.bak` ПЕРЕД перезаписью и называет
+  его в отчёте. Копия делается только если байты ОТЛИЧАЮТСЯ от шаблона: `.bak`, совпадающий
+  с шаблоном, — чистый мусор. `--dry-run --force` называет будущую копию и ничего не пишет.
+- Поведение самого `--force` не смягчено: файл по-прежнему перезаписывается, это его смысл.
+  Менялось только то, что правка перестала исчезать бесследно.
+
 ## [1.5.1] - 2026-08-21
 
 ### Changed — the Step-8 amendment gate is a COMMAND, and the durable writers are witnessed

package/README.md

@@ -63,7 +63,9 @@ npx @dzhechkov/skills-feature-adr init               # Install core components
 npx @dzhechkov/skills-feature-adr init --with-learning                  # + reward learning
 npx @dzhechkov/skills-feature-adr init --knowledge-extractor            # + knowledge extractor
 npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor  # + both
-npx @dzhechkov/skills-feature-adr init --force       # Overwrite existing files
+npx @dzhechkov/skills-feature-adr init --force       # Overwrite existing files (a locally
+                                                     # changed file is copied to <file>.bak first,
+                                                     # and the copy is named in the report)
 npx @dzhechkov/skills-feature-adr init --dry-run     # Preview without making changes
 npx @dzhechkov/skills-feature-adr update             # Update to latest version
 npx @dzhechkov/skills-feature-adr remove             # Clean uninstall
@@ -106,6 +108,13 @@ ARCHITECTURE → IMPLEMENTATION →  CODE   →   QE    →  FLEET QE
 # Full protocols + 6 extra skills, up to 7 fleet QE agents
 ```
 
+### Checkpoint reads have one source (v1.5.14)
+
+`loadCheckpoints` in the bundled `feature-adr.js` now builds its read command with the checkpoints blob's own
+`checkpointReadCmd(FDIR)` instead of a hand-written duplicate, so the helper with the speaking name is the one the pipeline
+runs. Behaviour is unchanged: for directory names with spaces, quotes and missing directories the shell output is
+byte-identical (proved against the old command). A wiring test fails if the duplicate is re-inlined.
+
 ### Advisory micro-recall at two decision points (v1.5.9, staged)
 
 The workflow makes one bounded decision-local recall attempt immediately before the live Step 3
@@ -208,6 +217,32 @@ run; it now survives it in `recordFailures`.
 
 Requires `@dzhechkov/harness-core >= 0.6.1`.
 
+### The QE instrument writes its own ledger row (aqe-ledger-row)
+
+Before this, the run-cost ledger recorded `plan`, `full`, `design-gate` and friends automatically, but
+the pass that actually reviews the code — Step 8 QE — left zero autorows: every `qe`/`impl` row in the
+ledger was hand-entered, with no model, no findings count, no cross-family signal. The `Workflow`
+pipeline now writes two additional autorows, both additive-only (existing rows are byte-identical to
+before — `appendRunCostRow` gained an optional fourth `extra` argument, spread in only after every
+pre-existing field):
+
+- **`impl`** — written right after the Step 7.5 landing barrier settles: `coder`, `coderFamily`, and
+  `landed` (the barrier's verdict string, or `skipped-claude-sync` for a synchronous Claude coder that
+  never runs the barrier). Writing it here — before Step 8 starts — means the `qe` row's
+  `minutesSincePrev` measures the QE step alone, not QE-plus-code.
+- **`qe`** — written right after the QE step resolves: `reviewer` (the model, or `null` if unknown),
+  `reviewerFamily`, `qeRole` (`qe-code-reviewer` for Claude; `codex-review`/`codex-exec` for Codex by
+  scope mode; never guessed), `grade`, `gradeSource` (if known), `findings` + `findingsBySeverity` +
+  `findingsSource` (normalized from the QE `gaps[]`; an unknown severity counts as `other`, never
+  dropped; no `gaps` array at all reads as `findings:0`, `findingsSource:'no-gaps-array'`), `claimCheck`
+  (if run), `crossFamily` (bool — reviewer family differs from coder family), and `qeScope` (if the
+  reviewer ran scoped, e.g. Codex's `mode`/`ref`/`files`).
+
+Both rows are skipped — with a logged reason, never silently — when their stage resumed from a
+checkpoint (`resumedStages`), so a resumed run never double-pays the ledger. Plain-mode runs (the
+interactive SKILL, not the ultracode `Workflow`) carry the same fields as a manual step at the end of
+`modules/08-qe.md` — see that module for the exact command.
+
 ### Step 0 writes the assessment down, and the acid check gets its input back (v1.5.0)
 
 Step 0 classifies the feature and now **writes `00_complexity_assessment.md` before it returns** — the
@@ -416,10 +451,56 @@ cross-family QE is silently lost — on exactly the big features that need it mo
 - **Every fallback names its cause.** The reason carried into
   `opus (cross-family QE DID NOT happen — …)` comes from a locked taxonomy —
   `timeout` (narrow the scope) · `no-verdict` · `tool-error` (fix the invocation) · `unusable-output` ·
-  `unavailable` (fix the account/model) · `over-ceiling`. A timeout and an unusable output can never
-  render the same string, because the operator's next move differs.
+  `unavailable` (fix the account/model) · `over-ceiling` · `scope-not-established` (mode A's scope
+  could not be built — see below) · `base-ref-not-established` (the scope's base-ref probe failed or
+  was unparseable — see below). A timeout and an unusable output can never render the same string,
+  because the operator's next move differs.
 - **The pipeline still never blocks on Codex.** Both modes fail into the same Claude belt as before.
 
+**Mode A's `--uncommitted` pass runs in an ISOLATED scope-repo, never on the shared tree.** MEASURED
+2026-09-17 (run `wf_95211e0f`): on a hub with other dirty packages, `codex review --uncommitted`
+wandered into unrelated files (`books/`, `features/clean-code-*`) and timed out at 600s having
+reviewed nothing of the run's own feature — cross-family QE silently lost on exactly the runs that
+need it most. Before mode A is attempted for scope `'uncommitted'` (the default), the pipeline now:
+builds a throwaway git repo under `features/<slug>/.fa-state/review-scope/` containing ONLY the
+ESTABLISHED change set (the same `modeBChanged` measurement mode B already uses — base versions via
+`git show <BASE_REF>:<path>` in one commit, working versions copied on top); verifies the receipt
+(`git status --porcelain` in that repo names EXACTLY the declared files, never "close enough"); and
+runs `codex review --uncommitted` with `repo:` pointed at that isolated tree. Findings come back with
+the scope-repo's own absolute path and are normalized to repo-relative before scoring. A change set
+that is **not established** (`null` — no pre-code baseline) or **established but empty** (`[]` — no
+files changed) refuses BEFORE any dispatch, under one decline kind `scope-not-established` (never a
+silent fallback to `--uncommitted` on the shared tree); a failed scope-repo build or a receipt
+mismatch refuse the same way. Knob: `args.qeIsolatedScope` (default `true`) — `false` restores the
+prior `--uncommitted`-on-the-shared-tree behavior byte-for-byte, with a log line saying so. Scopes
+`commit`/`base` are unaffected.
+
+**Fix round 1 hardening (Codex r1 review, 2026-09-17), briefly:** the scope-repo path is validated by
+PATH SEGMENT (`<repo>/features/<slug>/.fa-state/review-scope`, `<slug>` alphanumeric, no `.`/`..`
+segment anywhere), not by a lexical prefix/substring check — a `..`-laced path can no longer walk the
+one destructive `rm -rf` outside `features/`; the script itself repeats the check at runtime (symlink
++ `case` guard) as a second belt. A base-ref probe that fails or returns something unparseable now
+REFUSES under `base-ref-not-established` instead of silently substituting `HEAD` — a bad ref used to
+make Codex review a full-file addition instead of the real modification. The receipt is now a CONTENT
+check, not just a pathname list: the scope-build script also emits a `sha256sum` of every working
+file, compared against the same pre-measured hashes mode B already computes, so a `cp` that silently
+degraded to a deletion (an unreadable file, one that vanished mid-copy) is caught even though the
+pathname-only receipt would have passed; a genuine `cp` failure now aborts the build rather than being
+read as an intentional deletion. The porcelain receipt parser reads a fixed two-character status
+column (`--no-renames` on the git status call, so a rename can never arrive as the ambiguous
+`old -> new` shape). A declared path is never trimmed and rejects only what the receipt genuinely
+cannot express (control characters, `"`, `\`, backtick, `$`, non-ASCII, a leading `-`) — spaces and
+shell metacharacters are accepted, because every value already passes through the same safe quoting
+function used everywhere else in this file.
+
+**Named limit of the isolated scope (owner-facing, so it reads as a boundary, not a defect):** the
+scope-repo review is BLIND to everything outside the declared change set, by construction — that is
+the whole point (it is why the shared-tree run above timed out reviewing unrelated dirty packages).
+A finding phrased as *"file X does not exist"* or *"the twin file is missing"* from mode A is therefore
+an artifact of that intentional narrowness, not a real defect: the twin/sibling file is simply not
+copied into the scope repo. Context that spans beyond the declared files is covered by mode B (which
+is told exactly which files it may open) and by the separate Claude QE pass, never by mode A alone.
+
 After a Codex verdict a cheap Claude agent transcribes it into `08_qe_report.md` (mode A takes no
 prompt, so the reviewer cannot be asked to write anything). It is a scribe, not a second reviewer: the
 grade is Codex's and is stated as final.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.5.12",
+  "version": "1.5.14",
   "description": "Adaptive Feature Development skill pack for Claude Code — 11-step pipeline with Complexity Router (S/M/L/XL), ADR-driven architecture, 15 agentic-qe skills, multi-agent fleet QE. Supports --full-qe, --full-qe-extended, --with-learning, and --knowledge-extractor modes.",
   "bin": {
     "skills-feature-adr": "./bin/cli.js"

package/sbom.json

@@ -15,7 +15,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "88e0389016f697b90731ee8743a35e523f0ccb079426d59861d894f33e516392"
+          "content": "26fa03f89862d03ebfc6447c866cb5d4dcbd5591ae4f8fb3a3ea08b6c586e19d"
         }
       ]
     },
@@ -35,7 +35,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "e72e7ae2a5adc046598feb5de0bcac114d5aa961571f57d2aa530186c1dbb4b3"
+          "content": "8c96e82b41fb8479befb56797a367b3cc2119cc5b022b18fdd18f129ef8cd0f0"
         }
       ]
     },
@@ -69,7 +69,7 @@
         },
         {
           "name": "dz:canonical-json-sha256-v2",
-          "value": "8b0f75ec75e5f2a4e121c65a625abe6c9a8fb4b12732349293b78232348b2234"
+          "value": "0cdd048a5aacd52294f72b5903b5a94c049ad61680dbcac532d5cb3fbd45c736"
         }
       ]
     },
@@ -99,7 +99,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "fbc3853435048c5b632119bf37cc702c4c305cae7de656548891295f6b9e8947"
+          "content": "07ff9d955422979ea67aa5aa454c13303f5ae644efb32e5cc6f359a509638347"
         }
       ]
     },
@@ -399,7 +399,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "7973676cc9a5a6d8429c0bcdbe163bb5dc16e2d2f28a72698e44ad72d234e199"
+          "content": "5355e2b36ab13b6acb65abe5b206685915ef2b08191b4a3130574620012b9135"
         }
       ]
     },
@@ -629,7 +629,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "08e69d2e63350fe2dc64483226fcd30901b77a8e930ca6280ef71181c67675b4"
+          "content": "eb77822f121ade10bd6265b0f0145ec38507a07d2cb72ba5fa8336c962096bda"
         }
       ]
     },
@@ -799,7 +799,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "8900ff6bc777a078aa4e37d8e28a2ffbc612187354995f726daf93e6f87d3109"
+          "content": "6d1bb93be6fae296281ac8f9fc2f266e5f09336cf6e183912fab5ff3bd0d3fd8"
         }
       ]
     },

package/src/commands/init.js

@@ -54,14 +54,15 @@ function showKeysariumIntegration(keysariumManifest) {
 
 // Copies a component file-by-file with per-file overwrite protection:
 //   - destination missing            -> write, record in `written`
-//   - destination exists + --force   -> overwrite, record in `written`
+//   - destination exists + --force   -> BACK UP to a .bak sibling if the bytes differ,
+//                                       then overwrite; record in `written` (+ `backedUp`)
 //   - destination exists, no --force -> do NOT write, record in `preserved`
 // In dry-run mode nothing is written, but the same written/preserved
 // classification is produced.
 // Returns { missing, fileCount } where `missing` means the template source
 // was absent on disk and `fileCount` is how many files the template provides.
 function installComponent(key, comp, templatesDir, targetDir, opts) {
-  const { force, dryRun, written, preserved, hashes } = opts;
+  const { force, dryRun, written, preserved, backedUp, hashes } = opts;
   const src = path.join(templatesDir, comp.src);
   const destRoot = path.join(targetDir, comp.src);
 
@@ -89,12 +90,20 @@ function installComponent(key, comp, templatesDir, targetDir, opts) {
   }
 
   for (const entry of entries) {
-    if (fileExists(entry.destFile) && !force) {
+    const existed = fileExists(entry.destFile);
+    if (existed && !force) {
       preserved.push(entry.rel);
       continue;
     }
+    // `update --force` has backed edits up to a `.bak` sibling since day one; `init --force` was
+    // the ONE path that overwrote silently — and the success banner recommends exactly that
+    // command, so a locally-edited workflow could vanish with no notice and no copy.
+    // Only DIFFERING bytes are backed up: a `.bak` identical to the template is pure litter.
+    const differs = existed && hashFile(entry.destFile) !== hashFile(entry.srcFile);
+    if (differs && backedUp) backedUp.push(entry.rel);
     if (!dryRun) {
       ensureDir(path.dirname(entry.destFile));
+      if (differs) fs.copyFileSync(entry.destFile, `${entry.destFile}.bak`);
       fs.copyFileSync(entry.srcFile, entry.destFile);
       // Record the SHA-256 of the TEMPLATE bytes we just installed (not the
       // dest) as this file's baseline. This makes baseline == mine immediately
@@ -110,6 +119,23 @@ function installComponent(key, comp, templatesDir, targetDir, opts) {
   return { missing: false, fileCount: entries.length };
 }
 
+// Print the block of locally-changed files that were (or would be) backed up before --force
+// overwrote them. Silence here is what the field report caught: the operator had no way to learn
+// that their edit was gone, let alone where the copy is.
+function printBackedUpBlock(backedUp, dryRun) {
+  if (backedUp.length === 0) return;
+  const MAX_SHOWN = 10;   // `printPreservedBlock` держит свою копию — она объявлена в его теле
+  console.log('');
+  const verb = dryRun ? 'would be backed up' : 'backed up';
+  warn(`${backedUp.length} locally-changed file(s) ${verb} to a .bak sibling before being overwritten:`);
+  for (const rel of backedUp.slice(0, MAX_SHOWN)) {
+    console.log(dim(`  ${rel} -> ${rel}.bak`));
+  }
+  if (backedUp.length > MAX_SHOWN) {
+    console.log(dim(`  …and ${backedUp.length - MAX_SHOWN} more`));
+  }
+}
+
 // Print the block of pre-existing files that were (or would be) preserved
 function printPreservedBlock(preserved, dryRun) {
   console.log('');
@@ -233,6 +259,7 @@ async function run(options) {
   const installedFiles = [];   // files written (or would-write in dry-run)
   const installedHashes = {};  // rel -> sha256 of the TEMPLATE bytes installed (baseline)
   const preservedFiles = [];   // pre-existing files NOT overwritten (no --force)
+  const backedUpFiles = [];    // locally-changed files copied to .bak before --force overwrote them
   const completedKeys = [];    // component keys processed so far (for partial manifest)
   const installedOptionalKeys = [];
   let stepNum = 0;
@@ -246,7 +273,7 @@ async function run(options) {
 
       installComponent(key, comp, templatesDir, targetDir, {
         force, dryRun, written: installedFiles, preserved: preservedFiles,
-        hashes: installedHashes,
+        backedUp: backedUpFiles, hashes: installedHashes,
       });
       completedKeys.push(key);
     }
@@ -262,7 +289,7 @@ async function run(options) {
 
       const res = installComponent(key, comp, templatesDir, targetDir, {
         force, dryRun, written: installedFiles, preserved: preservedFiles,
-        hashes: installedHashes,
+        backedUp: backedUpFiles, hashes: installedHashes,
       });
       if (!res.missing && res.fileCount > 0) {
         installedOptionalKeys.push(key);
@@ -296,6 +323,10 @@ async function run(options) {
   if (dryRun) {
     console.log('');
     info(`Dry run: ${installedFiles.length} file(s) would be written, ${preservedFiles.length} pre-existing file(s) would be preserved.`);
+    // Отчёт о копиях стоит СНАРУЖИ стража сохранённых: при --force сохранять нечего, список
+    // пуст, и внутри стража блок был бы недостижим ровно в том случае, ради которого написан.
+    // Пустой список функция отсекает сама.
+    printBackedUpBlock(backedUpFiles, true);
     if (preservedFiles.length > 0) {
       printPreservedBlock(preservedFiles, true);
     }
@@ -318,10 +349,11 @@ async function run(options) {
     process.exit(0);
   }
 
+  printBackedUpBlock(backedUpFiles, false);   // снаружи: при --force preservedFiles пуст
   if (preservedFiles.length > 0) {
     printPreservedBlock(preservedFiles, false);
-    console.log('');
   }
+  if (preservedFiles.length > 0 || backedUpFiles.length > 0) console.log('');
 
   // ── f) Write manifest ──────────────────────────────────────────────────
   const pkgPath = path.resolve(__dirname, '../../package.json');

package/templates/.claude/skills/feature-adr/modules/08-qe.md

@@ -205,7 +205,9 @@ list), grep for unfinished-stub markers: `TODO` / `FIXME` / `HACK` / `XXX` / `PL
 file:line, UNLESS the line carries an inline `no-stubs: <reason>` waiver WITH a non-empty reason, or
 `.dz/guard.json` `stubWaivers` lists the path WITH a reason. A REASONLESS waiver is itself a HIGH gap,
 never an exemption. Cross-check mechanically: `dz guard check --op publish --json` runs the same scan
-as the SOFT `no-stubs` rule over the working-tree diff. When you QUOTE a marker in `08_qe_report.md`,
+as the SOFT `no-stubs` rule over the working-tree diff.
+After the Step-7 code has landed, run `dz guard check --op code --json` and treat a HARD `block` verdict
+as a HIGH finding naming the drifted file. When you QUOTE a marker in `08_qe_report.md`,
 backtick it so the report itself scans clean (the claim-check forbidden-phrase convention). Record the
 verdict in the ADR Fitness section.
 
@@ -311,6 +313,9 @@ Compile all findings into a structured report:
 ✅ READY FOR MERGE | ❌ NEEDS FIXES | ⚠️ CONDITIONAL APPROVAL
 ```
 
+Settle a cross-family re-QE debt with `dz reqe --slug <s> --done --report <08b>`.
+For `dz reqe --done`, exit 3 means the review settled but named BLOCKER/HIGH findings — stop and surface them to the owner.
+
 ### 7.1 Findings ledger (machine-readable)
 
 Prose is for people; `dz score`/`dz recap` need a machine-readable surface too (qe-findings-record,
@@ -356,6 +361,45 @@ An empty (header-only) table is read as `hollow: true` — worse than no table a
 claims a ledger exists and says nothing. If there are no findings, omit the section entirely rather
 than writing an empty table.
 
+### 7.2 Ledger row for this QE step (mandatory)
+
+Plain mode (this SKILL, not the ultracode `Workflow`) has no in-process `appendRunCostRow` — without
+this step the QE instrument's own pass leaves ZERO trace in the run-cost ledger (aqe-ledger-row,
+owner audit 17.09, decision #3).
+
+**Resume guard — check this FIRST, before writing anything.** If QE was RESTORED from a checkpoint
+for THIS run (`features/<slug>/.fa-state/checkpoints.jsonl` already contains a line for stage `qe`
+that matches this run) — the row for this review was already written by the run that actually did
+it. Do **NOT** run the command below in that case; instead write exactly this line into
+`08_qe_report.md`: `qe ledger row skipped — stage resumed`. Writing the row anyway would double-pay
+the same review in the ledger (aqe-ledger-row fix-round-1/#3, Codex r1 HIGH #3 — plain mode had no
+resume guard at all before this).
+
+Otherwise — QE ran fresh in this pass — after `08_qe_report.md` is written and the grade is final, run:
+
+```bash
+dz feature-adr-record --kind ledger --stage qe --slug <slug> --row '<json>' --json
+```
+
+fix-round-1 (Codex r1 HIGH finding 4, ADR-001 D5): no `--auto` here. `--auto` is the trusted marker
+of an AUTOMATED pipeline run and requires an experiment envelope that the manual path does not have;
+this plain-mode row is written without it.
+
+`<json>` carries the same fields the ultracode pipeline writes for this row: `reviewer` (the model
+that reviewed, or `null` if unknown — never guessed), `reviewerFamily` (`claude`|`codex`|`null` when
+the reviewer identity is not one of the two known families — never guessed as `claude`), `qeRole`
+(`qe-code-reviewer` for a Claude reviewer; `codex-review`/`codex-exec` for a codex reviewer by scope
+mode; `null` otherwise), `grade`, `gradeSource` (if known), `findings` (gap count), `findingsBySeverity`
+(normalized `sev` -> count, unknown severities counted as `other`, never dropped), `findingsSource`
+(`gaps` or `no-gaps-array`), `claimCheck` (if run), `crossFamily` (bool: reviewer family != coder
+family — `null` when either family is unknown, since a same/cross-family verdict cannot be asserted
+without both), `qeScope` (if the reviewer ran scoped, e.g. codex `mode`/`ref`/`files`). Insert the
+writer's verdict (`{verdict:"written"|...}`) verbatim into `08_qe_report.md` so the record is
+auditable from the artifact itself. NAMED LIMIT (layer 4 of the cost-of-detection ladder, said
+honestly): this step is a skill instruction, not a code gate — nothing forces the agent to run it or
+to check the resume guard first; only its PRESENCE in this module is deterministically pinned (grep
+for the command above and for the resume-guard sentence).
+
 ### 8. QE Pattern Store (Direct Mode only)
 
 When `{AGENTIC_QE_MODE}` = `direct` | `direct-extended`, after the gap loop is closed and the verdict is set:

package/templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs

@@ -31,12 +31,18 @@
 // side) for C1 and C8 together, so a prose mention stops satisfying either check, is a separate
 // backlog item — filed by the lead, not chased here.
 //
+// KNOWN LIMITATION (C9): only byte-identical copies are visible before the edit. Already drifted
+// or intentionally different pinned copies remain the identity tests' job; the frozen
+// features/wave1-instrument-repair/check-plan-completeness.mjs is a real example C9 cannot see.
+//
 // Checks:
 //  C1  every ADR file in 03_adr/ has >=1 task line in 06_implementation_plan.md citing it (ADR-00N)
 //  C2  every Confirmation-numbered check in each ADR is named in the plan (by its test-file path)
 //  C3  the plan carries an EXPECTED_CODE_TARGETS: block, non-empty, and EVERY line parses to a
 //      plausible repo-relative path (no spaces unless quoted, no traversal, no markdown residue)
 //      — SFDIPOT condition: line-level validation, reject-with-reason, not just block presence
+//  C9  every tracked byte-identical twin of a target is also listed or explicitly waived with a
+//      reason; size-first narrowing, fixed exclusions, one FAIL per missing (target, twin) pair
 //  C4  the plan names the feature's OWN acid corpus (see "acid corpus" below)
 //  C5  the plan has an 'Inputs read:' line naming 03_adr, 05_architecture (wave-2 seam, cheap here)
 //  C8  every requirement id DECLARED in 01_requirements.md (FR-N, NFR-N, AC-N, C-N, with an optional
@@ -79,7 +85,9 @@
 // supplied explicitly with `--acid=T1,T2,…`. If neither establishes a corpus, C4 is SKIPPED-with-note
 // (a feature that declared no acid cases cannot be failed for not naming them).
 import { maskMarkdown } from './markdown-masker.mjs';
-import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { isAbsolute, join, resolve } from 'node:path';
 
 const argv = process.argv.slice(2);
@@ -335,6 +343,7 @@ function classifyTargetPath(path) {
 
 // C3 — EXPECTED_CODE_TARGETS block, line-level validation
 const blockM = plan.match(/EXPECTED_CODE_TARGETS:\s*\n((?:\s*[-*]\s*.+\n?)+)/);
+const listedTargets = new Set();
 if (!blockM) failures.push('C3: no EXPECTED_CODE_TARGETS: block in the plan');
 else {
   const lines = blockM[1].split('\n').map(s => s.trim()).filter(Boolean);
@@ -343,6 +352,81 @@ else {
     const path = ln.replace(/^[-*]\s*/, '').replace(/`/g, '').trim();
     const reasons = classifyTargetPath(path);
     if (reasons.length) failures.push(`C3: target line rejected: "${safe(ln)}" — ${reasons.join(', ')}`);
+    else listedTargets.add(path);
+  }
+}
+
+// C9 — every byte-identical copy is listed or carries a reasoned waiver (ADR-001).
+const TWIN_EXCLUDED_PREFIXES = ['out/', '.claude/worktrees/', 'node_modules/'];
+{
+  const excluded = (path) => TWIN_EXCLUDED_PREFIXES.some((prefix) => path.startsWith(prefix) || path.includes('/' + prefix));
+  const waivers = [];
+  for (const line of maskMarkdown(plan, { unclosed: 'mask' }).split('\n')) {
+    if (!/^\s*(?:[-*]\s*)?TWIN_NOT_A_TARGET:/.test(line)) continue;
+    const match = line.match(/^\s*(?:[-*]\s*)?TWIN_NOT_A_TARGET:\s*`?([^\s`]+)`?\s*(?:—|--)\s*(\S.*)$/);
+    if (!match) {
+      failures.push(`C9: waiver "${safe(line.trim())}" carries no reason — a waiver without a reason is an allowlist entry`);
+    } else waivers.push({ path: match[1], used: false });
+  }
+
+  let tracked = null;
+  try {
+    tracked = execFileSync('git', ['ls-files', '-z'], {
+      cwd: process.cwd(), encoding: 'utf-8', maxBuffer: 16 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).split('\0').filter(Boolean);
+  } catch (error) {
+    warnings.push(`C9: twin scan had no input — git ls-files failed in ${safe(process.cwd())}: ${safe(error.message)}`);
+  }
+  if (tracked !== null) {
+    // Stat the universe first; only size matches ever reach readFileSync / md5.
+    const sizes = new Map();
+    for (const path of new Set([...tracked, ...listedTargets])) {
+      if (excluded(path)) continue;
+      try {
+        const stat = statSync(path);
+        if (stat.isFile()) sizes.set(path, stat.size);
+      } catch (error) {
+        // Missing targets are new files; tracked files can also have been deleted locally.
+        if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') warnings.push(`C9: cannot stat ${safe(path)}: ${safe(error.message)}`);
+      }
+    }
+    const targetSizes = new Set([...listedTargets].map((path) => sizes.get(path)).filter((size) => size > 0));
+    const hashes = new Map();
+    const twinsByHash = new Map();
+    for (const [path, size] of sizes) {
+      if (!targetSizes.has(size)) continue;
+      try { hashes.set(path, createHash('md5').update(readFileSync(path)).digest('hex')); }
+      catch (error) { warnings.push(`C9: cannot hash ${safe(path)}: ${safe(error.message)}`); }
+    }
+    for (const path of tracked) {
+      const hash = hashes.get(path);
+      if (hash === undefined) continue;
+      if (!twinsByHash.has(hash)) twinsByHash.set(hash, []);
+      twinsByHash.get(hash).push(path);
+    }
+    let unlisted = 0;
+    for (const target of listedTargets) {
+      for (const twin of twinsByHash.get(hashes.get(target)) ?? []) {
+        if (twin === target) continue;
+        let waived = false;
+        for (const waiver of waivers) {
+          if (waiver.path.endsWith('/') ? twin.startsWith(waiver.path) : twin === waiver.path) {
+            waiver.used = true;
+            waived = true;
+          }
+        }
+        if (listedTargets.has(twin) || waived) continue;
+        unlisted++;
+        // Keep pairs separate: safe() truncates each echoed value at 300 characters.
+        failures.push(`C9: target ${safe(target)} has a byte-identical twin the plan does not list: ${safe(twin)} — list it or waive it (TWIN_NOT_A_TARGET: ${safe(twin)} — <why>)`);
+      }
+    }
+    for (const waiver of waivers) if (!waiver.used) warnings.push(`C9: unused waiver ${safe(waiver.path)}`);
+    if (unlisted === 0) {
+      const onDisk = [...listedTargets].filter((path) => sizes.has(path)).length;
+      out(`NOTE  C9: twin scan over ${listedTargets.size} target(s), ${onDisk} on disk, 0 unlisted twins (byte-identical only; drifted copies need identity tests)`);
+    }
   }
 }
 
@@ -417,7 +501,21 @@ else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\
       // bullet-less row was invisible here while being a row there (so it evaded this check), and
       // this side lacked the range guard, so «AM-1..AM-4 are covered elsewhere» was falsely
       // reported as a definition. One shape, one meaning.
-      const isDef = /^\s*(?:[-*|]\s*)?\*{0,2}AM-(?:CP-)?\d+\*{0,2}\b(?!\s*\.)/.test(pl);
+      // ЯЧЕЙКА ТАБЛИЦЫ ВНЕ СЕКЦИИ — НЕ ОПРЕДЕЛЕНИЕ. Внутри `## Amendments` строка таблицы
+      // законно объявляет поправку, поэтому там `|` остаётся допустимым началом строки. Снаружи
+      // же таблица — это СВОДКА, ссылающаяся на поправки, определённые в другом месте, и читать
+      // её как определение значит отказывать плану за оглавление.
+      // ИЗМЕРЕНО 2026-09-05: четыре ложных FAIL за один день на четырёх разных фичах
+      // (narrated-error-must-be-taught, fa-phase-statusline, core-boundary-guard,
+      // run-registry-liveness); каждый стоил ручной правки ведущего и перезапуска конвейера,
+      // то есть 5–10 минут и один цикл роутера. Один планировщик дошёл до того, что вписал в
+      // план оговорку «no line of this paragraph may begin with AM-» — прибор начал
+      // диктовать людям форму прозы, а это уже не проверка, а суеверие.
+      // ОДИН механизм, а не два: `|` УБРАН из класса начал строки. Первая редакция этой правки
+      // добавляла ещё и отдельную проверку `isTableRow`, и мутация, снимавшая только её,
+      // оставалась ЭКВИВАЛЕНТНОЙ — 77 тестов из 77 зелёные при «снятой» починке. Дублирующая
+      // защита не усиливает гейт, она прячет от мутационной пробы, что именно держит свойство.
+      const isDef = /^\s*(?:[-*]\s*)?\*{0,2}AM-(?:CP-)?\d+\*{0,2}\b(?!\s*\.)/.test(pl);
       const inSection = sectionStart >= 0 && cursor2 >= sectionStart && cursor2 < sectionEnd;
       if (isDef && !inSection) {
         const tok = (/AM-(?:CP-)?\d+/.exec(pl) || ['AM-?'])[0];
@@ -479,7 +577,10 @@ else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\
         }
         if (superseded) break;
       }
-      if (!hasTest && !superseded) failures.push(`C6: ${defs[k].id} carries neither \`\u2192 test <name>\` nor \`superseded by AM-N\` — an amendment without a confirmation is a wish, and a retracted one must say its successor`);
+      // Сообщение называет ТУ ЖЕ форму, которую требует MARK выше. Прежняя редакция обещала
+      // простое `→ test <name>`, а проверка требовала имя и файл в обратных кавычках — человек,
+      // написавший ровно то, что просило сообщение, получал отказ снова и не понимал, почему.
+      if (!hasTest && !superseded) failures.push(`C6: ${defs[k].id} carries neither \`\u2192 test \`<имя>\` in \`<файл>\`\` (обратные кавычки обязательны, как и слово in) nor \`superseded by AM-N\` — an amendment without a confirmation is a wish, and a retracted one must say its successor`);
     }
   }
 }