@dzhechkov/skills-feature-adr 1.5.3 → 1.5.5

package/.dz-manifest.json

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": 1,
+    "version": 3,
     "pack": "skills-feature-adr",
     "files": [
       {
@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "1e3c1a4ed97981b70a3a5099f6355556fc987e493bf478b82cabe552888d2583"
+        "sha256": "bc3de443b7ec23acea734d141164c15a0dc9b262db293581e26b8ebe3b93cc44"
       },
       {
         "path": "bin/cli.js",
@@ -25,7 +25,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "2224692687da750844ef25096d1fc41fc86d7e79743ac7a8f42bf51ba9018750"
+        "sha256": "d027e16c3e24d354656f1463b9d7d7c1514259f69524644f1bd4314db8b960d1"
       },
       {
         "path": "src/cli.js",
@@ -145,11 +145,11 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/05-architecture.md",
-        "sha256": "2ef7cf316903f0cbb1fabe1f0e1770c22b2cb3a11a4118cac0529c25074b5e8a"
+        "sha256": "4d20dbc85ea5bb93ca90fd8cd089255bab9c76a912ca3ad954f3a4bb670f3c45"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/06-implementation-plan.md",
-        "sha256": "b3efdfa1d44f4c51ff46551b5827066955c1f0bfee212d371ac1e2fb1c99980f"
+        "sha256": "c624e0ade0314ca07913ba64e092d4655f86201856e8188c3e616b2320226c1e"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/07-code.md",
@@ -157,7 +157,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/08-qe.md",
-        "sha256": "bd5b5809142c12fa1378de446b68027a0c342a7a91ad17e4fb3395ca8f6a8508"
+        "sha256": "ea8fb546acb7f09816d2fc9f9189a86f2400b8cec91c9ba4b82b68a8e32920bb"
       },
       {
         "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": "eddf116620050e80b88497ace026fb8e0a12986f94f216181480c7daa0e08be4"
+        "sha256": "630eb9047258ad0333082f407cd34522e4c278650f22ef6dba1ef897ec5cce71"
       },
       {
         "path": "templates/.claude/skills/frontend-design/LICENSE.txt",
@@ -313,7 +313,7 @@
       },
       {
         "path": "templates/.claude/workflows/feature-adr.js",
-        "sha256": "a4e277040b42646d9bc1b06f78e32aa11f118a924f1626be67640f87ede8b292"
+        "sha256": "587b36287ce9e9b85b1dfc41fc50d95297f5ac6be32e1e702e0b89b5df0a7892"
       },
       {
         "path": "templates/lib/memory-protocol.md",
@@ -325,5 +325,5 @@
       }
     ]
   },
-  "signature": "uUN7yuKgSOed/hE0xooh1K788NcAFhnvsh92AHcu4oHn/uMZurn0VnktfhsUDHUv3jR8F6bMoKgrb/F6dHrvCQ=="
+  "signature": "QqAf37Y10ocnldYVOw3ci5jzMrd3XIcmHIx6thuagPMZlIoVYHHp74jJX4kHkHvRFNdBF7+O51/F3/7d9jDKAA=="
 }

package/README.md

@@ -169,7 +169,7 @@ refused BY NAME: `path traversal ('..' segment)`, `degenerate path segment`, `em
 `illegal character '<c>'`, `empty stem after the leading dot`. The old substring traversal test also
 rejected the ordinary filename `foo..bar.ts`; it is a segment test now.
 
-### The Step-8 amendment gate runs a command instead of judging (v1.5.3)
+### The Step-8 amendment gate runs a command instead of judging (v1.5.5)
 
 Every `AM-N` row must resolve to a test found INSIDE the file the row names, and the check is
 `dz amendment-check --slug <slug> --json` rather than a paragraph asking the reviewer to confirm it.
@@ -1113,7 +1113,27 @@ deliberately excluded — "skeleton first" is nonsense there.
 
 ## Status
 
-`1.5.3` — **the workflow stops crashing on the way into Step 7.** `1.5.3` shipped a workflow that
+`1.5.4` — **Step 5 now asks how the shipped feature will be watched.** The architecture artifact must
+carry a section headed exactly `Observability` answering what the feature logs, what it counts, what a
+failure looks like from outside, and who would notice. **"Nothing to observe" is a complete answer** —
+a pure refactor or a CI-only gate genuinely emits nothing, and a check that cannot express a true fact
+gets switched off. What is not acceptable is leaving the question unanswered. MEASURED before the
+change: the word appeared nowhere in the pipeline's prompts, and ZERO of 107 architecture artifacts
+carried such a section, while two fully-written observability skills (818 and 946 lines) sat
+unreachable because nothing called them. `dz score` reports the answer as a discipline — descriptive,
+never a gate, because the whole existing corpus predates the requirement.
+
+Also in the bundled workflow: the K2 gate stops GUESSING the workspace. When it was not pinned, the
+workspace candidate was taken from the gate agent's own working directory, which against an external
+target repo resolved to that repo — so the candidate silently became a duplicate of the repo
+candidate and a skill installed in the workspace was never found (`NOT-ESTABLISHED`, exit 3, the
+coding step never ran). New `args.workspace` pins it, the shipped call site passes it, each candidate
+is labelled in the audit line, and a `K2_GATE_NOTE` fires when two collapse onto one path. And a
+pre-code probe that returns nothing no longer becomes an all-null baseline that later reads as
+"every target changed".
+
+
+`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
 by default and every ultracode run that reached the coding step died with a `ReferenceError` while

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "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

@@ -35,7 +35,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "1e3c1a4ed97981b70a3a5099f6355556fc987e493bf478b82cabe552888d2583"
+          "content": "bc3de443b7ec23acea734d141164c15a0dc9b262db293581e26b8ebe3b93cc44"
         }
       ]
     },
@@ -62,10 +62,14 @@
     {
       "type": "file",
       "name": "package.json",
-      "hashes": [
+      "properties": [
         {
-          "alg": "SHA-256",
-          "content": "2224692687da750844ef25096d1fc41fc86d7e79743ac7a8f42bf51ba9018750"
+          "name": "dz:digest-basis",
+          "value": "package-json-ordered-conditions-v2"
+        },
+        {
+          "name": "dz:canonical-json-sha256-v2",
+          "value": "d027e16c3e24d354656f1463b9d7d7c1514259f69524644f1bd4314db8b960d1"
         }
       ]
     },
@@ -365,7 +369,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "2ef7cf316903f0cbb1fabe1f0e1770c22b2cb3a11a4118cac0529c25074b5e8a"
+          "content": "4d20dbc85ea5bb93ca90fd8cd089255bab9c76a912ca3ad954f3a4bb670f3c45"
         }
       ]
     },
@@ -375,7 +379,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "b3efdfa1d44f4c51ff46551b5827066955c1f0bfee212d371ac1e2fb1c99980f"
+          "content": "c624e0ade0314ca07913ba64e092d4655f86201856e8188c3e616b2320226c1e"
         }
       ]
     },
@@ -395,7 +399,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "bd5b5809142c12fa1378de446b68027a0c342a7a91ad17e4fb3395ca8f6a8508"
+          "content": "ea8fb546acb7f09816d2fc9f9189a86f2400b8cec91c9ba4b82b68a8e32920bb"
         }
       ]
     },
@@ -625,7 +629,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "eddf116620050e80b88497ace026fb8e0a12986f94f216181480c7daa0e08be4"
+          "content": "630eb9047258ad0333082f407cd34522e4c278650f22ef6dba1ef897ec5cce71"
         }
       ]
     },
@@ -785,7 +789,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "a4e277040b42646d9bc1b06f78e32aa11f118a924f1626be67640f87ede8b292"
+          "content": "587b36287ce9e9b85b1dfc41fc50d95297f5ac6be32e1e702e0b89b5df0a7892"
         }
       ]
     },

package/templates/.claude/skills/feature-adr/modules/05-architecture.md

@@ -118,6 +118,32 @@ GET /api/v1/{resource}/:id
   Errors: 401, 404
 ```
 
+## Observability — a MANDATORY section of `05_architecture.md`
+
+The artifact must carry a section headed exactly **`Observability`**, answering how anyone would
+know this feature is working once it ships:
+
+- what it **logs**, and at what level;
+- what it **counts** — the one or two numbers that would move if it broke;
+- what a **failure looks like from outside** — the symptom, not the stack trace;
+- **who would notice**, and how.
+
+If the feature genuinely emits nothing at runtime — a pure refactor, a doc change, a gate that only
+runs in CI — write **"nothing to observe"** and say why. That is a complete answer, not a gap. What
+is not acceptable is leaving the question unanswered.
+
+The heading is read by a machine (`dz score` reports it as a discipline), so it is spelled exactly
+`Observability` — the prompt above and the check derive that word from one shared constant, because
+a prompt asking for one heading while a check greps another produces a gate that fails every honest
+run.
+
+**Why this section exists.** MEASURED 2026-08-25: across 107 existing `05_architecture.md` files,
+ZERO carried such a section, and the word `observability` appeared nowhere in the pipeline's own
+prompts. The pipeline kept five telemetry stores about itself and asked for none about what it
+built. The two capable skills — `observability` (818 lines) and `observability-testing-patterns`
+(946 lines) — were fully written and unreachable, because nothing called them. This section is the
+call site.
+
 ## Write discipline (the 180-second rule)
 
 An executor that returns from a tool call and then thinks in silence past **180 seconds** is killed by the

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

@@ -130,8 +130,15 @@ Before finalizing the plan, validate completeness:
 1. Cross-reference every `{REQUIREMENT}` (FR-N) → at least one TASK covers it
 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. If gaps found → add missing TASKs and re-order the DAG
-5. **Iterate until no gaps remain** (max 3 iterations, then flag for user)
+4. Name every acid token `A<n>` from `00_complexity_assessment.md` VERBATIM in the plan (C4), each
+   bound to the TASK that owns it and the TEST that proves the refusal — the gate reads them with a
+   word-boundary regex, so a paraphrase, a range (`A1-A7`) or a renamed token does not count
+5. Carry an `Inputs read:` line naming at least `03_adr` and `05_architecture` (C5). Put it at the
+   TOP of the plan or immediately BEFORE the trailing `EXPECTED_CODE_TARGETS:` block — never after
+   it. The plan must END with that targets block, so "end with Inputs read" would contradict the
+   layout the coder reads (cross-family QE, gpt-5.6-sol)
+6. If gaps found → add missing TASKs and re-order the DAG
+7. **Iterate until no gaps remain** (max 3 iterations, then flag for user)
 
 This gap-check loop ensures the implementation plan is complete before coding begins.
 
@@ -190,6 +197,14 @@ Create `features/<slug>/06_implementation_plan.md` with:
   the NEXT `AM-N` begins. Multi-line amendments are fine; what is NOT fine is putting a marker after
   the following amendment has already started, because it then belongs to that one. A bare range
   like `AM-1..AM-4` never opens a row.
+  TWO machines read this row with ONE grammar and different depths: the K2 C6 gate asks whether the
+  row is well-formed; `dz amendment-check` asks whether the named test RESOLVES to a real title in a
+  real file. So the marker carries ALL THREE parts — an arrow (`→` or `->`), the test id in
+  backticks, and the file as `` in `path` ``:
+  `AM-N (source): <change>. Confirmation: <property> → test \`test_name\` in \`path/to/file\` (fails if reverted).`
+  A marker WITHOUT the file used to pass the plan gate and then fail Step 8 with `no-file-named` —
+  that is the exact defect this shape removes. The alternative complete form is a retraction:
+  `superseded by AM-N`, which both machines accept.
   A safeguard amendment's named test must prove it TRIGGERS on a real input, not merely that its code
   path exists. Step 8 verifies every named test exists and is non-vacuous (`dz discrimination-check`).
 

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

@@ -246,6 +246,25 @@ ITERATION {N}:
   Max iterations: 3. After 3 iterations, flag remaining gaps for user decision.
 ```
 
+**Do NOT count the iterations yourself — ASK.** Before starting another rework round, run:
+
+```bash
+dz qe-rounds --slug <slug>
+```
+
+`0` under the ceiling, another round is within budget · `1` **STOP** — the ceiling is reached, the
+remaining gaps go to the owner · `2` NOT ESTABLISHED, which is never "zero rounds".
+
+It reads what `dz qe-bridge` already wrote and records nothing of its own, so it answers correctly
+across restarts and for runs already past.
+
+**Why this is a command and not a sentence you remember.** Until 2026-08-27 this rule existed ONLY as
+the line above: `grep -rl 'ReviewScope|scopeId|findingId|lineage'` over harness-core and harness-cli
+returned nothing, so there was no counter anywhere. Every restart of the agent forgot the sentence.
+MEASURED cost on real data: one slug reached **38** graded rounds and 4 attempts with no verdict,
+against a ceiling of 3. A rule at layer 4 of the cost-of-detection ladder fails silently — nobody
+complains that the ceiling was missed, it is simply never reached.
+
 This loop implements the "did we miss something?" recursive check from the original pipeline spec.
 
 ### 6. Acceptance Criteria Validation

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

@@ -301,15 +301,38 @@ else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\
   // Line-scan, not regex-over-document: \Z is Python, and $-lookahead under /m matches every
   // line end — a section with no FOLLOWING heading silently failed to parse (caught by the
   // fixture the moment the tests ran).
-  const planLines = plan.split('\n');
+  // Fenced blocks are BLANKED line-for-line, preserving numbering and offsets: a fenced
+  // `## Amendments` could become the section heading, and a fenced example row could either open a
+  // phantom amendment or hand a real testless one someone else's marker. Third fence-blindness
+  // found in a checker today, so it is closed here by construction rather than by care.
+  const rawLines = plan.split('\n');
+  const planLines = [];
+  {
+    let fence = null;
+    for (const line of rawLines) {
+      const open = /^ {0,3}(```+|~~~+)/.exec(line);
+      if (fence === null && open) { fence = open[1][0]; planLines.push(''); continue; }
+      if (fence !== null) {
+        planLines.push('');
+        if (new RegExp('^ {0,3}' + fence + '{3,}\\s*$').test(line)) fence = null;
+        continue;
+      }
+      planLines.push(line);
+    }
+  }
   let sectionStart = -1, sectionEnd = -1, cursor = 0;
   for (const pl of planLines) {
-    if (sectionStart < 0 && /^##\s*Amendments\s*$/.test(pl)) sectionStart = cursor + pl.length + 1;
-    else if (sectionStart >= 0 && sectionEnd < 0 && /^##\s/.test(pl)) sectionEnd = cursor;
+    // The SAME heading shape amendment-trace.ts accepts: up to three leading spaces, two to four
+    // hashes, and trailing text allowed. C6 required exactly `##` with nothing after, so the two
+    // tools disagreed about where the section even IS — the divergence this feature exists to end.
+    if (sectionStart < 0 && /^ {0,3}#{2,4}\s+Amendments\b/.test(pl)) sectionStart = cursor + pl.length + 1;
+    else if (sectionStart >= 0 && sectionEnd < 0 && /^ {0,3}#{1,4}\s/.test(pl)) sectionEnd = cursor;
     cursor += pl.length + 1;
   }
   if (sectionStart >= 0 && sectionEnd < 0) sectionEnd = plan.length;
-  const amSection = sectionStart >= 0 ? plan.slice(sectionStart, sectionEnd) : '';
+  // Sliced from the MASKED text so the offsets computed above line up with what is scanned.
+  const maskedPlan = planLines.join('\n');
+  const amSection = sectionStart >= 0 ? maskedPlan.slice(sectionStart, sectionEnd) : '';
   // Only a DEFINITION-shaped line counts as a stray: a list item opening with the AM token.
   // A mid-prose REFERENCE («per 01_requirements.md (AM-1..AM-6)», «(AM-1: the clause stays
   // dropped)») cites an amendment defined in ANOTHER artifact and is legitimate — the first cut
@@ -317,7 +340,11 @@ else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\
   {
     let cursor2 = 0;
     for (const pl of planLines) {
-      const isDef = /^\s*(?:[-*|]\s*)\*{0,2}AM-(?:CP-)?\d+\b/.test(pl);
+      // The SAME row shape as the in-section rule, or the two disagree about what a row is: a
+      // 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);
       const inSection = sectionStart >= 0 && cursor2 >= sectionStart && cursor2 < sectionEnd;
       if (isDef && !inSection) {
         const tok = (/AM-(?:CP-)?\d+/.exec(pl) || ['AM-?'])[0];
@@ -346,16 +373,39 @@ else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\
     // check entirely (MEASURED). The `(?!\s*\.)` guard is what refuses a wrapped `AM-1..AM-4;`
     // range preamble, which used to open a phantom amendment and double-count AM-1 — it costs 0 rows.
     const DEF = /^(?:[-*|]\s*)?\*{0,2}(AM-(?:CP-)?\d+)\*{0,2}\b(?!\s*\.)/;
-    // `tests?` — the two-id form `-> tests \`a\` and \`b\`` is corpus-canonical and is what
-    // amendment-trace.ts parses; matching only the singular turned two currently-green rows red.
-    const MARK = /\u2192\s*tests?\b|->\s*tests?\b/;
+    // The marker must carry what the LATER gate needs to resolve: an arrow, a backticked test id,
+    // and a file as `in \`path\``. Until 2026-08-25 this accepted a bare `-> test`, so a plan cleared
+    // K2 and then failed Step-8 `dz amendment-check` with `no-file-named` — the two tools read one
+    // row under different contracts (field report doc-26). Same grammar, different depth: this asks
+    // whether the row is WELL-FORMED, amendment-check asks whether it RESOLVES.
+    // The two-id form `-> tests \`a\` and \`b\`` is corpus-canonical; matching only the singular
+    // turned two green rows red when this was last touched.
+    const MARK = /(?:\u2192|->)\s*tests?\s+`[^`]+`(?:\s*(?:and|и)\s*`[^`]+`)?[\s\S]{0,40}?\bin\s+`[^`]+`/;
     const defs = [];
     secLines.forEach((l, i) => { const m = DEF.exec(l.trim()); if (m) defs.push({ i, id: m[1] }); });
     for (let k = 0; k < defs.length; k++) {
       const to = k + 1 < defs.length ? defs[k + 1].i : secLines.length;
       const block = secLines.slice(defs[k].i, to).join('\n');
       const hasTest = MARK.test(block);
-      const superseded = /superseded by AM-(?:CP-)?\d+/i.test(block);
+      // A MENTION is not a CLAIM — the third instance of that class found today. An unanchored
+      // substring test passes on "NOT superseded by AM-9" and on a sentence quoting the form.
+      // Anchoring on POSITION was tried and rejected: real rows put prose between the id and the
+      // retraction, so a position rule refuses legitimate corpus forms. The rule is therefore about
+      // NEGATION and QUOTATION, the two ways a mention differs from a claim — plus the successor
+      // must EXIST among the amendments defined here, since a retraction pointing at AM-999999 is
+      // not a retraction but a way through the gate.
+      let superseded = false;
+      for (const bl of block.split('\n')) {
+        const re = /superseded by (AM-(?:CP-)?\d+)\b/ig;
+        for (let m = re.exec(bl); m !== null; m = re.exec(bl)) {
+          const before = bl.slice(0, m.index);
+          if (/\b(?:not|never|no|isn't|is not|rather than|instead of)\s*$/i.test(before)) continue;
+          const quotes = (before.match(/[`"«]/g) || []).length;
+          if (quotes % 2 === 1) continue;
+          if (m[1] && defs.some((d) => d.id.toLowerCase() === m[1].toLowerCase())) { superseded = true; break; }
+        }
+        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`);
     }
   }
@@ -368,7 +418,11 @@ else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\
 // with both sides named and never blocks.
 {
   const adrAll = adrFiles.map((f) => { try { return readFileSync(join(adrDir, f), 'utf-8'); } catch { return ''; } }).join('\n');
-  const cmds = (t) => new Set([...t.matchAll(/`dz ([a-z][a-z0-9-]+)`/g)].map((m) => m[1]));
+  // The tail is OPTIONAL and stops at the first closing backtick (`[^`]*`, never `.*`): a command
+  // cited WITH its real arguments must be visible on BOTH sides, or a genuine ADR<->plan divergence
+  // hides whenever both files write the natural form (ADR-002, backlog 420e5b79). The CAPTURE stays
+  // the bare name, so the comparison remains a set of command NAMES and flag differences never warn.
+  const cmds = (t) => new Set([...t.matchAll(/`dz ([a-z][a-z0-9-]+)(?:\s[^`]*)?`/g)].map((m) => m[1]));
   const inAdr = cmds(adrAll); const inPlan = cmds(plan);
   const onlyAdr = [...inAdr].filter((c) => !inPlan.has(c));
   const onlyPlan = [...inPlan].filter((c) => !inAdr.has(c));

package/templates/.claude/workflows/feature-adr.js

@@ -505,9 +505,31 @@ function captureFailureRecord(stage, mode, reason, detail) {
 }
 function tpFamily(spec) { return /codex|gpt|openai/i.test(String(spec == null ? '' : spec)) ? 'codex' : 'claude' }
 function tpText(v) { if (typeof v === 'string') return v; if (v === null || v === undefined) return ''; try { const s = JSON.stringify(v); return typeof s === 'string' ? s : String(v) } catch (e) { return String(v) } }
+// Operator-profile redaction (mirror of harness-core redactProfileBlock — ADR-001 Decision 5 /
+// CF-6 of operator-profile). The PERSIST seam in `dz feature-adr-record` redacts independently;
+// this mirror exists so the truncation fnv1a64 hashes below are hashes of the REDACTED text and
+// never fingerprint personal data, exactly like the core builder. Unterminated block fails
+// CLOSED: everything from the start marker to the end of the text is dropped.
+const TP_PROFILE_START = '<!-- dz:profile:start -->'
+const TP_PROFILE_END = '<!-- dz:profile:end -->'
+const TP_PROFILE_REDACTED = '[dz:profile REDACTED]'
+function tpRedact(text) {
+  if (typeof text !== 'string' || text === '') return typeof text === 'string' ? text : ''
+  let out = ''
+  let rest = text
+  for (;;) {
+    const start = rest.indexOf(TP_PROFILE_START)
+    if (start === -1) return out + rest
+    out += rest.slice(0, start) + TP_PROFILE_REDACTED
+    const end = rest.indexOf(TP_PROFILE_END, start + TP_PROFILE_START.length)
+    if (end === -1) return out
+    rest = rest.slice(end + TP_PROFILE_END.length)
+  }
+}
 function buildTrainingPair(slug, stage, ts, inputRaw, outputRaw, evaluation, provenance, captureMode, resumed) {
-  let input = tpText(inputRaw)
-  let output = tpText(outputRaw)
+  // Redaction FIRST, before the oversize guard — same order as the core builder.
+  let input = tpRedact(tpText(inputRaw))
+  let output = tpRedact(tpText(outputRaw))
   let truncated = null
   if (input.length + output.length > TP_MAX_IO) {
     truncated = { inputChars: input.length, outputChars: output.length, inputHash: fnv1a64(input), outputHash: fnv1a64(output) }
@@ -921,9 +943,23 @@ function codexExecPlan(stage, promptChars, probedId, scoped) {
 // A model id is user input (args.codexModel) and lands in a shell command the agent runs. Cross-model
 // review (codex exec, 2026-07-10) found it interpolated unquoted. Plain ids only, quoted anyway.
 function isSafeCodexId(id) { return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(String(id)) }
-function codexProbeCommand(id) {
+const TIMEOUT_BINS = { timeout: true, gtimeout: true }
+
+// Which binary bounds a dispatched run. timeout(1) is GNU coreutils and is NOT on macOS; brew's
+// coreutils installs it as gtimeout. An ALLOWLIST, because this value goes into a shell command.
+// MEASURED 2026-08-25: with neither present the dispatch exits 127 and cross-family QE — a NAMED
+// safety property — silently did not happen for a whole run.
+// Deliberately NOT the perl alarm+exec form: MEASURED, it exits 142 while GNU timeout exits 124,
+// and classifyCodexQeOutcome keys timeout on exit === 124. A remedy that breaks the classifier is
+// worse than the defect it fixes.
+function timeoutBinOrDefault(bin) {
+  const b = typeof bin === 'string' ? bin : ''
+  return TIMEOUT_BINS[b] === true ? b : 'timeout'
+}
+
+function codexProbeCommand(id, timeoutBin) {
   if (!isSafeCodexId(id)) return null
-  return "timeout 60 codex exec -m '" + id + "' 'Reply with exactly: OK' < /dev/null"
+  return timeoutBinOrDefault(timeoutBin) + " 60 codex exec -m '" + id + "' 'Reply with exactly: OK' < /dev/null"
 }
 
 // A verdict must NAME its grade. "Looks good" is not a review — cross-model review caught this too.
@@ -956,7 +992,7 @@ const CODEX_REVIEW_TIMEOUT_SECONDS = 600
 const CODEX_REVIEW_DEFAULT_EFFORT = 'high'
 const CODEX_TIMEOUT = 'CODEX_TIMEOUT'
 const CODEX_QE_SIGNAL_PREFIX = 'CODEX-QE-SIGNAL'
-const CODEX_QE_DECLINE_KINDS = ['timeout', 'no-verdict', 'tool-error', 'unusable-output', 'unavailable', 'over-ceiling']
+const CODEX_QE_DECLINE_KINDS = ['timeout', 'no-verdict', 'tool-error', 'unusable-output', 'unavailable', 'over-ceiling', 'wrong-tree']
 const SCOPED_QE_MAX_FILES = 3
 const SCOPED_QE_MAX_QUESTIONS = 4
 const SCOPED_QE_MAX_PATH_CHARS = 200
@@ -974,6 +1010,23 @@ function isSafeCodexRef(ref) {
 // --uncommitted alike. Either mistake presents as a review that silently did not happen, so both are
 // refusals in the builder, not comments. carriesPrompt is kept as a field: it is the one boolean a
 // future CLI would flip.
+function codexSq(s) { return "'" + String(s).replace(/'/g, "'\\''") + "'" }
+function codexCd(repo) { return repo === '' ? '' : 'cd ' + codexSq(repo) + ' && ' }
+// Field report 27: BOTH codex dispatches ran with no working directory, so they read the SESSION cwd.
+// On a run against an external checkout that is a different tree — and the review still exits 0 with a
+// Grade the pipeline records as a verdict, while crossFamilyQe.happened stays true. codex exec takes
+// -C; codex review has no such flag (measured on codex-cli 0.149.1) and needs a cd prefix.
+function codexExecCommand(input) {
+  const o = input || {}
+  const modelId = String(o.modelId === undefined || o.modelId === null ? '' : o.modelId)
+  if (!isSafeCodexId(modelId)) return null
+  const raw = Number(o.timeoutSeconds)
+  const seconds = (raw === raw && raw !== Infinity && raw > 0) ? Math.floor(raw) : CODEX_EXEC_TIMEOUT_SECONDS
+  const repo = String(o.repo === undefined || o.repo === null ? '' : o.repo)
+  const cd = repo === '' ? '' : ' -C ' + codexSq(repo)
+  return timeoutBinOrDefault(o.timeoutBin) + ' ' + seconds + ' codex exec' + cd + ' -m ' + codexSq(modelId) + ' ' + codexSq(String(o.prompt === undefined || o.prompt === null ? '' : o.prompt)) + ' < /dev/null'
+}
+
 function codexReviewCommand(input) {
   const o = input || {}
   const scope = (o.scope === undefined || o.scope === null || o.scope === '') ? 'uncommitted' : String(o.scope)
@@ -988,7 +1041,8 @@ function codexReviewCommand(input) {
   if (scope !== 'uncommitted' && !isSafeCodexRef(ref)) return { cmd: null, carriesPrompt: false, scope: scope, reason: 'unsafe id or ref' }
   const raw = Number(o.timeoutSeconds)
   const seconds = (raw === raw && raw !== Infinity && raw > 0) ? Math.floor(raw) : CODEX_REVIEW_TIMEOUT_SECONDS
-  let cmd = 'timeout ' + seconds + " codex review -c model='" + modelId + "' -c model_reasoning_effort='" + effort + "'"
+  const repo = String(o.repo === undefined || o.repo === null ? '' : o.repo)
+  let cmd = codexCd(repo) + timeoutBinOrDefault(o.timeoutBin) + ' ' + seconds + " codex review -c model='" + modelId + "' -c model_reasoning_effort='" + effort + "'"
   if (scope === 'commit') cmd += " --commit '" + ref + "'"
   else if (scope === 'base') cmd += " --base '" + ref + "'"
   else cmd += ' --uncommitted'
@@ -1097,6 +1151,37 @@ function gradeFromReviewFindings(findings) {
 // called it 'unusable-output' and told the operator to fix a tool that works. And exit 0 is a
 // SUCCESSFUL review even when it finds blockers (MEASURED probe 0.2), so tool-error is exit not in
 // {0,124} only. signalExpected defaults TRUE (fail closed): a swallowed sentinel is a tool-error.
+// Field report 27. A review dispatched into the wrong working directory does not error: the declared
+// paths simply are not there, the model says so in prose, and the command still exits 0 — often with
+// a Grade line, which the pipeline then records as a verdict about code nobody read. Narrow on
+// purpose: a review of a file-handling module may legitimately DISCUSS "No such file or directory",
+// and a mention is not a claim — so one LINE must carry both the phrase and a declared path.
+function codexReviewMissedItsFiles(body, declaredFiles) {
+  const text = String(body === undefined || body === null ? '' : body)
+  const files = Array.isArray(declaredFiles) ? declaredFiles.filter((f) => typeof f === 'string' && f !== '') : []
+  if (text === '' || files.length === 0) return false
+  // Only quotes, whitespace and a colon may sit between the path and the failure. Prose may not —
+  // and that single restriction is what separates "the tool could not open this path" from "this
+  // finding is ABOUT this path": a review finding always names its file, so anything looser marks
+  // every file-handling review as wrong-tree. (Codex, gpt-5.6-sol, on the first version of this
+  // function: the finding line "- [P2] Do not swallow file not found - src/io.ts:42" plus a stated
+  // grade C was classified wrong-tree, discarding a valid cross-family verdict and falling back to
+  // same-family QE — the guard against a false-clean review destroying a true one.)
+  const GAP = '["\'\u2018\u2019\u201c\u201d\u0060(\\[\\s:,]{0,4}'
+  const NOT_FOUND = 'no such file or directory|file not found|not found|does not exist|is not present|cannot be found'
+  const VERB = '(?:cannot|can\'t|could not|couldn\'t|unable to|failed to|error(?: while)?)\\s+(?:open|read|find|access|stat|locate|load)'
+  for (const f of files) {
+    const q = f.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const shapes = [
+      q + GAP + '(?:' + NOT_FOUND + ')',          // src/io.ts: No such file or directory
+      '(?:' + NOT_FOUND + ')' + GAP + q,          // No such file or directory: src/io.ts
+      VERB + GAP + q,                             // cannot open 'src/io.ts'
+    ]
+    for (const shape of shapes) if (new RegExp(shape, 'i').test(text)) return true
+  }
+  return false
+}
+
 function classifyCodexQeOutcome(input) {
   const o = input || {}
   const body = String(o.body === undefined || o.body === null ? '' : o.body)
@@ -1117,6 +1202,9 @@ function classifyCodexQeOutcome(input) {
   } else if (exit !== 0) {
     return { kind: 'tool-error' }
   }
+  // BEFORE the grade rule: a wrong-tree review usually DOES state a grade, and that clean letter
+  // about unread code is the most dangerous thing this pipeline can emit.
+  if (codexReviewMissedItsFiles(body, o.declaredFiles)) return { kind: 'wrong-tree' }
   if (grade !== null) return { kind: 'verdict' }
   return { kind: 'no-verdict' }
 }
@@ -1137,11 +1225,14 @@ function codexQeDeclineReason(kind, detail) {
   const exit = (d.exit === undefined || d.exit === null) ? '?' : String(d.exit)
   const chars = (d.chars === undefined || d.chars === null) ? '?' : String(d.chars)
   const extra = (d.detail === undefined || d.detail === null || String(d.detail) === '') ? 'no detail' : String(d.detail)
+  if (canonical === 'wrong-tree') return 'codex reported that the declared file(s) do not exist — the review ran in the WRONG working directory and its verdict is about a tree nobody asked for; ' + files + ' file(s) declared, exit ' + exit + ' (' + extra + ')'
   if (canonical === 'timeout') return 'codex review timed out after ' + elapsed + 's on scope ' + ref + ' (' + files + ' files) — NARROW the scope (this is reconnaissance cost, not thinking time)'
   if (canonical === 'no-verdict') return 'codex answered in ' + elapsed + 's but named no grade — not a verdict'
   if (canonical === 'tool-error') return 'codex review exited ' + exit + ' — FIX the invocation (' + extra + ')'
   if (canonical === 'unusable-output') return 'codex exec unusable — ' + ((d.reason === undefined || d.reason === null || String(d.reason) === '') ? 'codex exec returned no text' : String(d.reason))
-  if (canonical === 'unavailable') return 'codex not used — ' + ((d.reason === undefined || d.reason === null || String(d.reason) === '') ? 'codex exec reported it could not run' : String(d.reason))
+  // The detail is the ONE field carrying the shell error, and this branch used to drop it while
+  // tool-error right above rendered it — the asymmetry that made the field report unfixable blind.
+  if (canonical === 'unavailable') return 'codex not used — ' + ((d.reason === undefined || d.reason === null || String(d.reason) === '') ? 'codex exec reported it could not run' : String(d.reason)) + (extra === 'no detail' ? '' : ' (' + extra + ')')
   if (canonical === 'over-ceiling') return 'prompt is ' + chars + ' chars / unscoped — refused before dispatch'
   throw new Error('codexQeDeclineReason: unknown kind ' + k)
 }
@@ -1157,12 +1248,12 @@ function codexDeclineReason(a, b) {
 // this input may never have been wrapped (a saved fixture, a report on disk), so a missing sentinel
 // means "no machine signal exists", not "the tool failed". The PIPELINE must not use that leniency —
 // the dispatch below calls classifyCodexQeOutcome directly with signalExpected true.
-function parseCodexReviewResult(text) {
+function parseCodexReviewResult(text, declaredFiles) {
   const sig = parseCodexReviewSignal(text)
   const findings = parseCodexReviewFindings(sig.body)
   const stated = parseCodexGrade(sig.body)
   const grade = (stated !== null) ? stated : gradeFromReviewFindings(findings)
-  const outcome = classifyCodexQeOutcome({ exit: sig.exit, body: sig.body, grade: grade, findings: findings, signalExpected: sig.signalPresent })
+  const outcome = classifyCodexQeOutcome({ exit: sig.exit, body: sig.body, grade: grade, findings: findings, signalExpected: sig.signalPresent, declaredFiles: declaredFiles })
   const kind = (outcome.kind === 'unusable-output') ? 'empty' : outcome.kind
   const ok = kind === 'verdict'
   const reason = ok ? null : codexQeDeclineReason(kind, { elapsedSeconds: sig.elapsedSeconds, exit: sig.exit, chars: sig.body.length })
@@ -1186,12 +1277,35 @@ async function safeCodexAgent(prompt, opts) {
 
 // CX-1: the allowlist says a name is spellable; only a probe says it answers. One probe per run.
 let _probedCodexId
+// Which timeout binary this machine actually has. ONE cached shell probe, run before either
+// dispatch mode spends a model call.
+//
+// The model probe below is NOT a substitute: it is judged by the agent's prose ("reply with its
+// stdout only"), so on the machine in field report doc-24 it passed while timeout(1) was absent —
+// the agent evidently retried without the missing prefix — and only the strict "run this VERBATIM"
+// dispatch surfaced the 127. A shell fact must be checked by a shell, once, deterministically.
+let _timeoutBin
+async function probeTimeoutBin() {
+  if (_timeoutBin !== undefined) return _timeoutBin
+  const cmd = 'command -v timeout >/dev/null 2>&1 && echo timeout || { command -v gtimeout >/dev/null 2>&1 && echo gtimeout || echo NONE; }'
+  const out = await agent('Run EXACTLY this via Bash and reply with its stdout only: ' + cmd, { label: 'probe:timeout-bin', phase: 'Route', model: 'haiku', effort: 'low' })
+  const t = String(out === null || out === undefined ? '' : out).trim()
+  _timeoutBin = TIMEOUT_BINS[t] === true ? t : null
+  if (_timeoutBin === null) log('codex: NEITHER timeout(1) NOR gtimeout is on PATH — every codex dispatch would exit 127; on macOS: brew install coreutils')
+  else if (_timeoutBin !== 'timeout') log('codex: bounding runs with ' + _timeoutBin + ' (timeout(1) is absent — darwin without coreutils on PATH)')
+  return _timeoutBin
+}
+
 async function probeCodexId() {
   if (_probedCodexId !== undefined) return _probedCodexId
   const raw = (CODEX_MODEL && CODEX_MODEL !== 'auto') ? [CODEX_MODEL, 'gpt-5.6-sol', 'gpt-5.5'] : ['gpt-5.6-sol', 'gpt-5.5']
   const ids = raw.filter(isSafeCodexId)
   for (const id of ids) {
-    const cmd = codexProbeCommand(id)
+    // The probe is built with the SAME binary the real dispatch will use, so a machine that cannot
+    // bound a run fails here rather than mid-QE.
+    const tbin = await probeTimeoutBin()
+    if (tbin === null) { _probedCodexId = null; return null }
+    const cmd = codexProbeCommand(id, tbin)
     if (!cmd) { log('codex: refusing unsafe model id ' + id); continue }
     const out = await agent('Run EXACTLY this via Bash and reply with its stdout only: ' + cmd + ' — if it fails or times out reply with exactly ' + CODEX_UNAVAILABLE, { label: 'probe:' + id, phase: 'Route', model: 'haiku', effort: 'low' })
     if (out && /\bOK\b/.test(String(out)) && String(out).indexOf(CODEX_UNAVAILABLE) === -1) {
@@ -1249,7 +1363,7 @@ async function runCodexQeCommand(stage, cmd, phaseName, label, probed, mode, sco
   // the closing line, may read it.
   const stated = (allowStatedGrade === true) ? parseCodexGrade(sig.body) : null
   const grade = (stated !== null) ? stated : gradeFromReviewFindings(findings)
-  const outcome = classifyCodexQeOutcome({ exit: sig.exit, body: sig.body, grade: grade, findings: findings, signalExpected: true })
+  const outcome = classifyCodexQeOutcome({ exit: sig.exit, body: sig.body, grade: grade, findings: findings, signalExpected: true, declaredFiles: files })
   if (outcome.kind !== 'verdict') {
     return noteCodexDecline(stage, outcome.kind, { elapsedSeconds: sig.elapsedSeconds, exit: sig.exit, ref: scopeRef, files: files, chars: cmd.length, reason: parseCodexExecResult(sig.body).reason, detail: sig.body.slice(0, 160) })
   }
@@ -1263,7 +1377,7 @@ async function codexReviewAgent(stage, scope, scopeRef, phaseName) {
   lastCodexDecline = null
   const probed = await probeCodexId()
   if (!probed) return noteCodexDecline(stage, 'unavailable', { reason: 'no codex model id answered the probe' })
-  const built = codexReviewCommand({ scope: scope, ref: scopeRef, modelId: probed, reasoning: 'high', timeoutSeconds: CODEX_REVIEW_TIMEOUT_SECONDS })
+  const built = codexReviewCommand({ scope: scope, ref: scopeRef, modelId: probed, reasoning: 'high', timeoutSeconds: CODEX_REVIEW_TIMEOUT_SECONDS, timeoutBin: await probeTimeoutBin(), repo: REPO })
   if (built.cmd === null) return noteCodexDecline(stage, 'tool-error', { exit: 2, detail: built.reason })
   return await runCodexQeCommand(stage, built.cmd, phaseName, stage + ':codex-review', probed, 'A', built.scope + (scopeRef ? ' ' + scopeRef : ''), [], false)
 }
@@ -1275,7 +1389,11 @@ async function codexExecAgent(stage, prompt, phaseName, scoped, files) {
   const probed = await probeCodexId()
   const plan = codexExecPlan(stage, prompt.length, probed, scoped)
   if (plan.mode !== 'exec') return noteCodexDecline(stage, 'unavailable', { reason: plan.reason })
-  const inner = 'timeout ' + CODEX_EXEC_TIMEOUT_SECONDS + ' codex exec -m ' + JSON.stringify(probed) + ' ' + JSON.stringify(prompt) + ' < /dev/null'
+  // Was JSON.stringify(...) — DOUBLE quotes, in which the shell still expands a command substitution, and the
+  // prompt carries the user's own feature description. Single-quoted through codexSq closes that
+  // as a side effect of pinning the working directory.
+  const inner = codexExecCommand({ modelId: probed, prompt: prompt, timeoutBin: await probeTimeoutBin(), timeoutSeconds: CODEX_EXEC_TIMEOUT_SECONDS, repo: REPO })
+  if (inner === null) return noteCodexDecline(stage, 'unavailable', { reason: 'unsafe codex id ' + String(probed) })
   return await runCodexQeCommand(stage, inner, phaseName, stage + ':codex-exec', probed, 'B', 'declared-targets(' + (files || []).length + ' declared, <=' + SCOPED_QE_MAX_FILES + ' reviewed)', files || [], true)
 }
 
@@ -1978,7 +2096,7 @@ const DISCRIMINATION_GATE = '\u00a742 TEST-DISCRIMINATION GATE (run right after
 // amendment is a mini-ADR: it carries a one-line Confirmation naming the test that falsifies it. Machine-checkable
 // shape (a linter can assert the `→ test ` token); Step-8 verifies existence + non-vacuity via the SAME
 // dz discrimination-check that guards the ADR property (cost-of-detection ladder: judgment → step gate).
-const AMENDMENT_RULE = 'AMENDMENT CONFIRMATION DISCIPLINE (every amendment is a mini-ADR): whenever a correction/amendment is folded in (a QCSD CONDITIONAL condition, a challenge-panel confirmed finding, or a user checkpoint steer), record it in a `## Amendments` section as a fixed-shape row: `AM-N (source): <change>. Confirmation: <property> → test `test_name` (fails if reverted).` — naming the test that would FAIL if the amendment were reverted/broken. The row is MACHINE-READ by the K2 C6 gate: the marker (or a superseded-by-AM-N note) must sit inside the OWN block of that amendment — anywhere between its AM-N line and the line where the NEXT AM-N begins. Multi-line amendments are fine; what is NOT fine is placing a marker after the following amendment has already started, because it then belongs to that one. A bare range such as AM-1..AM-4 never opens a row. For a SAFEGUARD amendment (a warning/guard/fallback), the named test must prove the safeguard actually TRIGGERS on a real input — not merely that its code path exists (a structurally-dead safeguard passes an existence test and never fires in production).'
+const AMENDMENT_RULE = 'AMENDMENT CONFIRMATION DISCIPLINE (every amendment is a mini-ADR): whenever a correction/amendment is folded in (a QCSD CONDITIONAL condition, a challenge-panel confirmed finding, or a user checkpoint steer), record it in a `## Amendments` section as a fixed-shape row: `AM-N (source): <change>. Confirmation: <property> → test `test_name` (fails if reverted).` — naming the test that would FAIL if the amendment were reverted/broken. The row is MACHINE-READ by the K2 C6 gate: the marker (or a superseded-by-AM-N note) must sit inside the OWN block of that amendment — anywhere between its AM-N line and the line where the NEXT AM-N begins. Multi-line amendments are fine; what is NOT fine is placing a marker after the following amendment has already started, because it then belongs to that one. A bare range such as AM-1..AM-4 never opens a row. The row is read by TWO machines with the SAME grammar and different depths: the K2 C6 gate asks whether the row is well-formed, and dz amendment-check asks whether the named test RESOLVES. So the marker must carry ALL THREE parts: an arrow, the test id in backticks, and the file — AM-N (source): <change>. Confirmation: <property> -> test <backticked name> in <backticked path> (fails if reverted). A marker without the file passes the plan gate and then FAILS Step 8, which is the exact defect this shape removes. The alternative form is a retraction: superseded by AM-N, which both machines accept as a complete answer. For a SAFEGUARD amendment (a warning/guard/fallback), the named test must prove the safeguard actually TRIGGERS on a real input — not merely that its code path exists (a structurally-dead safeguard passes an existence test and never fires in production).'
 const AMENDMENT_GATE = 'AMENDMENT GATE (P2): do NOT judge this yourself — RUN the check and report what it says. Via Bash run EXACTLY `' + DZ + ' amendment-check --slug ' + SLUG + ' --json` (add `--feature-dir ' + FDIR + '` if the slug does not resolve from your CWD). Parse the JSON and report `amendments: {outcome, counts, reasons}` in your return object. outcome `pass` or `skip` clears the gate; `fail` is a HIGH gap and every reason must be quoted verbatim into the QE report; `not-established` means the check could not be run or the grammar matched nothing — that is NEVER a pass, report it as inconclusive with the tool error. Empty stdout, a crash, or a missing `dz` is `not-established`, not a clean gate. This check proves each amendment RESOLVES to a real test; it does NOT prove the test discriminates — vacuity stays with the discrimination gate above. ' +
   'IO-ON-PURE-PATH + FIXTURE-SWAP HUNT (P5): in the test diff, hunt for replacements of broken/unbound fixtures with healthy ones — the old fixture was probably a NEGATIVE CONTROL proving a path was I/O-free; each such swap requires a compensating negative resource-down test. If the code diff adds I/O (DB/network/file) to a previously-pure path — especially startup/lifespan/health — require a negative resource-down test (broken/unbound resource → the path degrades per its declared contract: fail-open for advisory, explicit fail-fast for load-bearing). Missing → HIGH gap.'
 
@@ -2075,9 +2193,35 @@ await agent('Run EXACTLY this one shell command via your Bash tool and report it
 // R2 polymorphic-feature-adr (ADR-001): probe the project skill manifest ONCE at Step 0. Returns only
 // {hasManifest, report} (small, reliable). NO manifest ⇒ PS_GUIDANCE returns '' for every stage, so the
 // stage prompts are byte-identical to today (FR-7 load-bearing). Fail-open: a probe error ⇒ generic run.
+// Field report doc-25b: BOTH the probe below and PS_GUIDANCE hardcoded `cd REPO`, so on a run whose
+// REPO is an external checkout the manifest installed in the WORKSPACE was unreachable — the run
+// recorded an honest `polymorphism:null` and every project lens silently went missing. Symmetric with
+// the doc-21 fix for the K2 gate: probe the target repo FIRST (a repo's own conventions are
+// authoritative for it) and fall back to the workspace ONLY when the target has no manifest and WS is
+// a genuinely different root. The choice is made in the SHELL by `grep -q`, never by the agent's
+// judgment. ONE builder feeds both call sites, so they cannot drift apart again.
+// Checkpoint note: POLY.hasManifest and fnv1a64(POLY.report) are checkpoint-hash inputs, so a run that
+// NOW finds a manifest it used to miss legitimately re-spends design/code/qe on resume — that is the
+// stale-input promise working, not a regression.
+// MIRROR of harness-core `projectSkillsOneRoot` / `projectSkillsProbeCommand` (the workflow sandbox
+// has no imports). Behaviour is pinned against the export by a drift test that extracts BOTH copies.
+function psSq(s) { return "'" + String(s).replace(/'/g, "'\\''") + "'" }
+function projectSkillsOneRoot(dzBin, root) { return 'cd ' + psSq(root) + ' && ' + dzBin + ' project-skills --project ' + psSq(root) + ' --stages-json' }
+function projectSkillsProbeCommand(dzBin, repo, workspace) {
+  const primary = projectSkillsOneRoot(dzBin, repo)
+  if (workspace === null || workspace === undefined || workspace === repo) return primary
+  return 'o=$(' + primary + ' 2>/dev/null); echo "$o" | grep -q \'"hasManifest":true\' || o=$(' + projectSkillsOneRoot(dzBin, workspace) + ' 2>/dev/null); echo "$o"'
+}
+// WS is populated ONLY by args.workspace or a relative args.repo, so the reporter's own invocation
+// (absolute args.repo, no args.workspace) leaves it null and the fallback would never arm — the exact
+// run doc-28 describes. BRAIN is the canonical pattern store, defaulting to REPO but pinned by
+// args.brain to the workspace precisely when the coder works in a target checkout, so it is the
+// second-best evidence of where the workspace is. Falling back to it costs nothing when it equals
+// REPO (the builder collapses to the single-root form).
+const PS_CMD = projectSkillsProbeCommand(DZ, REPO, WS !== null ? WS : (BRAIN !== REPO ? BRAIN : null))
 let POLY = { hasManifest: false, report: '' }
 try {
-  const psProbe = await agent('Run EXACTLY this one shell command via your Bash tool: cd ' + REPO + ' && ' + DZ + ' project-skills --stages-json. It prints one JSON line {hasManifest, design, code, qe, report}. Return ONLY {hasManifest, report} from it (drop the big design/code/qe strings).', { label: 'project-skills:step0', phase: 'Router', effort: 'low', schema: PROJECT_SKILLS })
+  const psProbe = await agent('Run EXACTLY this one shell command via your Bash tool: ' + PS_CMD + '. It prints one JSON line {hasManifest, design, code, qe, report}. Return ONLY {hasManifest, report} from it (drop the big design/code/qe strings).', { label: 'project-skills:step0', phase: 'Router', effort: 'low', schema: PROJECT_SKILLS })
   if (psProbe && typeof psProbe === 'object') POLY = psProbe
 } catch (e) { /* fail-open — generic run */ }
 if (POLY.hasManifest) log('Project skills: manifest active — folding project guidance into design/code/qe')
@@ -2085,7 +2229,7 @@ if (POLY.hasManifest) log('Project skills: manifest active — folding project g
 // agent fetches its OWN stage's guidance from `dz project-skills` (exact file content, no model
 // transcription). Empty string when no manifest ⇒ `prompt + PS_GUIDANCE(...)` is a no-op (byte-identical).
 const PS_GUIDANCE = (stage) => POLY.hasManifest
-  ? '\n\nPROJECT-SPECIFIC GUIDANCE (polymorphic feature-adr): this project ships a skill manifest. Via your Bash tool run EXACTLY `cd ' + REPO + ' && ' + DZ + ' project-skills --stages-json`, parse the JSON, and treat its `' + stage + '` field as AUTHORITATIVE project guidance for THIS step (product vision, conventions, checklists) — honor it as a hard constraint. If the command errors or hasManifest is false, ignore this paragraph.'
+  ? '\n\nPROJECT-SPECIFIC GUIDANCE (polymorphic feature-adr): this project ships a skill manifest. Via your Bash tool run EXACTLY `' + PS_CMD + '`, parse the JSON, and treat its `' + stage + '` field as AUTHORITATIVE project guidance for THIS step (product vision, conventions, checklists) — honor it as a hard constraint. If the command errors or hasManifest is false, ignore this paragraph.'
   : ''
 
 // Steps 1-5: Design (tier-gated thunks built explicitly - no inline ternary-null)
@@ -2125,7 +2269,7 @@ if (isMplus) {
   designThunks.push(() => subCheckpoint('qcsd', qcsdPromptText, qcsdOpts, ['03.5_ideation_report.md'], () => designStage(qcsdPromptText, qcsdOpts, FDIR + '/03.5_ideation_report.md', 'qcsd')))
   designPairMeta.push({ role: 'design:qcsd', prompt: qcsdPromptText, model: modelLabel(qcsdOpts), lessons: [] })
   const archExtra = isLplus ? ' Also ' + FDIR + '/04_domain_model.md (DDD).' : ''
-  const archPromptText = (isLplus ? 'Step 4 (DDD) + ' : '') + 'Step 5 (Architecture) of /feature-adr for "' + DESC + '" (' + SLUG + '). READ the code. Write ' + FDIR + '/05_architecture.md (components, data flow, integration points, the emit/merge/wiring shape).' + archExtra + ' Return wrote[] + summary.' + WRITE_DISCIPLINE
+  const archPromptText = (isLplus ? 'Step 4 (DDD) + ' : '') + 'Step 5 (Architecture) of /feature-adr for "' + DESC + '" (' + SLUG + '). READ the code. Write ' + FDIR + '/05_architecture.md (components, data flow, integration points, the emit/merge/wiring shape). It MUST carry a section headed exactly "Observability" answering how anyone would know this feature is working once it ships: what it logs, what it counts, what a failure looks like from outside, and who would notice. If the feature genuinely emits nothing at runtime — a pure refactor, a CI-only gate — say "nothing to observe" and why; that is a complete answer, not a gap. What is not acceptable is leaving the question unanswered.' + archExtra + ' Return wrote[] + summary.' + WRITE_DISCIPLINE
   designThunks.push(() => subCheckpoint('architecture', archPromptText, archOpts, ['05_architecture.md'].concat(isLplus ? ['04_domain_model.md'] : []), () => designStage(archPromptText, archOpts, FDIR + '/05_architecture.md', 'architecture')))
   designPairMeta.push({ role: 'design:architecture', prompt: archPromptText, model: modelLabel(archOpts), lessons: [] })
 }
@@ -2285,7 +2429,7 @@ if (!fanVerdict.complete) {
 // unavailable/errors — the pipeline never blocks on Codex.
 phase('Plan')
 await usageProbe('Plan')
-const planPrompt = 'Step 6 (SPARC-GOAP implementation plan) of /feature-adr for "' + DESC + '" (' + SLUG + ', tier ' + tier + '). Given the requirements + ADR + architecture in ' + FDIR + ', decompose into milestones + concrete tasks with success metrics. Write ' + FDIR + '/06_implementation_plan.md. END the plan with a trailing `EXPECTED_CODE_TARGETS:` block listing, one per line as `- <repo-relative path>`, EVERY production/test/config/doc file Step 7 is expected to create or modify. This block is machine-read by the Step-7.5 landing barrier: only paths it ESTABLISHES can ever count as landed, so an absent or unpollable block makes the barrier verdict INCONCLUSIVE. List only real targets outside features/, .dz/, .agentic-qe/ and roam/. If any corrections from Step 3.5 (a CONDITIONAL verdict) or other sources are folded into this plan, carry them in a `## Amendments` section. ' + AMENDMENT_RULE + ' Return wrote[] + summary.' + ABSOLUTE_PATH_NOTE + WRITE_DISCIPLINE
+const planPrompt = 'Step 6 (SPARC-GOAP implementation plan) of /feature-adr for "' + DESC + '" (' + SLUG + ', tier ' + tier + '). Given the requirements + ADR + architecture in ' + FDIR + ', decompose into milestones + concrete tasks with success metrics. Write ' + FDIR + '/06_implementation_plan.md. END the plan with a trailing `EXPECTED_CODE_TARGETS:` block listing, one per line as `- <repo-relative path>`, EVERY production/test/config/doc file Step 7 is expected to create or modify. This block is machine-read by the Step-7.5 landing barrier: only paths it ESTABLISHES can ever count as landed, so an absent or unpollable block makes the barrier verdict INCONCLUSIVE. List only real targets outside features/, .dz/, .agentic-qe/ and roam/. The K2 plan-completeness gate blocks Step 7 until the plan satisfies these too, so write them in as you author, not afterwards: (C1) every ADR under 03_adr/ is cited as `ADR-<n>` by the task that implements it; (C2) every test path named in an ADR Confirmation stanza appears verbatim in the plan, bound to the task that writes it; (C4) every acid token `A<n>` from 00_complexity_assessment.md is named verbatim, bound to its owning task and to the test that proves the refusal. If any corrections from Step 3.5 (a CONDITIONAL verdict) or other sources are folded into this plan, carry them in a `## Amendments` section. ' + AMENDMENT_RULE + ' Return wrote[] + summary.' + ABSOLUTE_PATH_NOTE + WRITE_DISCIPLINE
 // Resolve the plan model. args.models.plan wins; else the planner:'codex' knob (via routingRequested +
 // DEFAULT_MODELS/coder-fold) or the DEFAULT_MODELS.plan ('sonnet') under routing; else {} (BC).
 const planModel = resolveStageModel('plan')
@@ -2613,6 +2757,16 @@ if (codeStage && codeStage.modelUsed) modelsUsed.code = codeStage.modelUsed + (r
 // landedNote comes FROM the checkpointed composite (the barrier ran inside the code stage — QE #3):
 // on resume the ORIGINAL barrier signal is restored verbatim with a resumed marker prepended.
 let landedNote = codeStage ? String(codeStage.landedNote || '') : ''
+// These two are re-read from codeStage for the SAME reason `code`, `codexCodeText` and `landedNote`
+// above are: the Step-7 body is an arrow function, so its `let`s die at its closing brace. Both were
+// referenced BARE at top level — `expectedTargets` by the Step-8 writer-quiescence probe and
+// `landingStatus` by the promise-tag block — which is a runtime ReferenceError, not a stale value.
+// The wrapper landed 2026-08-19 (wave1-instrument-repair) and the quiescence probe 2026-08-24
+// (qe-writer-quiescence) referenced the name across it. Found 2026-08-25 by the scope-aware half of
+// workflow-free-identifiers.test.ts on its first run; the flat half could not see it, because both
+// names ARE declared — three hundred lines away, inside a scope that had already closed.
+const expectedTargets = codeStage && Array.isArray(codeStage.expectedTargets) ? codeStage.expectedTargets : []
+const landingStatus = codeStage ? codeStage.landingStatus : null
 if (resumedStages.indexOf('code') !== -1 && landedNote !== '') {
   landedNote = '\n\n[RESUMED from checkpoint — the landing barrier below ran in the ORIGINAL run; the change-manifest artifact was re-verified present by the resume probe]' + landedNote
 }