@dzhechkov/skills-feature-adr 1.5.11 → 1.5.13

package/.dz-manifest.json

@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "889d62c5dfafb53c0664867f0882e5712e47eb8aa7a44c6db46d082e693ed58d"
+        "sha256": "619a231352a602c736ce6eec1e5fa79a056dc2f5f80f6b35eed236f9670f7337"
       },
       {
         "path": "bin/cli.js",
@@ -25,7 +25,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "d13930ae60a1d849d08b798dbb3b3ed4fb5d0b50c4c3910fc76a455dd9e6ce31"
+        "sha256": "07537ebbd424c668a37a42b670c033a4d3134a9e7e13803f426aa31149a85b58"
       },
       {
         "path": "src/cli.js",
@@ -121,7 +121,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/00-complexity-router.md",
-        "sha256": "a1275bd960ddff1c61352f96d8b7a4249371190766f08d1778f5a54f98350950"
+        "sha256": "6a98ca7af49aabcb2e14a081815f1167740ac4dba2e0cbb938c87aceac47bfa3"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/01-requirements.md",
@@ -149,15 +149,15 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/06-implementation-plan.md",
-        "sha256": "c624e0ade0314ca07913ba64e092d4655f86201856e8188c3e616b2320226c1e"
+        "sha256": "5c8d4c79d5329702b8c75b9afb36ae335aa63c99e74045c0afa98e12658ee975"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/07-code.md",
-        "sha256": "c427a0abacb4bc1d969d9f47739ce2aeff286a66da73eab67bf042d5c4dc9a59"
+        "sha256": "fb054591e86d55cee184eab96b5f0440053ada8fa9edf619e4a66ec5ac371587"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/08-qe.md",
-        "sha256": "ea8fb546acb7f09816d2fc9f9189a86f2400b8cec91c9ba4b82b68a8e32920bb"
+        "sha256": "7ab9b7b1523289986a1f51b4cbbebf4410d96ad4a153f22fa8613e8a0f4f5fa7"
       },
       {
         "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": "cbe70a524f6ce7987b5e3961ee412b92c24c00d84066d438c759659d656efaa2"
+        "sha256": "08e69d2e63350fe2dc64483226fcd30901b77a8e930ca6280ef71181c67675b4"
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs",
@@ -317,7 +317,7 @@
       },
       {
         "path": "templates/.claude/workflows/feature-adr.js",
-        "sha256": "22416f105c1b988c07f6cb9002a507b54b07842b5b4bb109b7e300ff52272603"
+        "sha256": "e96c5280ad21b604036cc912418c9627b0ff0ae8ca1436c58dcff951ba9a034b"
       },
       {
         "path": "templates/lib/memory-protocol.md",
@@ -329,5 +329,5 @@
       }
     ]
   },
-  "signature": "WT7wArJY3aKuIMMVgbBzFO+Rqw7qfcaVh8UQ9MENSltqdTJTFAr/0TBOS5A89UAfczkluCrkTtyUvPOTQvaNCw=="
+  "signature": "CfTJgsBbekrZE+IbzaQFLofuRDZ3B2CJTqPk6gjeOiLXhChXiPGkqxaWKCT+hdQTy6ORB7fu6vfMx37rwJf6Cg=="
 }

package/README.md

@@ -208,6 +208,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 +442,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.
@@ -1179,6 +1251,64 @@ pre-code probe that returns nothing no longer becomes an all-null baseline that
 "every target changed".
 
 
+`next` — **the plan inherits requirements by contract, not by goodwill** (feature `plan-inherits-requirements`,
+staged: not yet versioned or published). Two swarms plus a cross-family check measured that the implementation
+plan referenced only 95 of 339 requirement ids across 8 M/L features (28 %), lost one requirement without a trace
+and introduced one contradiction, while the norm "every FR-N → a task" lived only in the module text — neither
+the planner prompt nor the K2 gate enforced it. Now:
+
+- **C8 — requirement coverage.** The K2 gate reads `01_requirements.md`, extracts every id declared at line start
+  in the four corpus shapes (heading / bold / list / table; `FR-N`, `NFR-N`, `AC-N`, `C-N`, with an optional
+  letter group and dotted sub-number — measured over 394 requirement files) and checks each by word boundary in
+  the plan. By default a WARN with the exact count; under `--require-requirements` (which the pipeline passes)
+  every missing id is its own FAIL line. An absent `01_requirements.md` is a WARN naming the absence, never a
+  skip; a file declaring no ids in the contract shapes says so. NAMED LIMIT, in the same form as C1's: C8 is a
+  grep — a prose mention satisfies it; "mentioned but not tasked" is not caught.
+- **C1 counts decisions by heading, not by filename.** `# ADR-NNN` / `## ADR-NNN` headings inside each ADR file
+  are the decisions the plan owes a task; a file holding four decisions now yields four checks, not one. No
+  heading ⇒ filename prefix with a WARN.
+- **An unclosed code fence on the declaration side is NOT-ESTABLISHED.** Masking it silently dropped every id
+  after it (measured); restoring it silently established a heading that was only example code. Neither silent
+  reading is honest, so the gate refuses with the file named — close the fence, rerun. The corpus has 0 such
+  files out of 831.
+- **The Step-6 planner is told the inputs by NAME** (`01_requirements.md`, every `03_adr/*.md`,
+  `05_architecture.md`, `03.5_ideation_report.md` / `04_domain_model.md` when present) and the C8 contract in the
+  same clause as C1/C2/C4 — the lesson that a gate whose contract is not named in the authoring prompt produces
+  refusal after refusal.
+- **ONE automatic repair round.** A genuine script-verdict FAIL re-dispatches the planner with the FAIL lines
+  ("close EXACTLY these gaps, keep everything else"). Because that sentence is a prompt and not a guarantee, the
+  round is bracketed: the plan is backed up first (no backup ⇒ no repair; a stale `.pre-repair` or a symlinked
+  plan refuses), snapshots before/after compare byte length, every `EXPECTED_CODE_TARGETS` line and every task
+  heading line WITH multiplicity, a snapshot that did not complete REJECTS (never fails open), the re-gate runs
+  before the backup is archived, and a rejected or still-failing repair is restored from the backup with the
+  restore PROVEN by POSIX `cksum` + length. `planGateAttempts` counts gate runs; `planRepair` carries the
+  outcome; a `plan-repair` ledger row is written either way. NAMED LIMIT: task bodies are not proven preserved
+  by any metric — a repair that keeps every heading, every target and 80 % of the bytes while gutting prose is
+  undetectable by construction.
+- The pure halves (`shellQuote`, `planBackupCmd`, `planRestoreCmd`, `planArchiveBackupCmd`, `planSnapshotCmd`,
+  `snapshotBlock`, `snapshotNumber`, `parsePlanSnapshot`) live in `@dzhechkov/harness-core` and are body-pinned
+  against the inline copies by the drift guard. Three Codex review rounds (C, C, D) — every finding either fixed
+  or named above; the full account is in `features/plan-inherits-requirements/08_qe_report.md`.
+
+Also staged: **the coder now gets the same recall lane the planner already had** (feature
+`coder-reads-and-recall`). `1.5.9` wired advisory decision-point micro-recall into Step 3 (ADR
+selection) and Step 6 (plan routing) only — Step 7 (Code) never called `prepareDecisionRecall` at
+all, so any lesson reaching the coder was a night-shift human pasting it into the brief by hand.
+`drDecisionShape` now knows a third decision kind, `code-implementation` → `step-7` /
+`feature-adr-decision-code-implementation`, kept apart from the plan's own `step-6` bandit context.
+The call sits INSIDE the code stage's checkpoint, before any of the three places that read the
+coder's prompt (the Claude dispatch, the Codex dispatch, and the training-pair capture) — so a
+resumed stage neither re-spends the recall nor loses it, and all three see the identical
+recall-augmented text. Separately measured (Step 0 of this feature, instrument: host workflow
+records → the coding-stage agent's own tool-call transcript): a comment added 24.08 naming the plan,
+every ADR, the architecture doc, requirements and the domain model by file name moved how often
+Claude-family coders opened `01_requirements.md` from 39 % (11 of 28 runs) before the change to 71 %
+(5 of 7) after — a real jump, but on **n = 7**, not a controlled comparison, and it says nothing
+about Codex-family coders: they were 77 % of the post-change sample and are invisible to this
+instrument (a Codex coder's transcript carries exactly one entry, the dispatch itself). Full method,
+the two false reads caught before the number was trusted, and the raw counts are in
+`features/coder-reads-and-recall/00_complexity_assessment.md`.
+
 `1.5.3` — **the workflow stops crashing on the way into Step 7.** `1.5.2` shipped a workflow that
 CALLED three helpers it never defined — `changeSetProbeCmd`, `parseHashProbe`, `changedFromHashes`
 (5 call sites, 0 definitions). `QE_SCOPE` defaults to `uncommitted`, so the guarded branch was true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.5.11",
+  "version": "1.5.13",
   "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"
@@ -15,6 +15,10 @@
     ".dz-manifest.json",
     "sbom.json"
   ],
+  "scripts": {
+    "test": "node --test \"test/**/*.test.js\"",
+    "prepack": "node -e \"const fs=require('fs');const bad=['.claude','.skills-feature-adr.json'].filter(p=>fs.existsSync(p));if(bad.length){console.error('prepack guard: stray init artifacts in package dir: '+bad.join(', ')+' — remove before packing');process.exit(1)}\""
+  },
   "keywords": [
     "claude",
     "claude-code",
@@ -59,8 +63,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "test": "node --test \"test/**/*.test.js\""
   }
-}
+}

package/sbom.json

@@ -35,7 +35,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "889d62c5dfafb53c0664867f0882e5712e47eb8aa7a44c6db46d082e693ed58d"
+          "content": "619a231352a602c736ce6eec1e5fa79a056dc2f5f80f6b35eed236f9670f7337"
         }
       ]
     },
@@ -69,7 +69,7 @@
         },
         {
           "name": "dz:canonical-json-sha256-v2",
-          "value": "d13930ae60a1d849d08b798dbb3b3ed4fb5d0b50c4c3910fc76a455dd9e6ce31"
+          "value": "07537ebbd424c668a37a42b670c033a4d3134a9e7e13803f426aa31149a85b58"
         }
       ]
     },
@@ -309,7 +309,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "a1275bd960ddff1c61352f96d8b7a4249371190766f08d1778f5a54f98350950"
+          "content": "6a98ca7af49aabcb2e14a081815f1167740ac4dba2e0cbb938c87aceac47bfa3"
         }
       ]
     },
@@ -379,7 +379,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c624e0ade0314ca07913ba64e092d4655f86201856e8188c3e616b2320226c1e"
+          "content": "5c8d4c79d5329702b8c75b9afb36ae335aa63c99e74045c0afa98e12658ee975"
         }
       ]
     },
@@ -389,7 +389,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c427a0abacb4bc1d969d9f47739ce2aeff286a66da73eab67bf042d5c4dc9a59"
+          "content": "fb054591e86d55cee184eab96b5f0440053ada8fa9edf619e4a66ec5ac371587"
         }
       ]
     },
@@ -399,7 +399,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "ea8fb546acb7f09816d2fc9f9189a86f2400b8cec91c9ba4b82b68a8e32920bb"
+          "content": "7ab9b7b1523289986a1f51b4cbbebf4410d96ad4a153f22fa8613e8a0f4f5fa7"
         }
       ]
     },
@@ -629,7 +629,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "cbe70a524f6ce7987b5e3961ee412b92c24c00d84066d438c759659d656efaa2"
+          "content": "08e69d2e63350fe2dc64483226fcd30901b77a8e930ca6280ef71181c67675b4"
         }
       ]
     },
@@ -799,7 +799,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "22416f105c1b988c07f6cb9002a507b54b07842b5b4bb109b7e300ff52272603"
+          "content": "e96c5280ad21b604036cc912418c9627b0ff0ae8ca1436c58dcff951ba9a034b"
         }
       ]
     },

package/templates/.claude/skills/feature-adr/modules/00-complexity-router.md

@@ -103,19 +103,39 @@ Runs after tier classification, only when `{AGENTIC_QE_MODE}` = `direct` | `dire
 
 Step 1 folds `{LEARNED_PATTERNS}` into the requirements brief as "lessons from previous features" — advisory context only, never requirements themselves. Why here: Step 0 is the one point where recall can be keyed to the feature's phase and domain — per-prompt hook auto-injection cannot see which pipeline step is running.
 
+### 7. Task Kind Classification (experiment-envelope, ADR-001)
+
+Classify the feature as exactly ONE of the six task kinds below, and write `Task kind: <x>` as its
+own line in the artifact. This feeds the experiment envelope the conveyor builds after this step —
+downstream learning reads the kind, not a paraphrase, so the line must use one of the exact words.
+
+| Task kind | Criterion |
+|-----------|-----------|
+| `feature` | A genuinely new capability, adapter, command, or skill did not exist before this run. |
+| `bugfix` | The change corrects observed incorrect behavior in existing code — a defect, not an absence. |
+| `refactor` | Behavior is unchanged; the change restructures, renames, or simplifies existing code. |
+| `tooling` | The change is to build/CI/dev-tooling/scripts rather than to the product's own runtime behavior. |
+| `docs` | The change is documentation-only (README, ADR prose, comments) with no code delta. |
+| `research` | The deliverable is a finding or a design decision, not a shipped code change. |
+
+If `args.taskKind` was passed explicitly by the caller, it OVERRIDES this classification — record
+both: `Task kind: <forced value> (forced by the caller)` as the kind of record, and your own
+classification separately if it differs, the same pattern Step 0 already uses for a forced tier.
+
 ## Output
 
 Set the following variables:
 
 ```
 {COMPLEXITY_TIER} = S | M | L | XL
+{TASK_KIND} = feature | bugfix | refactor | tooling | docs | research
 {ACTIVE_STEPS} = [0, 1, 6, 7, 8]  # example for S
 {TIME_BUDGET} = { requirements: 2, planning: 0, implementation: 10, qe: 3 }
 {DIMENSION_SCORES} = { files: 1, domains: 1, integrations: 1, breaking: 1, models: 1, crosscutting: 1 }
 {LEARNED_PATTERNS} = [ ... ]  # top-3 by confidence from memory_query; [] in reference mode / no hits / error
 ```
 
-Create artifact: `features/<slug>/00_complexity_assessment.md`
+Create artifact: `features/<slug>/00_complexity_assessment.md`, including the `Task kind: <x>` line.
 
 ## Checkpoint 0 Format
 

package/templates/.claude/skills/feature-adr/modules/06-implementation-plan.md

@@ -127,7 +127,9 @@ For each group, identify:
 
 Before finalizing the plan, validate completeness:
 
-1. Cross-reference every `{REQUIREMENT}` (FR-N) → at least one TASK covers it
+1. Cross-reference every `{REQUIREMENT}` (FR-N) → at least one TASK covers it (C8 — the gate checks
+   this by identifier: WARN with a count by default, FAIL under `--require-requirements`, which the
+   pipeline passes)
 2. Cross-reference every `{ADR_DECISION}` → at least one TASK implements it
 3. Cross-reference every critical risk from `{QUALITY_RISKS}` → mitigation in some TASK
 4. Name every acid token `A<n>` from `00_complexity_assessment.md` VERBATIM in the plan (C4), each
@@ -233,11 +235,16 @@ C2 recognises JS/TS, pytest, Go, Rust, JVM and .NET test paths, extensible per p
 
 Never proceed on a non-zero exit, and never treat empty output as a pass — the last line
 (`K2 plan-completeness: PASS|FAIL|NOT-ESTABLISHED`) is the verdict, and its absence is not one.
-What it checks: C1 every ADR has a plan task citing it · C2 every ADR Confirmation test path is named
-in the plan · C3 the `EXPECTED_CODE_TARGETS:` block parses line by line · C4 the feature's declared
-acid corpus is named · C5 (WARN) the `Inputs read:` line. An S-tier run with no `03_adr/` skips C1/C2
-with a note (it cannot be failed for ADRs it never had) — unless the plan itself cites `ADR-<n>`,
-which is NOT-ESTABLISHED. C1 is a grep: it catches "forgot entirely", not "mentioned but not tasked".
+What it checks: C1 every ADR **decision** (a `# ADR-NNN` / `## ADR-NNN` heading INSIDE the file, not
+just the filename prefix — a file with several headings owes several plan citations) has a plan task
+citing it · C2 every ADR Confirmation test path is named in the plan · C3 the `EXPECTED_CODE_TARGETS:`
+block parses line by line · C4 the feature's declared acid corpus is named · C5 (WARN) the
+`Inputs read:` line · C8 every requirement id declared in `01_requirements.md` (`FR-N`, `NFR-N`,
+`AC-N`, `C-N`) is cited by the plan by word boundary — WARN with a count by default, FAIL per missing
+id under `--require-requirements` (the pipeline passes this flag; a bare interactive run of the
+script does not). An S-tier run with no `03_adr/` skips C1/C2 with a note (it cannot be failed for
+ADRs it never had) — unless the plan itself cites `ADR-<n>`, which is NOT-ESTABLISHED. C1 is a grep:
+it catches "forgot entirely", not "mentioned but not tasked".
 
 Pass the run's tier so the check cannot be dodged: `--tier=S|M|L|XL`. An M/L/XL feature with no
 `03_adr/` FAILS C1/C2 (an M+ feature owes ADRs); only `--tier=S` — or no tier at all, and then the

package/templates/.claude/skills/feature-adr/modules/07-code.md

@@ -20,6 +20,7 @@ opus (complex code generation)
 - `{ADR_DECISIONS}` from Step 3 (M+)
 - `{DOMAIN_MODEL}` from Step 4 (L/XL)
 - Codebase context (existing patterns, conventions)
+- {LEARNED_PATTERNS} for Step 7 — the decision-recall block (≤3 lessons), appended to the coder prompt by the pipeline
 
 ## Protocol
 

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

@@ -311,6 +311,86 @@ Compile all findings into a structured report:
 ✅ READY FOR MERGE | ❌ NEEDS FIXES | ⚠️ CONDITIONAL APPROVAL
 ```
 
+### 7.1 Findings ledger (machine-readable)
+
+Prose is for people; `dz score`/`dz recap` need a machine-readable surface too (qe-findings-record,
+ADR-001). Write BOTH of these into `08_qe_report.md`, in addition to the prose report above:
+
+1. Exactly ONE line, in the PROSE body of the file (never inside a fenced code block, an indented
+   code block, a `>` blockquote, or an HTML comment — the parser masks all four before it looks):
+   `QE-VERDICT: <A|A-|A+|B|B+|B-|C|C+|C-|D>` — the letter grade you gave above, machine-parseable,
+   ASCII hyphen for the sign (the parser also accepts U+2212 as the same sign; write ASCII). Two such
+   lines make the report `ambiguous`, never "last wins" — write it once. A line that starts with
+   `QE-VERDICT` but gets the grammar wrong (wrong dash, trailing prose, wrong case, no colon) is worse
+   than writing nothing: the parser reports `invalid` and REFUSES to fall back to guessing a grade
+   from prose — get the one line right rather than close.
+2. A `## Findings ledger` section — this exact heading, occurring EXACTLY ONCE in the file, at the
+   top level (never inside a fence/indented block/blockquote/comment either) — with a table directly
+   under it, under this EXACT header (copy it verbatim):
+
+```markdown
+## Findings ledger
+
+| Finding | Severity | Status | Round | Author | Title |
+|---------|----------|--------|-------|--------|-------|
+| F1 | HIGH | fixed | 1 | codex | escaping bug in the token scanner |
+| F2 | MEDIUM | open | 1 | lead | style nit, not blocking |
+```
+
+A table found ANYWHERE else — before the heading, after the section ends at the next heading, with
+no heading in the file, or with the heading duplicated — is REFUSED as `outside ledger section`,
+never parsed as the real ledger; a second table found INSIDE the section is REFUSED as `duplicate
+table`. Both refusals name how many of the rejected table's rows were ignored.
+
+Closed dictionaries — a row using anything else is REFUSED by the parser, never coerced to the
+nearest known value:
+- **Severity**: `BLOCKER` `CRITICAL` `HIGH` `MEDIUM` `LOW` `INFO`
+- **Status**: `confirmed` `fixed` `partial` `refuted` `named-limit` `open`
+- **Round**: an integer ≥ 1 (which review round raised it)
+- **Author**: `codex` `claude` `lead`
+- **Finding**: a short id token with no spaces (`F1`, `R2-3`, …); **Title**: free text — a literal
+  `|` inside Title must be escaped as `\|`, or wrapped in inline code (`` `a|b` ``), or it fragments
+  the row into extra columns and the row is refused as malformed.
+
+An empty (header-only) table is read as `hollow: true` — worse than no table at all, because it
+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>' --auto --json
+```
+
+`<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: