@dzhechkov/skills-feature-adr 1.5.10 → 1.5.11

package/.dz-manifest.json

@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "b1dbcb7b1f0f3d95bdda9f9568f65e1f78b306b2cb64e42979b1981aeadc6047"
+        "sha256": "889d62c5dfafb53c0664867f0882e5712e47eb8aa7a44c6db46d082e693ed58d"
       },
       {
         "path": "bin/cli.js",
@@ -25,7 +25,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "e376fe73743953ad7f0b7525e22f815ea949450fe7ea784f89d1e61bcc62ce6f"
+        "sha256": "d13930ae60a1d849d08b798dbb3b3ed4fb5d0b50c4c3910fc76a455dd9e6ce31"
       },
       {
         "path": "src/cli.js",
@@ -249,7 +249,11 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs",
-        "sha256": "cd2d4e05d1b61be5485c9836abdebdb00b5f4085a14f3c71126cc45d4e08fe3b"
+        "sha256": "cbe70a524f6ce7987b5e3961ee412b92c24c00d84066d438c759659d656efaa2"
+      },
+      {
+        "path": "templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs",
+        "sha256": "82c3c48c25f400f3a64d1caba3d47357f3db87460f0746f88706f901eb6ff689"
       },
       {
         "path": "templates/.claude/skills/frontend-design/LICENSE.txt",
@@ -313,7 +317,7 @@
       },
       {
         "path": "templates/.claude/workflows/feature-adr.js",
-        "sha256": "ef6a119466e504307116b12af3369029c13738ad6c40cc7a345d7d81834eca72"
+        "sha256": "22416f105c1b988c07f6cb9002a507b54b07842b5b4bb109b7e300ff52272603"
       },
       {
         "path": "templates/lib/memory-protocol.md",
@@ -325,5 +329,5 @@
       }
     ]
   },
-  "signature": "2ltA45AgleqbKopq4ritI5XTO7YtiM/vDWxo6fNIFBYrlz+sz9ZAFSxyNOEN3KYs8uwlgmef1I1sb1wvMIgxAw=="
+  "signature": "WT7wArJY3aKuIMMVgbBzFO+Rqw7qfcaVh8UQ9MENSltqdTJTFAr/0TBOS5A89UAfczkluCrkTtyUvPOTQvaNCw=="
 }

package/README.md

@@ -698,7 +698,7 @@ sufficiency + honesty, overengineering, silent decisions, runtime consistency, s
   `dz challenge --plan <plan.md>` or the `challenge-panel` skill; scaffold the degradations registry via
   `dz feature-adr-setup --from-spec <spec with {"degradations":true}> --apply`.
 
-### ADR quality gate (Step 3 generates → Step 8 enforces)
+### ADR quality review + Confirmation file gate (Step 3 generates → Step 8 checks)
 
 Step 3 and Step 8 share an ADR best-practices contract distilled from the
 [architecture-decision-record monograph](https://github.com/architecture-decision-record/architecture-decision-record):
@@ -709,12 +709,17 @@ Step 3 and Step 8 share an ADR best-practices contract distilled from the
   links + after-action review, a **`## Confirmation`** stanza (method, monitoring, success metric, owner)
   naming the load-bearing property, and a **`## Links`** traceability block. Template weight is tier-mapped:
   S/M → Nygard/ITD-lightweight, L/XL → MADR + Confirmation.
-- **Step 8** runs a **13-point ADR fitness checklist** (`qe-code-reviewer`) against every generated ADR and
-  **fails the gate** on any miss — decision-shaped title, controlled-vocabulary Status + reversibility,
+- **Step 8** runs a **13-point advisory ADR fitness checklist** (`qe-code-reviewer`) against every generated ADR —
+  decision-shaped title, controlled-vocabulary Status + reversibility,
   neutral Context-before-Decision, symmetric options, driver-mapped rationale, concrete/testable decision,
   negative consequences, traceability links, no placeholder, and **rejects explainer-masquerading-as-ADR**.
-  The **Confirmation→test link is load-bearing**: if the named safety property has no automated test the ADR
-  grades no better than C.
+  Those judgment-based items remain findings; they do not independently force the workflow verdict.
+- The **one mandatory gate** runs after Step 7.5 and before the QE verdict: every test-file path named
+  under an ADR heading beginning with `## Confirmation` must exist as a readable regular file. Missing
+  files or unreadable/unparseable paths force a non-passing Step-8 grade while the independent QE review
+  still runs. A feature with no ADR prints `пропущено: ADR нет, проверять нечего` and is not failed.
+  `dz discrimination-check` and `dz mutation-gate` remain advisory: existence does not prove that a test
+  actually discriminates the load-bearing property.
 
 The pipeline **dog-foods** this: a harness test runs the gate against feature-adr's own generated ADR, so a
 Step-3↔Step-8 drift fails CI rather than shipping.
@@ -1211,3 +1216,11 @@ Also in this release, both halves of the K2 plan-completeness gate that field us
 `dispatchOutcomes` отчёта. Причина отказа остаётся у outcome отказавшей ступени, а intent следующего
 fallback получает нейтральную причину `fallback-rung`. Регион `stage-line` принадлежит генератору
 `gen-loop-blobs` и не правится руками.
+
+### Shared Markdown masking in feature-adr gates
+
+The standalone plan-completeness gate ships with `markdown-masker.mjs`, copied byte-for-byte from
+harness-core's `src/markdown-masker.ts`. It runs without a core build. Amendment checks, swarm briefs
+and K2 share the parser while retaining their existing unclosed-block and indentation policies.
+The four-space indented-code gap remains open for amendment checks and K2; swarm briefs retain their
+existing masking of indented code. Versions are unchanged in this staged change.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.5.10",
+  "version": "1.5.11",
   "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": "b1dbcb7b1f0f3d95bdda9f9568f65e1f78b306b2cb64e42979b1981aeadc6047"
+          "content": "889d62c5dfafb53c0664867f0882e5712e47eb8aa7a44c6db46d082e693ed58d"
         }
       ]
     },
@@ -69,7 +69,7 @@
         },
         {
           "name": "dz:canonical-json-sha256-v2",
-          "value": "e376fe73743953ad7f0b7525e22f815ea949450fe7ea784f89d1e61bcc62ce6f"
+          "value": "d13930ae60a1d849d08b798dbb3b3ed4fb5d0b50c4c3910fc76a455dd9e6ce31"
         }
       ]
     },
@@ -629,7 +629,17 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "cd2d4e05d1b61be5485c9836abdebdb00b5f4085a14f3c71126cc45d4e08fe3b"
+          "content": "cbe70a524f6ce7987b5e3961ee412b92c24c00d84066d438c759659d656efaa2"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "82c3c48c25f400f3a64d1caba3d47357f3db87460f0746f88706f901eb6ff689"
         }
       ]
     },
@@ -789,7 +799,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "ef6a119466e504307116b12af3369029c13738ad6c40cc7a345d7d81834eca72"
+          "content": "22416f105c1b988c07f6cb9002a507b54b07842b5b4bb109b7e300ff52272603"
         }
       ]
     },

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

@@ -51,6 +51,7 @@
 // the feature's own `00_complexity_assessment.md` acid-case table (rows shaped `| A<N> | … |`), or
 // 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 { isAbsolute, join, resolve } from 'node:path';
 
@@ -319,21 +320,7 @@ else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\
   // `## 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);
-    }
-  }
+  const planLines = maskMarkdown(plan, { unclosed: 'mask' }).split('\n');
   let sectionStart = -1, sectionEnd = -1, cursor = 0;
   for (const pl of planLines) {
     // The SAME heading shape amendment-trace.ts accepts: up to three leading spaces, two to four

package/templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs

@@ -0,0 +1,109 @@
+/**
+ * Canonical Markdown block masker; copied byte-for-byte as markdown-masker.mjs beside K2.
+ * Keep this file valid JavaScript (inferred TS types, no build needed by the copy).
+ *
+ * CommonMark fences and type-2 HTML comments; same UTF-16 length and newline positions.
+ * Inline code cannot open an HTML block. HTML delimiters within a block are consumed left to
+ * right, including close/reopen on one line. This is not a complete CommonMark parser.
+ *
+ * Reader policies are deliberate: amendment-trace restores unclosed blocks; brief/K2 hide them.
+ * Four-space code is still unsupported by default. ONLY brief keeps its pre-existing policy.
+ * Containers, tab indentation and HTML block types other than comments remain unsupported.
+ * Callbacks expose line facts; callers own semantic diagnostics and list-barrier representation.
+ */
+export function maskMarkdown(md = '', {
+  unclosed = 'restore',
+  indentedCode = false,
+  inlineComments = false,
+  onMasked = (_line = 0) => {},
+  onDisputed = (_line = 0) => {},
+} = {}) {
+  const lines = md.split('\n');
+  const out = lines.slice();
+  const masked = lines.map(() => false);
+  let state = 'text';
+  let marker = '';
+  let markerLength = 0;
+  let openedAt = -1;
+  let nestedOpener = false;
+  let disputed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? '';
+    const blank = () => { out[i] = ' '.repeat(line.length); masked[i] = true; };
+    if (state === 'fence') {
+      blank();
+      const close = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(line);
+      if (close) {
+        const run = close[1] ?? '';
+        if (run[0] === marker && run.length >= markerLength) {
+          state = 'text';
+          openedAt = -1;
+        }
+      }
+      continue;
+    }
+    if (state === 'text') {
+      const fence = /^ {0,3}(`{3,}|~{3,})([^\n]*)$/.exec(line);
+      if (fence && !(fence[1]?.[0] === '`' && fence[2]?.includes('`'))) {
+        const run = fence[1] ?? '';
+        state = 'fence';
+        marker = run[0] ?? '';
+        markerLength = run.length;
+        openedAt = i;
+        blank();
+        continue;
+      }
+      if (indentedCode && /^ {4,}/.test(line)) {
+        blank();
+        continue;
+      }
+    }
+    // Outside HTML only a block opener counts: code-spanned delimiters in prose are inert.
+    // Inside HTML, backticks are literal and do not protect a delimiter.
+    const htmlStart = /^ {0,3}<!--/.test(line);
+    const wasDisputed = disputed;
+    // Ambiguity is diagnostic state, never permission to scan otherwise-visible prose.
+    // Brief deliberately keeps that diagnostic across blocks until the author's outer close;
+    // block-only readers must not hide an unrelated arrow or opener because it is pending.
+    if (state === 'html' || htmlStart || inlineComments) {
+      let maskLine = state === 'html' || htmlStart;
+      const tokens = [...line.matchAll(/`+|<!--|-->/g)];
+      for (let t = 0; t < tokens.length; t++) {
+        const token = tokens[t];
+        if (!token) continue;
+        if (token[0][0] === '`') {
+          // Code spans require an EXACT matching run; a shorter embedded run is literal.
+          // HTML blocks treat backticks literally. Inline-comment support is brief's existing
+          // policy; other readers only enter this scan at a block opener or while disputed.
+          if (state !== 'html') {
+            const end = tokens.findIndex((next, j) => j > t && next[0] === token[0]);
+            if (end >= 0) t = end;
+          }
+          continue;
+        }
+        if (token[0] === '<!--') {
+          if (state === 'html') nestedOpener = true;
+          else { state = 'html'; openedAt = i; }
+          maskLine = true;
+        } else if (state === 'html') {
+          state = 'text';
+          openedAt = -1;
+          if (nestedOpener) { disputed = true; nestedOpener = false; }
+        } else if (disputed) {
+          disputed = false;
+          maskLine = true;
+        }
+      }
+      if (maskLine) blank();
+    }
+    if (wasDisputed || disputed) onDisputed(i);
+  }
+  if (openedAt >= 0 && unclosed === 'restore') {
+    for (let i = openedAt; i < lines.length; i++) {
+      out[i] = lines[i] ?? '';
+      masked[i] = false;
+    }
+  }
+  for (let i = 0; i < masked.length; i++) if (masked[i]) onMasked(i);
+  return out.join('\n');
+}

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

@@ -16,6 +16,12 @@ export const meta = {
   ],
 }
 
+// Finalize on every normal return and on a caught runtime error; a killed host cannot finalize.
+let finishRunRegistry = null
+let registryOutcome = 'errored'
+try {
+const RUNTIME_SPENT = (typeof budget === 'object' && budget && typeof budget.spent === 'function') ? function () { return budget.spent() } : null
+let spentAtPrevRow = RUNTIME_SPENT ? RUNTIME_SPENT() : null
 const A = typeof args === 'string' ? JSON.parse(args) : (args || {})
 const SLUG = A.slug || 'feature'
 const DESC = A.description || ''
@@ -135,15 +141,35 @@ function normalizeDzBin(raw, ws) {
   const base = (typeof ws === 'string' && ws.length > 0) ? ws.replace(/\/+$/, '') : ''
   return base === '' ? r : base + '/' + r
 }
-const DZ_RAW = A.dzBin || 'dz'
-// The probe above runs only when args.repo needed resolving; a relative dzBin needs WS too, so run
-// it here in exactly that case — a bare `dz` (the common case) pays zero extra agent calls.
+// In the hub, PATH may name an older published CLI. Resolve the workspace first so an omitted
+// args.dzBin can prefer the build that belongs to this checkout.
+if (A.workspace !== undefined && A.workspace !== null) WS = assertAbsoluteNoTraversal(A.workspace, 'workspace')
+if ((A.dzBin === undefined || A.dzBin === null || A.dzBin === '') && WS === null) {
+  WS = await probeSessionCwd('resolve-workspace-dz')
+}
+const WORKSPACE_DZ = WS === null ? null : WS.replace(/\/+$/, '') + '/packages/@dzhechkov/harness-cli/dist/bin.js'
+let DZ_RAW = A.dzBin
+let DZ_VERSION = 'not probed (dzBin given)'
+if (DZ_RAW === undefined || DZ_RAW === null || DZ_RAW === '') {
+  const dzProbeCmd = WORKSPACE_DZ === null
+    ? "printf 'DZ_PATH_FALLBACK '; dz --version"
+    : 'if [ -f ' + shq(WORKSPACE_DZ) + " ]; then printf 'DZ_WORKSPACE_BUILD '; " + shq(WORKSPACE_DZ) + " --version; else printf 'DZ_PATH_FALLBACK '; dz --version; fi"
+  const localDzOut = await dispatchAgent(newRung(), 'Run EXACTLY this via Bash and reply with ONLY its stdout: ' + dzProbeCmd, { label: 'resolve-workspace-dz:select-version', phase: 'Route', model: 'haiku', effort: 'low' })
+  const localDzText = String(localDzOut || '').trim()
+  const workspaceDzExists = localDzText.indexOf('DZ_WORKSPACE_BUILD ') === 0
+  DZ_RAW = workspaceDzExists ? WORKSPACE_DZ : 'dz'
+  const dzVersionText = localDzText.replace(/^DZ_(?:WORKSPACE_BUILD|PATH_FALLBACK)\s*/, '')
+  const dzVersionLines = dzVersionText.split(/\r?\n/).map(function (line) { return line.trim() }).filter(Boolean)
+  DZ_VERSION = dzVersionLines.length > 0 ? dzVersionLines[dzVersionLines.length - 1].slice(0, 80) : 'unknown'
+}
+// A relative dzBin still needs WS so it resolves identically after every downstream cd. The combined
+// selection/version probe above runs only when dzBin is absent; a supplied absolute dzBin costs no call.
 if (DZ_RAW.indexOf('/') >= 0 && DZ_RAW.charAt(0) !== '/' && WS === null) {
   WS = await probeSessionCwd('resolve-ws')
   if (!WS) throw new Error('feature-adr: args.dzBin ' + JSON.stringify(DZ_RAW) + ' is relative and the workspace root could not be resolved after 2 attempts; refusing to splice a path that would resolve differently in every cd\'d command. Pass an absolute args.dzBin.')
 }
 const DZ = normalizeDzBin(DZ_RAW, WS)
-log('dz binary: ' + DZ)
+log('dz binary: ' + DZ + ' (' + DZ_VERSION + ')')
 // args.gateScript — an explicit ABSOLUTE path to the K2 gate script (ADR-002 candidate 1). Validated
 // HERE, at invocation time, so a bad value fails at the same layer the pure half fails rather than
 // two layers later inside an emitted shell command.
@@ -152,7 +178,6 @@ const GATE_SCRIPT_ARG = (A.gateScript === undefined || A.gateScript === null) ?
 // shell fallback WS=$(pwd -P) runs in the GATE AGENT own cwd. On a run against an external repo it
 // equalled REPO, so the workspace candidate pointed at the target repo and the skill installed in
 // the workspace was never found - NOT-ESTABLISHED, exit 3, Step 7 never ran. args.workspace pins it.
-if (A.workspace !== undefined && A.workspace !== null) WS = assertAbsoluteNoTraversal(A.workspace, 'workspace')
 // CANONICAL BRAIN store: the self-learning loop (Step-0 recall → Step-8 teach) MUST read+write ONE
 // shared pattern store so lessons never fragment into a target repo's .dz when the Step-7 coder cd's
 // away. BRAIN defaults to the workspace root (REPO) — so an OMITTED args.brain is behaviorally inert
@@ -170,6 +195,14 @@ const DZ_RECALL = (terms) => 'cd ' + BRAIN + ' && ' + DZ + ' recall "' + terms +
 const DZ_TEACH = (lesson, reward, domain) =>
   'cd ' + BRAIN + ' && ' + DZ + ' teach "' + lesson + '" --reward ' + reward + ' --domain ' + domain + ' --project ' + BRAIN
 
+function parseRoundCommandJson(raw) {
+  const lines = String(raw === null || raw === undefined ? '' : raw).split(/\r?\n/).map(function (line) { return line.trim() }).filter(Boolean)
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try { return JSON.parse(lines[i]) } catch { /* a chatty shell courier may add non-JSON lines */ }
+  }
+  return null
+}
+
 // ── Durable checkpoints + resume (backlog 49e4a95b) — inline mirror of ──
 // ── harness-core/src/feature-adr-checkpoints.ts (the workflow is self-contained, no imports) ──
 // After each expensive stage a cheap effort-low agent appends {stage, inputHash, result} to
@@ -435,7 +468,11 @@ async function withCheckpoint(stage, phaseName, inputHash, runFn, ckptOpts) {
     else if (stage === 'fleet') faNext = 'done'
   }
   const faTier = (stage === 'router' && result && typeof result.tier === 'string') ? result.tier : FA_TIER.v
-  const faRecordCmd = faNext === null ? null : (DZ + ' statusline --fa-record --slug ' + shq(SLUG) + ' --step ' + shq(faNext) + (faTier ? ' --tier ' + shq(faTier) : '') + ' --mode ' + shq(MODE) + ' --project ' + shq(REPO))
+  const faRunIdFile = FDIR + '/.fa-state/run-id'
+  const faMintRunId = stage === 'router'
+    ? ('mkdir -p ' + shq(FDIR + '/.fa-state') + ' 2>/dev/null || true; date +%s%3N > ' + shq(faRunIdFile) + ' 2>/dev/null || true; ')
+    : ''
+  const faRecordCmd = faNext === null ? null : (faMintRunId + DZ + ' statusline --fa-record --slug ' + shq(SLUG) + ' --step ' + shq(faNext) + (faTier ? ' --tier ' + shq(faTier) : '') + ' --mode ' + shq(MODE) + ' --project ' + shq(REPO) + ' --run-id "$(cat ' + shq(faRunIdFile) + ' 2>/dev/null || true)"')
   var faReported = false
   if (CHECKPOINTS_ON && result !== null && result !== undefined && !partial && persistable) {
     let line = null
@@ -970,7 +1007,14 @@ async function appendRunCostRow(stage, phaseName, outcome) {
   // Like capturePairs, a ledger failure is a logged SECONDARY event that can NEVER fail the run;
   // the whole body therefore rides one best-effort try/catch and never rethrows.
   try {
-    // HONESTY: tokens and minutes and agents come from the Workflow COMPLETION NOTIFICATION, which the running script CANNOT see. So the automated row MUST write null for them — never an estimate, never a guess, never a fabricated number. The operator still enriches tokens/minutes afterwards.
+    const spentNow = RUNTIME_SPENT ? RUNTIME_SPENT() : null
+    const tokensOut = Number.isFinite(spentNow) && Number.isFinite(spentAtPrevRow)
+      ? spentNow - spentAtPrevRow
+      : null
+    if (Number.isFinite(spentNow)) spentAtPrevRow = spentNow
+    // HONESTY: budget.spent() exposes only cumulative OUTPUT tokens, so tokensOut is that measured
+    // partial cost. Complete token cost, minutes and agents come from the Workflow COMPLETION NOTIFICATION,
+    // which the running script CANNOT see. Keep their fields null: never an estimate, never a guess, never a fabricated number.
     const line = JSON.stringify({
       slug: (typeof SLUG === 'string' && SLUG !== '') ? SLUG : null,
       stage: (typeof stage === 'string' && stage !== '') ? stage : null,
@@ -978,6 +1022,9 @@ async function appendRunCostRow(stage, phaseName, outcome) {
       tokens: null,
       minutes: null,
       agents: null,
+      tokensOut: tokensOut,
+      tokensOutSource: tokensOut === null ? 'unavailable' : 'budget.spent',
+      costNote: 'total tokens visible only in the completion notification; minutes not measurable inside the sandbox',
       coder: (typeof coderUsed === 'string' && coderUsed !== '') ? coderUsed : null,
       grade: (qe && typeof qe.grade === 'string' && qe.grade !== '') ? qe.grade : null,
       outcome: (typeof outcome === 'string' && outcome !== '') ? outcome : null,
@@ -1098,9 +1145,9 @@ function stageReason(stage, decision) {
   if (decision.reason === 'explicit-models' && AUTOCOST[stage]) return 'auto-cost'
   return decision.reason
 }
-const KNOWN_CODEX = { 'auto': 1, 'gpt-5.5': 1, 'gpt-5.6': 1, 'gpt-5.6-luna': 1, 'gpt-5.6-terra': 1, 'gpt-5.6-sol': 1 }
+const KNOWN_CODEX = { 'auto': 1, 'gpt-5.5': 1, 'gpt-5.6': 1, 'gpt-5.6-luna': 1, 'gpt-5.6-terra': 1, 'gpt-5.6-sol': 1, 'gpt-6-astra': 1 }
 // The allowlist is not an availability check — probe every id before every run; ids drift in both directions.
-const CODEX_TIERS = { flagship: 'gpt-5.6-sol', workhorse: 'gpt-5.6-terra', 'high-volume': 'gpt-5.6-luna' }
+const CODEX_TIERS = { premium: 'gpt-6-astra', flagship: 'gpt-5.6-sol', workhorse: 'gpt-5.6-terra', 'high-volume': 'gpt-5.6-luna' }
 const CLAUDE_NAMES = { fable: 1, opus: 1, sonnet: 1, haiku: 1 }
 const VALID_REASONING = { none: 1, minimal: 1, low: 1, medium: 1, high: 1, xhigh: 1, max: 1 }
 const DEFAULT_MODELS = { router: 'fable', requirements: 'sonnet', research: 'sonnet', adr: 'opus', ideation: 'sonnet', ddd: 'opus', architecture: 'opus', plan: 'sonnet', code: null, qe: null, fleet: 'sonnet' }
@@ -1238,9 +1285,26 @@ function budgetTable(primary, mode) {
     codexHalf = { ...ROUTING_TABLES.claude.codex[mode.codex], qe: A.codexAvailable === false ? 'opus' : qeSpec }
   } else {
     const normal = mode.codex === 'normal'
-    const id = codexIdForTier(normal ? 'flagship' : 'workhorse')
-    const design = 'codex:' + id + ':' + (normal ? 'high' : 'medium')
-    codexHalf = { requirements: design, research: design, adr: design, ideation: design, ddd: design, architecture: design, plan: 'codex:' + id + ':' + (normal ? 'high' : 'low'), code: 'codex:' + id + ':medium' }
+    // Тир берётся из FA_TIER.v, а НЕ из A.tier: A.tier несёт только ЯВНО переданный аргумент,
+    // а обычный прогон узнаёт свой размер от нулевого шага (роутера), который кладёт его сюда
+    // на строке FA_TIER.v = tier. Читая A.tier, ячейка плана никогда не поднималась до
+    // премиального яруса в обычном прогоне — матрица работала наполовину (ИЗМЕРЕНО 2026-09-09).
+    const largePlan = FA_TIER.v === 'L' || FA_TIER.v === 'XL'
+    const work = 'codex:' + codexIdForTier(normal ? 'flagship' : 'workhorse') + ':high'
+    const evidence = 'codex:' + codexIdForTier(normal ? 'workhorse' : 'high-volume') + ':medium'
+    codexHalf = {
+      router: evidence,
+      requirements: 'codex:' + codexIdForTier(normal ? 'flagship' : 'workhorse') + ':medium',
+      research: evidence,
+      adr: 'codex:' + codexIdForTier(normal ? 'premium' : 'flagship') + ':high',
+      ideation: work,
+      ddd: work,
+      architecture: 'codex:' + codexIdForTier(normal ? 'premium' : 'flagship') + ':high',
+      plan: largePlan ? 'codex:' + codexIdForTier(normal ? 'premium' : 'flagship') + ':high' : work,
+      code: work,
+      fleet: work,
+    }
+
   }
   return { ...claudeHalf, ...codexHalf }
 }
@@ -2237,17 +2301,18 @@ const CODE_LANDING_CEILING_ENV = 'DZ_FEATURE_ADR_CODE_LANDING_CEILING_MS'
 const CODEX_COMPANION_SCRIPT = '/root/.claude/plugins/cache/openai-codex/codex/1.0.5/scripts/codex-companion.mjs'
 const CODEX_COMPANION_STATE_ROOT = '/root/.claude/plugins/data/codex-openai-codex/state'
 
-function decideCodeLandingLiveness(input) {
+function decideCodeLandingLiveness(input, pidProbe) {
   const status = typeof input.companionStatus === 'string' ? input.companionStatus.trim().toLowerCase() : ''
   const elapsedMs = Number.isFinite(input.elapsedMs) ? Math.max(0, input.elapsedMs) : 0
   const ceilingMs = Number.isFinite(input.ceilingMs) && input.ceilingMs > 0 ? input.ceilingMs : DEFAULT_CODE_LANDING_CEILING_MS
+  const recordedPidAlive = input.recordedPidAlive === undefined ? (input.recordedPid === undefined ? null : pidProbe(input.recordedPid)) : input.recordedPidAlive
   const live = status === 'running' || status === 'queued'
   const terminal = status === 'completed' || status === 'failed' || status === 'cancelled'
 
-  if (live && input.recordedPidAlive === false) {
+  if (live && recordedPidAlive === false) {
     return { verdict: 'dead-worker', reason: 'recorded-pid-absent' }
   }
-  if (live && input.recordedPidAlive === true) {
+  if (live && recordedPidAlive === true) {
     if (elapsedMs >= ceilingMs) return { verdict: 'inconclusive', reason: 'ceiling-exceeded' }
     return { verdict: 'coder-running', reason: 'recorded-pid-alive' }
   }
@@ -2753,7 +2818,8 @@ function codeLandingLivenessProbeCmd(repo, plan, baselineAbsPath, jobId, waitSec
     // cannot answer) — a different event from an expired window, and the only one with a cure.
     // Unreadable stays 'unknown', which the verdict treats as no evidence, never as a clean exit.
     'tf=unknown; if [ -f "$state" ]; then if grep -q \'"touchedFiles": *\\[ *\\]\' "$state"; then tf=0; elif grep -q \'"touchedFiles"\' "$state"; then tf=1; fi; fi; ' +
-    'if [ -n "$pid" ]; then if ps -p "$pid" -o pid= >/dev/null 2>&1; then pid_alive=true; else pid_alive=false; fi; fi; fi; fi; ' +
+    // Replaces ps -p "$pid": the CLI uses the shared probePid; inaccessible stays unknown.
+    'if [ -n "$pid" ]; then pid_alive=$(' + DZ + ' runs --probe-pid "$pid"); case "$pid_alive" in true|false|unknown) :;; *) pid_alive=unknown;; esac; fi; fi; fi; ' +
     'echo "CODEX-LIVENESS-SIGNAL companion=$companion pid-alive=$pid_alive targets-changed=$target elapsed-ms=$elapsed_ms ceiling-ms=$ceiling_ms start-ms=$start_ms touched-files=$tf"; ' +
     'printf "%s\n" "$landing" | head -40; rm -rf "$sc"'
   )
@@ -3056,7 +3122,34 @@ const ARTIFACT = { type: 'object', additionalProperties: false, required: ['wrot
 // (hasManifest + the who-injected report). The BIG per-stage guidance content is fetched by each stage
 // agent directly from `dz project-skills` (never threaded through a model → fidelity preserved).
 const PROJECT_SKILLS = { type: 'object', additionalProperties: false, required: ['hasManifest', 'report'], properties: { hasManifest: { type: 'boolean' }, report: { type: 'string' } } }
-const QE = { type: 'object', additionalProperties: false, required: ['grade', 'gaps', 'codeTestsAdequate', 'docTestsPresent'], properties: { grade: { type: 'string' }, codeTestsAdequate: { type: 'boolean' }, docTestsPresent: { type: 'boolean' }, gaps: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['sev', 'what'], properties: { sev: { type: 'string' }, what: { type: 'string' } } } }, claimCheck: { type: 'object', additionalProperties: false, properties: { findings: { type: 'number' }, high: { type: 'number' }, medium: { type: 'number' } } } } }
+const QE = { type: 'object', additionalProperties: false, required: ['grade', 'gaps', 'codeTestsAdequate', 'docTestsPresent'], properties: { grade: { type: 'string' }, codeTestsAdequate: { type: 'boolean' }, docTestsPresent: { type: 'boolean' }, gaps: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['sev', 'what'], properties: { sev: { type: 'string' }, what: { type: 'string' } } } }, claimCheck: { type: 'object', additionalProperties: false, properties: { findings: { type: 'number' }, high: { type: 'number' }, medium: { type: 'number' } } }, roundLessons: { type: 'array', items: { type: 'string' } }, roundNoNewKnowledge: { type: 'string' } } }
+const CONFIRMATION_FILE_GATE = { type: 'object', additionalProperties: false, required: ['verdict', 'missing', 'checked', 'reason'], properties: { verdict: { type: 'string', enum: ['pass', 'fail', 'skipped', 'refused'] }, missing: { type: 'array', items: { type: 'string' } }, checked: { type: 'array', items: { type: 'string' } }, reason: { type: 'string' } } }
+
+function normalizeConfirmationFileGate(raw) {
+  if (!raw || typeof raw !== 'object') return { verdict: 'refused', missing: [], checked: [], reason: 'confirmation-file gate agent returned no readable result' }
+  const verdict = raw.verdict
+  if (verdict !== 'pass' && verdict !== 'fail' && verdict !== 'skipped' && verdict !== 'refused') return { verdict: 'refused', missing: [], checked: [], reason: 'confirmation-file gate returned an invalid verdict' }
+  return {
+    verdict: verdict,
+    missing: Array.isArray(raw.missing) ? raw.missing.map(function (x) { return String(x) }) : [],
+    checked: Array.isArray(raw.checked) ? raw.checked.map(function (x) { return String(x) }) : [],
+    reason: typeof raw.reason === 'string' ? raw.reason : ''
+  }
+}
+
+function enforceConfirmationFileGate(qe, gate) {
+  if (!qe || typeof qe !== 'object') return qe
+  const out = Object.assign({}, qe, { confirmationFileGate: gate })
+  if (gate.verdict !== 'fail' && gate.verdict !== 'refused') return out
+  const what = gate.verdict === 'fail'
+    ? 'confirmation file gate FAIL — missing: ' + gate.missing.join(', ')
+    : 'confirmation file gate REFUSED — ' + gate.reason
+  const gaps = Array.isArray(out.gaps) ? out.gaps.slice() : []
+  if (!gaps.some(function (g) { return g && g.what === what })) gaps.push({ sev: 'HIGH', what: what })
+  out.gaps = gaps
+  out.grade = String(out.grade || '').trim().toUpperCase() === 'D' ? 'D' : 'C'
+  return out
+}
 const ADR_TEMPLATE_GUIDE = 'ADR best-practices for Step 3: emit exactly one decision per ADR with the invariant core Title, Status, Context, Decision, Consequences. Template weight is tier-routed: S/M use Nygard/ITD-lightweight form but still include decision drivers, considered options, rationale, consequences, and Confirmation; L/XL use MADR structure plus an NHS Wales Confirmation stanza. Confirmation MUST name verification method, monitoring, success metric, and owner, and its load-bearing safety property MUST be tied to a Step-8 automated test/fitness function. Use status vocabulary proposed/accepted/rejected/deprecated/superseded plus a reversibility clause. Context must be neutral and appear before Decision. Considered Options must include rejected options with symmetric pros/cons. Rationale points must map to stated drivers and explain why losers were rejected. Consequences must include positive and negative outcomes/accepted downsides, follow-up ADR links, an after-action review schedule, and supersession discipline: supersession mints a new ADR and never edits accepted/rejected ADR content in place. Decision must be concrete/testable with exact names, versions, formats, paths, commands, or APIs. Reject explainer-masquerading-as-ADR: a domain overview with no concrete Decision is not an ADR. File names under 03_adr MUST be sequential NNN-{decision-slug}.md with lowercase kebab-case, dateless, ticketless slugs (the auto-001 ADR tracks the feature slug, so the present-tense imperative signal lives in the ADR Title; model-named additional ADRs use imperative slugs). Add a ## Links traceability block (requirements, driving use case, related ADRs) and a one-line provenance note (model-generated, edited for clarity); for a long ADR include a top-of-file table of contents.'
 const ADR_FITNESS_CHECKLIST = 'ADR fitness checklist for Step 8: read every ' + FDIR + '/03_adr/NNN-*.md ADR and fail the QE gate for any miss. Required checks: (1) filename is 03_adr/NNN-{decision-slug}.md where the slug is lowercase kebab-case, imperative, dateless, and ticketless; (2) title is decision-shaped and the ADR records one decision only; (3) Status is non-empty controlled vocabulary proposed/accepted/rejected/deprecated/superseded and includes a reversibility/revisit clause; (4) Context is neutral, problem-first, and appears before Decision; (5) Decision Drivers are stated and ranked/weighted; (6) Considered Options include the chosen and rejected options, each with symmetric pros and cons; (7) Rationale maps each point back to a driver and explains why rejected options lost; (8) Decision is concrete/testable with exact names, versions, formats, paths, commands, or APIs; (9) Consequences include positive and negative outcomes/accepted downsides, follow-up ADR links, and an after-action review schedule; (10) Confirmation names verification method, monitoring, success metric, and owner, then links the load-bearing safety property to an automated test/fitness function; (11) no placeholder text, template hints, raw generation scaffolding, or fake Markdown structure; (12) reject explainer-masquerading-as-ADR: describing a space with no concrete Decision is a blocker; (13) a Related/Links traceability block maps the ADR to its requirements, driving use case, and related ADRs. The ADR Confirmation check is load-bearing: assert the named safety property has a test that DISCRIMINATES — a real test by file/name that would go RED if the protection were deleted (the discrimination + mutation gates below are the proof; a test that would still pass with the protection deleted is documentation, not a gate); if absent, grade no better than C and record a blocker gap.'
 // §42 test-discrimination gate (feature step8-discrimination-gate, grounded in cve-bench/evaluate.mjs). Asserting
@@ -3088,8 +3181,55 @@ const AMENDMENT_RULE = 'AMENDMENT CONFIRMATION DISCIPLINE (every amendment is a
 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.'
 
+// ── BEGIN BLOB run-registry@1.0.0 sha256:a4187c278260e8f8285fc494da2a6d82923efe4465fabba20ce1d3141df7fef3 src=packages/@dzhechkov/harness-core/src/run-registry.ts ──
+function runRecordCommand(dz, root, event, runId, slug, pid, parentRunId, outcome) {
+    const quote = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
+    let cmd = dz + ' runs-record --project ' + quote(root) + ' --event ' + quote(event) + (runId ? ' --run-id ' + quote(runId) : '');
+    if (event === 'started') {
+        cmd += ' --kind feature-adr --slug ' + quote(slug);
+        cmd += ' --pid ' + quote(pid === null ? 'host' : String(pid));
+        if (parentRunId)
+            cmd += ' --parent-run-id ' + quote(parentRunId);
+    }
+    if (event === 'finished')
+        cmd += ' --outcome ' + quote(outcome);
+    return cmd + ' --json';
+}
+// ── END BLOB run-registry ──
+
+// Run registry: the courier executes the CLI because the sandbox has no filesystem.
+let registryRunId = ''
+let registryPhase = 'Router'
+async function recordRegistryEvent(event, phaseName, outcome) {
+  registryPhase = phaseName
+  if (event !== 'started' && !registryRunId) return
+  try {
+    const cmd = runRecordCommand(DZ, REPO, event, registryRunId, SLUG,
+      A.runPid === undefined ? null : A.runPid, A.parentRunId || null, outcome || '')
+    const out = await dispatchAgent(newRung(), 'Run EXACTLY this command via Bash and return ONLY its stdout: ' + cmd,
+      { label: 'runs-record:' + event + ':' + phaseName, phase: phaseName, effort: 'low' })
+    let receipt = null
+    try { receipt = typeof out === 'string' ? JSON.parse(out.trim()) : out } catch { /* unverified below */ }
+    if (!receipt || receipt.status !== 'written' || receipt.event !== event ||
+        typeof receipt.runId !== 'string' || !receipt.runId || (registryRunId && receipt.runId !== registryRunId)) {
+      registryOutcome = 'unverified'
+      log('run registry: ' + event + ' UNVERIFIED — ' + (receipt && receipt.reason ? String(receipt.reason) : String(out)))
+      return
+    }
+    if (event === 'started') registryRunId = receipt.runId
+  } catch (error) {
+    registryOutcome = 'unverified'
+    log('run registry: ' + event + ' UNVERIFIED — ' + String(error))
+  }
+}
+finishRunRegistry = async function () {
+  await recordRegistryEvent('finished', registryPhase, registryOutcome)
+}
+await recordRegistryEvent('started', 'Router')
+
 // Step 0: Router + MANDATORY self-learning recall
 phase('Router')
+await recordRegistryEvent('heartbeat', 'Router')
 
 // W1 (backlog 848853a0): REPO must be the git TOPLEVEL. Both measured incidents were a REPO
 // pointing INSIDE the repository (packages/@dzhechkov/health-advisor) — artifacts then scatter
@@ -3110,6 +3250,7 @@ else if (wrootTop !== wrootHere) {
   log('REPO ROOT MISMATCH: REPO canonicalizes to ' + wrootHere + ' but the git toplevel is ' + wrootTop + ' — refusing before any design spend (the measured incident class: artifacts scattered into a subdirectory features/)')
   const repoRootMismatchGates = {}
   const repoRootMismatchOutcome = runOutcomeOf({ phase: 'repo-root-mismatch', gates: repoRootMismatchGates })
+if (registryOutcome !== 'unverified') registryOutcome = repoRootMismatchOutcome
   return { phase: 'repo-root-mismatch', outcome: repoRootMismatchOutcome, repo: REPO, repoCanonical: wrootHere, gitToplevel: wrootTop, cure: 'invoke with args.repo=' + wrootTop + ' (or run from the repository root)' }
 }
 await loadCheckpoints('Router')
@@ -3148,6 +3289,8 @@ FA_TIER.v = tier // fa-phase-statusline: from here every ckpt-side fa-record car
 // Outer completion state starts absent so the plan-only ledger row can report null honestly.
 let coderUsed = null
 let qe = null
+let pipelineRound = null
+let roundClosed = false
 const LEARNED = router ? router.rationale : 'none recalled'
 const isMplus = tier === 'M' || tier === 'L' || tier === 'XL'
 const isLplus = tier === 'L' || tier === 'XL'
@@ -3191,6 +3334,26 @@ if (autoCostStages.length > 0) {
 // most visible moment. Uses the workspace bin (PATH-independent). Best-effort — never blocks.
 if (resumedStages.indexOf('router') === -1) await dispatchAgent(newRung(), 'Run EXACTLY this one shell command via your Bash tool and report its stdout verbatim — do nothing else, do not summarize: ' + DZ + ' statusline --fa-record --slug ' + SLUG + ' --step "Step 0 recall" --recalled auto --run fa:' + SLUG + ' --count-project ' + BRAIN + ' --stored 0 --mode ' + MODE + ' --project ' + REPO, { label: 'fa-record:step0', phase: 'Router', effort: 'low' })
 
+// A whole feature-adr run is one outer round. Cost remains in the unchanged per-stage ledger rows;
+// the round records only the outcome. State lives in REPO because the command cd's there, while
+// recall reads the canonical BRAIN and carries the same fa:<slug> attribution as DZ_RECALL.
+const roundOwnerArg = registryRunId
+  ? ' --owner-run ' + shq(registryRunId)
+  : ''
+if (!registryRunId) log('round owner: no registry run id (registry write failed) — falling back to explicit owner')
+const roundOpenCmd = 'cd ' + shq(REPO) + ' && ' + DZ + ' round open --slug ' + shq(SLUG) + ' --round auto --topic ' + shq(DESC) + ' --project ' + shq(BRAIN) + ' --run fa:' + SLUG + roundOwnerArg + ' --json'
+const roundOpenOut = await dispatchAgent(newRung(), 'Run EXACTLY this one shell command via your Bash tool and return its stdout VERBATIM, nothing else: ' + roundOpenCmd, { label: 'round:open', phase: 'Router', effort: 'low' })
+const roundOpenReceipt = parseRoundCommandJson(roundOpenOut)
+pipelineRound = Number(roundOpenReceipt && roundOpenReceipt.state ? roundOpenReceipt.state.round : (roundOpenReceipt ? roundOpenReceipt.round : NaN))
+if (!Number.isInteger(pipelineRound) || pipelineRound < 1) {
+  pipelineRound = null
+  log('round open refused: ' + (roundOpenReceipt && roundOpenReceipt.message ? roundOpenReceipt.message : String(roundOpenOut || 'no JSON receipt')))
+} else if (!roundOpenReceipt.state) {
+  // A resumed run sees the still-open state and receives the selected auto number in the refusal.
+  // Keep that number so Step 8 can close the original round, but never call the refusal an open.
+  log('round open refused: ' + String(roundOpenReceipt.message || 'round already open'))
+}
+
 // R1 product-architecture-lens (ADR-001 Decision 3): forward-looking сверка of THIS feature vs the LIVE
 // product map + vision. NON-BLOCKING/soft by design — it LOGS {signal,confidence} so a real command
 // duplication or vision-boundary tension is visible at Step 0; the hard-stop call stays the user's (a
@@ -3241,6 +3404,7 @@ const PS_GUIDANCE = (stage) => POLY.hasManifest
 
 // Steps 1-5: Design (tier-gated thunks built explicitly - no inline ternary-null)
 phase('Design')
+await recordRegistryEvent('heartbeat', 'Design')
 await usageProbe('Design')
 const designThunks = []
 const reqExtra = isLplus ? ' Also write ' + FDIR + '/02_research.md (codebase patterns + external analogues; read the repo for the closest existing implementation to mirror).' : ''
@@ -3482,6 +3646,7 @@ if (!fanVerdict.complete) {
   // (coderUsed/qe are the outer bindings, both still null here, so the row reports null honestly.)
   const designIncompleteGates = { design: fanVerdict.reason === 'probe-not-established' ? 'not-established' : 'incomplete', plan: 'not-run', planCompleteness: 'not-run', challengePanel: 'not-run', code: 'not-run', qe: 'not-run' }
   const designIncompleteOutcome = runOutcomeOf({ phase: 'design-incomplete', gates: designIncompleteGates })
+if (registryOutcome !== 'unverified') registryOutcome = designIncompleteOutcome
   await appendRunCostRow('design-gate', 'Design', designIncompleteOutcome)
   return { tier: tier, phase: 'design-incomplete', outcome: designIncompleteOutcome, slug: SLUG, artifactsDir: FDIR, missingSubstages: fanVerdict.missingSubstages, missingArtifacts: fanVerdict.missingArtifacts, reason: fanVerdict.reason, modelsUsed: modelsUsed, dispatchOutcomes: dispatchOutcomes, gates: designIncompleteGates, resumedStages: resumedStages, checkpointing: CHECKPOINTS_ON ? RESUME_MODE : 'off', trainingPairs: CAPTURE_PAIRS ? TP_DIR : 'off', captureFailures: captureFailures, recordFailures: recordFailures, decisionRecallFailures: decisionRecallFailures, usageEvents: usageEvents, usageThreshold: USAGE_THRESHOLD, polymorphism: POLY.hasManifest ? POLY.report : null, note: 'REFUSED at the Step-5/6 boundary: ' + what + ', so the design is incomplete and Step 6 was NOT dispatched. Planning off a partial design produces a plan with no ADR behind it. ' + repair + ' If a sibling died on a Claude limit, add usage-adaptive routing or route that stage to Codex first (args.models). To rebuild the whole design from scratch instead, re-invoke with args.resume=\'never\'.' }
 }
@@ -3491,6 +3656,7 @@ if (!fanVerdict.complete) {
 // the codex:codex-rescue runtime and GRACEFULLY FALL BACK to the default (Claude) planner if Codex is
 // unavailable/errors — the pipeline never blocks on Codex.
 phase('Plan')
+await recordRegistryEvent('heartbeat', '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/. 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
 const planContext = buildDecisionContext({ slug: SLUG, decisionKind: 'plan-route-selection', description: DESC, tier: tier, codeHint: CODE_HINT, upstreamDigest: fnv1a64(JSON.stringify(design === undefined ? null : design)) })
@@ -3686,6 +3852,7 @@ if (planGate.verdict !== 'pass') {
   // checkpoint deliberately: an incomplete plan is not something to steer, it is something to fix.
   const planGateFailedGates = { plan: (plan ? 'produced' : 'missing'), planCompleteness: planGate.verdict, challengePanel: 'not-run', code: 'not-run', qe: 'not-run' }
   const planGateFailedOutcome = runOutcomeOf({ phase: 'plan-gate-failed', gates: planGateFailedGates })
+if (registryOutcome !== 'unverified') registryOutcome = planGateFailedOutcome
   await appendRunCostRow('plan-gate', 'Plan', planGateFailedOutcome)
   return { tier: tier, phase: 'plan-gate-failed', outcome: planGateFailedOutcome, slug: SLUG, artifactsDir: FDIR, planner: (plan ? plan.planner : null), plan: (plan ? plan.summary : null), modelsUsed: modelsUsed, dispatchOutcomes: dispatchOutcomes, planGate: planGate, gates: planGateFailedGates, resumedStages: resumedStages, checkpointing: CHECKPOINTS_ON ? RESUME_MODE : 'off', trainingPairs: CAPTURE_PAIRS ? TP_DIR : 'off', captureFailures: captureFailures, recordFailures: recordFailures, decisionRecallFailures: decisionRecallFailures, usageEvents: usageEvents, usageThreshold: USAGE_THRESHOLD, polymorphism: POLY.hasManifest ? POLY.report : null, note: refusalNoteFor(planGate, SLUG) }
 }
@@ -3728,6 +3895,7 @@ if (stopHere) {
   // presence), never from prose, so a skipped gate shows as 'not-run' instead of being silently forgotten.
   const planGates = { plan: (plan ? 'produced' : 'missing'), planCompleteness: planGate.verdict, challengePanel: (challengeVerdict ? 'ran' : 'not-run'), code: 'not-run', qe: 'not-run' }
   const checkpointAfterPlanOutcome = runOutcomeOf({ phase: 'checkpoint-after-plan', gates: planGates })
+if (registryOutcome !== 'unverified') registryOutcome = checkpointAfterPlanOutcome
   await appendRunCostRow('plan', 'Plan', checkpointAfterPlanOutcome)
   return { tier: tier, phase: 'checkpoint-after-plan', outcome: checkpointAfterPlanOutcome, artifactsDir: FDIR, planner: (plan ? plan.planner : null), plan: (plan ? plan.summary : null), modelsUsed: plannedModels, dispatchOutcomes: dispatchOutcomes, challengeVerdict: challengeVerdict, gates: planGates, resumedStages: resumedStages, checkpointing: CHECKPOINTS_ON ? RESUME_MODE : 'off', trainingPairs: CAPTURE_PAIRS ? TP_DIR : 'off', captureFailures: captureFailures, recordFailures: recordFailures, decisionRecallFailures: decisionRecallFailures, usageEvents: usageEvents, usageThreshold: USAGE_THRESHOLD, polymorphism: POLY.hasManifest ? POLY.report : null, note: 'L/XL checkpoint - review the ADR + plan (+ the planned code/qe/fleet models) + the challenge panel verdict (advisory) + the gates line, then re-invoke with args.stopAfter="none" to implement + QE (durable checkpoints make the re-invoke resume router+design+plan instead of re-running them). Present the gates map as a `🚦 Gates:` line in the checkpoint banner, rendering the planCompleteness entry as `K2 plan-completeness ✓` (pass) / `✗` (fail) / `inconclusive`.' }
 }
@@ -3764,6 +3932,8 @@ if (QE_SCOPE === 'uncommitted') {
 }
 
 phase('Code')
+
+await recordRegistryEvent('heartbeat', 'Code')
 await usageProbe('Code')
 // GATE-ANSWERED preamble. MEASURED 2026-08-31 (job task-mtgrlrq7, feature storage-auth-classes):
 // a Codex coder exited status=completed, exit 0, touchedFiles=[] because it ASKED the routing
@@ -3977,6 +4147,7 @@ if (resumedStages.indexOf('code') !== -1 && landedNote !== '') {
 
 // Step 8: QE (brutal-honesty, agentic-qe) + MANDATORY teach
 phase('QE')
+await recordRegistryEvent('heartbeat', 'QE')
 
 // ── Writer-quiescence probe (feature qe-writer-quiescence, backlog 700b46a4) ─────────────────────
 // Step-8 used to grade a MOVING tree (crossrt-1: a background worker wrote AFTER the verdict,
@@ -4017,8 +4188,20 @@ log('Step 8 writer-quiescence: ' + writerQuiescence.verdict + ' (windows: ' + (w
 const wqNote = writerQuiescence.verdict === 'quiet'
   ? ' WRITER-QUIESCENCE: quiet (' + writerQuiescence.note + ').'
   : ' WRITER-QUIESCENCE GATE (MANDATORY to acknowledge): ' + writerQuiescence.note + ' State this standing explicitly in 08_qe_report.md next to the grade.'
+const confirmationGatePrompt = 'STEP-8 CONFIRMATION FILE GATE. You are the shell because this workflow sandbox has no filesystem API. Work under repo ' + REPO + ' and inspect only direct canonical ADR Markdown files in ' + FDIR + '/03_adr/NNN-*.md. If 03_adr is absent or has zero direct ADR files, return verdict=skipped, reason="ADR нет, проверять нечего", missing=[], checked=[]. Otherwise read every ADR. Find its unique H2 whose line starts with `## Confirmation` (the suffix may be Russian), extract EVERY repo-relative test-file path named in that section, and refuse if the section/path cannot be parsed. For every extracted path run shell checks from ' + REPO + ': missing (`test -e` is false) goes in missing; an existing path that is not a readable regular file (`test -f`, `test -r`, and an actual read) returns verdict=refused with the exact path and reason. Never turn an unreadable path, directory, parse failure, empty stdout, or tool error into skipped. If missing is non-empty return verdict=fail; otherwise pass. This gate proves ONLY file existence/readability; do not enforce the other ADR checklist items. Return exactly {verdict, missing, checked, reason}.'
+const confirmationGateRaw = await dispatchAgent(newRung(), confirmationGatePrompt, { label: 'qe:confirmation-files', phase: 'QE', effort: 'low', schema: CONFIRMATION_FILE_GATE })
+const confirmationFileGate = normalizeConfirmationFileGate(confirmationGateRaw)
+const confirmationGateLine = confirmationFileGate.verdict === 'skipped'
+  ? 'Confirmation file gate: пропущено: ADR нет, проверять нечего'
+  : confirmationFileGate.verdict === 'pass'
+    ? 'Confirmation file gate: PASS — checked ' + confirmationFileGate.checked.join(', ')
+    : confirmationFileGate.verdict === 'fail'
+      ? 'Confirmation file gate: FAIL — missing ' + confirmationFileGate.missing.join(', ')
+      : 'Confirmation file gate: REFUSED — ' + confirmationFileGate.reason
+log(confirmationGateLine)
+const confirmationGateNote = ' MANDATORY CONFIRMATION FILE GATE RESULT: `' + confirmationGateLine + '`. Write that as a separate line in 08_qe_report.md. The independent QE review MUST still run. If the gate verdict is fail or refused, the final Step-8 grade cannot be A or B; the workflow also enforces that after the reviewer returns. This gate proves only existence/readability; all other ADR checklist items remain advisory.'
 await usageProbe('QE')
-const qePrompt = 'Step 8 (QE - brutal-honesty review, agentic-qe) of /feature-adr for "' + DESC + '" (' + SLUG + '). Adversarially review the SHIPPED code (read it): correctness, edge cases, error handling, and the LOAD-BEARING property the ADR named (ASSERT it has a test that DISCRIMINATES - the recurring lesson: a test that would still pass with the protection deleted is documentation, not a gate). Run this ADR gate before final grading: ' + ADR_FITNESS_CHECKLIST + ' ' + DISCRIMINATION_GATE + ' ' + MUTATION_GATE + ' ' + NO_STUBS_GATE + ' ' + AMENDMENT_GATE + ' Grade A/B/C/D honestly. Assess code-test adequacy + doc-test presence. List CONFIRMED gaps with severity. Write ' + FDIR + '/08_qe_report.md with the primary findings under the exact heading `## Primary QE pass` and an ADR Fitness Checklist section showing PASS/FAIL per ADR and evidence for the Confirmation-linked test. MANDATORY SELF-LEARNING STORE (close the loop, never skip): compare every candidate lesson against the Step-0 recalled LEARNED patterns above. Teach ONLY lessons NOT covered by Step-0 recall. On overlap, run `dz teach --reinforce "<recalled pattern id or exact text>" --project ' + BRAIN + '` instead of minting a near-duplicate; if --reinforce is unavailable, skip the duplicate teach and report `reinforced existing pattern <id>` in the QE report. Store every genuinely new lesson in the CANONICAL BRAIN store at `' + BRAIN + '` so it is NOT lost to a target repo you may have cd`d into. Via Bash run EXACTLY `' + DZ_TEACH('<a durable reusable lesson from this feature - a rule/pattern/pitfall, NOT a checkpoint echo>', '<0.7-0.95>', '<area>') + '` for each genuine NEW lesson (1-3 max, high-signal) — the `cd ' + BRAIN + ' &&` prefix + `--project ' + BRAIN + '` pin guarantee the lesson lands in the brain regardless of your CWD. Then run `' + DZ + ' statusline --fa-record --slug ' + SLUG + ' --step "Step 8 QE" --recalled auto --run fa:' + SLUG + ' --count-project ' + BRAIN + ' --stored <count taught> --reinforced <count reinforced> --mode ' + MODE + ' --project ' + REPO + '` (run it verbatim via Bash, do not skip). Do NOT teach trivia or invent gaps. AUTHORING-TIME CLAIM-CHECK (Deliverable of claim-check-authoring-time): after writing ' + FDIR + '/08_qe_report.md, run EXACTLY `dz claim-check ' + FDIR + '/08_qe_report.md --json --fail-on none` via Bash, parse the {ok, findings, scanned} JSON, and report claimCheck: {findings: N, high: N, medium: N} (counts by severity) in your return object. TAG EVERY QUANTITATIVE CLAIM you write in the report using the convention the checker recognizes as honest — write "1131 tests pass (MEASURED — `npx vitest run`)", never a bare "1131 tests pass" — and where you QUOTE a forbidden phrase as an example (e.g. the retracted "100% passing" framing), backtick the literal so it reads as code, not an assertion, so your own compliant report scans clean. Return {grade, gaps, codeTestsAdequate, docTestsPresent, claimCheck}.' + ABSOLUTE_PATH_NOTE + landedNote + wqNote + PS_GUIDANCE('qe')
+const qePrompt = 'Step 8 (QE - brutal-honesty review, agentic-qe) of /feature-adr for "' + DESC + '" (' + SLUG + '). Adversarially review the SHIPPED code (read it): correctness, edge cases, error handling, and the LOAD-BEARING property the ADR named (ASSERT it has a test that DISCRIMINATES - the recurring lesson: a test that would still pass with the protection deleted is documentation, not a gate). Run this ADR gate before final grading: ' + ADR_FITNESS_CHECKLIST + ' ' + DISCRIMINATION_GATE + ' ' + MUTATION_GATE + ' ' + NO_STUBS_GATE + ' ' + AMENDMENT_GATE + ' Grade A/B/C/D honestly. Assess code-test adequacy + doc-test presence. List CONFIRMED gaps with severity. Write ' + FDIR + '/08_qe_report.md with the primary findings under the exact heading `## Primary QE pass` and an ADR Fitness Checklist section showing PASS/FAIL per ADR and evidence for the Confirmation-linked test. MANDATORY SELF-LEARNING STORE (close the loop, never skip): compare every candidate lesson against the Step-0 recalled LEARNED patterns above. Teach ONLY lessons NOT covered by Step-0 recall. On overlap, run `dz teach --reinforce "<recalled pattern id or exact text>" --project ' + BRAIN + '` instead of minting a near-duplicate; if --reinforce is unavailable, skip the duplicate teach and report `reinforced existing pattern <id>` in the QE report. Store every genuinely new lesson in the CANONICAL BRAIN store at `' + BRAIN + '` so it is NOT lost to a target repo you may have cd`d into. Via Bash run EXACTLY `' + DZ_TEACH('<a durable reusable lesson from this feature - a rule/pattern/pitfall, NOT a checkpoint echo>', '<0.7-0.95>', '<area>') + '` for each genuine NEW lesson (1-3 max, high-signal) — the `cd ' + BRAIN + ' &&` prefix + `--project ' + BRAIN + '` pin guarantee the lesson lands in the brain regardless of your CWD. Then run `' + DZ + ' statusline --fa-record --slug ' + SLUG + ' --step "Step 8 QE" --recalled auto --run fa:' + SLUG + ' --count-project ' + BRAIN + ' --stored <count taught> --reinforced <count reinforced> --mode ' + MODE + ' --project ' + REPO + '` (run it verbatim via Bash, do not skip). Do NOT teach trivia or invent gaps. In the return object set roundLessons to the teach:<id> receipts successfully written in this Step 8; when there were none, return roundLessons:[] and a non-empty roundNoNewKnowledge reason derived from this review/reinforcement decision. AUTHORING-TIME CLAIM-CHECK (Deliverable of claim-check-authoring-time): after writing ' + FDIR + '/08_qe_report.md, run EXACTLY `dz claim-check ' + FDIR + '/08_qe_report.md --json --fail-on none` via Bash, parse the {ok, findings, scanned} JSON, and report claimCheck: {findings: N, high: N, medium: N} (counts by severity) in your return object. TAG EVERY QUANTITATIVE CLAIM you write in the report using the convention the checker recognizes as honest — write "1131 tests pass (MEASURED — `npx vitest run`)", never a bare "1131 tests pass" — and where you QUOTE a forbidden phrase as an example (e.g. the retracted "100% passing" framing), backtick the literal so it reads as code, not an assertion, so your own compliant report scans clean. Return {grade, gaps, codeTestsAdequate, docTestsPresent, claimCheck, roundLessons, roundNoNewKnowledge}.' + ABSOLUTE_PATH_NOTE + landedNote + wqNote + confirmationGateNote + PS_GUIDANCE('qe')
 // CROSS-MODEL QE (load-bearing): resolveStageModel('qe') derives the OTHER family than the resolved
 // coder when args.models.qe is unset (coder-codex ⇒ opus; coder-Claude ⇒ codex, or opus if codex absent).
 // An explicit args.models.qe wins. A Claude qe spec is merged onto the qe-code-reviewer base (role
@@ -4049,7 +4232,7 @@ const qe2Spec = qePrecisionPassSpec(PRIMARY, BUDGET_MODE, tier)
 // re-teach (the original run already stored its lessons — replaying teach would double-store).
 // R6: the review SCOPE is part of what a QE verdict is about, so it enters the hash — a resume must
 // not present a verdict obtained over one scope as if it had been obtained over another.
-const qeHash = ckptHash('qe', [fnv1a64(JSON.stringify(codeStage === undefined ? null : codeStage)), tier, DESC, QE_REVIEWER, MODELS.qe === undefined ? null : MODELS.qe, CODEX_MODEL, coderUsed, PRIMARY, BUDGET_MODE, qe2Spec, POLY.hasManifest, fnv1a64(String(POLY.report || '')), usageOverride, QE_SCOPE, QE_SCOPE_REF])
+const qeHash = ckptHash('qe', [fnv1a64(JSON.stringify(codeStage === undefined ? null : codeStage)), tier, DESC, QE_REVIEWER, MODELS.qe === undefined ? null : MODELS.qe, CODEX_MODEL, coderUsed, PRIMARY, BUDGET_MODE, qe2Spec, POLY.hasManifest, fnv1a64(String(POLY.report || '')), usageOverride, QE_SCOPE, QE_SCOPE_REF, confirmationFileGate])
 let crossFamilyQeReport = null
 const qeStage = await withCheckpoint('qe', 'QE', qeHash, async () => {
 let qe = null
@@ -4184,7 +4367,7 @@ if (qe === null && (qeIsCodex || QE_REVIEWER === 'codex-fallback')) {
   if (codexQe) {
     // gaps come from what the reviewer ACTUALLY found; gradeSource says whether the letter was
     // STATED by the reviewer or DERIVED from its findings, because mode A cannot be asked for one.
-    qe = { grade: codexQe.grade, gaps: codexQe.findings, codeTestsAdequate: null, docTestsPresent: null, summary: String(codexQe.text).slice(0, 1500), gradeSource: codexQe.gradeSource, qeScope: { mode: codexQe.mode, ref: codexQe.scopeRef, files: codexQe.files } }
+    qe = enforceConfirmationFileGate({ grade: codexQe.grade, gaps: codexQe.findings, codeTestsAdequate: null, docTestsPresent: null, summary: String(codexQe.text).slice(0, 1500), gradeSource: codexQe.gradeSource, qeScope: { mode: codexQe.mode, ref: codexQe.scopeRef, files: codexQe.files } }, confirmationFileGate)
     qeReviewerUsed = qeIsCodex ? 'codex' : 'codex-fallback'
     log('QE: cross-family review by codex, mode ' + codexQe.mode + ' (scope ' + codexQe.scopeRef + ', grade ' + codexQe.grade + ' ' + codexQe.gradeSource + ', ' + codexQe.elapsedSeconds + 's)')
     // ARTIFACT SCRIBE. The old dispatch handed Codex the whole Step-8 prompt, so the reviewer itself
@@ -4199,7 +4382,7 @@ if (qe === null && (qeIsCodex || QE_REVIEWER === 'codex-fallback')) {
       // with no 08_qe_report.md at all. Named by cross-family review of b6973199. The verdict itself
       // is real (Codex produced it), so a failed transcription DEGRADES the run rather than voiding
       // it — but it must be visible, and it must never read as a clean QE.
-      const scribePrompt = 'Step 8 (QE) of /feature-adr for "' + DESC + '" (' + SLUG + '). The independent cross-family review has ALREADY BEEN DONE, by Codex. You are the SCRIBE, not the reviewer: RECORD it, do NOT re-grade it, do NOT soften it, do NOT add a verdict of your own, and do NOT mark anything resolved that the reviewer flagged. The grade is ' + codexQe.grade + ' and it is FINAL.\n\nWrite ' + FDIR + '/08_qe_report.md with: (1) the grade ' + codexQe.grade + ' stated verbatim; (2) HOW it was obtained — dispatch mode ' + codexQe.mode + ', scope ' + codexQe.scopeRef + ', wall-clock ' + codexQe.elapsedSeconds + 's, gradeSource ' + codexQe.gradeSource + ' (a DERIVED grade means the reviewer could not be asked for a letter and it was computed from the severities it reported — say so plainly); (3) the reviewer text below, verbatim, under the exact heading `## Primary QE pass`; (4) an ADR Fitness Checklist section with PASS/FAIL per ADR and the evidence pointer for the Confirmation-linked test.\n\nREVIEWER TEXT (verbatim, do not edit or summarise):\n' + String(codexQe.text) + '\n\nMANDATORY SELF-LEARNING STORE (close the loop, never skip): compare candidate lessons against the Step-0 recalled LEARNED patterns. Teach ONLY lessons NOT already covered; on overlap run `dz teach --reinforce "<recalled pattern id or exact text>" --project ' + BRAIN + '` instead of minting a near-duplicate. Via Bash run EXACTLY `' + DZ_TEACH('<a durable reusable lesson from this feature - a rule/pattern/pitfall, NOT a checkpoint echo>', '<0.7-0.95>', '<area>') + '` for each genuine NEW lesson (1-3 max, high-signal). Then run `' + DZ + ' statusline --fa-record --slug ' + SLUG + ' --step "Step 8 QE" --recalled auto --run fa:' + SLUG + ' --count-project ' + BRAIN + ' --stored <count taught> --reinforced <count reinforced> --mode ' + MODE + ' --project ' + REPO + '` verbatim via Bash. Finally run EXACTLY `dz claim-check ' + FDIR + '/08_qe_report.md --json --fail-on none` via Bash and TAG every quantitative claim you write the way the checker recognises as honest.' + ABSOLUTE_PATH_NOTE
+      const scribePrompt = 'Step 8 (QE) of /feature-adr for "' + DESC + '" (' + SLUG + '). The independent cross-family review has ALREADY BEEN DONE, by Codex. You are the SCRIBE, not the reviewer: RECORD it, do NOT re-grade it, do NOT soften it, do NOT add a verdict of your own, and do NOT mark anything resolved that the reviewer flagged. The reviewer grade was ' + codexQe.grade + '; the final Step-8 grade after the deterministic Confirmation file gate is ' + qe.grade + ' and it is FINAL: the file gate can only LOWER a reviewer grade, never raise it, and nothing after this point may change it.\n\nWrite ' + FDIR + '/08_qe_report.md with: (1) the final grade ' + qe.grade + ' stated verbatim; (2) HOW it was obtained — reviewer grade ' + codexQe.grade + ', dispatch mode ' + codexQe.mode + ', scope ' + codexQe.scopeRef + ', wall-clock ' + codexQe.elapsedSeconds + 's, gradeSource ' + codexQe.gradeSource + ' (a DERIVED grade means the reviewer could not be asked for a letter and it was computed from the severities it reported — say so plainly); (3) the reviewer text below, verbatim, under the exact heading `## Primary QE pass`; (4) an ADR Fitness Checklist section with PASS/FAIL per ADR and the evidence pointer for the Confirmation-linked test; (5) this gate receipt as a separate line: `' + confirmationGateLine + '`.\n\nREVIEWER TEXT (verbatim, do not edit or summarise):\n' + String(codexQe.text) + '\n\nMANDATORY SELF-LEARNING STORE (close the loop, never skip): compare candidate lessons against the Step-0 recalled LEARNED patterns. Teach ONLY lessons NOT already covered; on overlap run `dz teach --reinforce "<recalled pattern id or exact text>" --project ' + BRAIN + '` instead of minting a near-duplicate. Via Bash run EXACTLY `' + DZ_TEACH('<a durable reusable lesson from this feature - a rule/pattern/pitfall, NOT a checkpoint echo>', '<0.7-0.95>', '<area>') + '` for each genuine NEW lesson (1-3 max, high-signal). Then run `' + DZ + ' statusline --fa-record --slug ' + SLUG + ' --step "Step 8 QE" --recalled auto --run fa:' + SLUG + ' --count-project ' + BRAIN + ' --stored <count taught> --reinforced <count reinforced> --mode ' + MODE + ' --project ' + REPO + '` verbatim via Bash. Finally run EXACTLY `dz claim-check ' + FDIR + '/08_qe_report.md --json --fail-on none` via Bash and TAG every quantitative claim you write the way the checker recognises as honest.' + ABSOLUTE_PATH_NOTE
       // WITNESS THE REWRITE, not the existence. On a re-QE or a resume with the same slug an OLD
       // 08_qe_report.md is already sitting there, and an existence probe reports that stale file as
       // landed — so a scribe that wrote nothing still marked the new verdict recorded, and the stage
@@ -4254,6 +4437,7 @@ if (qe === null && qeIsCodex) {
   if (qe) { qeReviewerUsed = 'claude'; crossFamilyQeReport = cfBelt.report }
   else modelsUsed.qe = cfBelt.label + ' (no deliverable)'
 }
+qe = enforceConfirmationFileGate(qe, confirmationFileGate)
 // A-normal L/XL only: Sonnet is the recall-oriented primary reviewer; Opus is a SECOND,
 // independent precision pass. It is advisory but real — never a table-only half-wire — and its
 // provenance stays separate in both the return object and 08_qe_report.md.
@@ -4305,6 +4489,26 @@ let qeReviewerUsed = qeStage ? qeStage.qeReviewerUsed : 'claude'
 if (qeStage && qeStage.modelUsed) modelsUsed.qe = qeStage.modelUsed + (resumedStages.indexOf('qe') !== -1 ? ' (resumed)' : '')
 if (qeStage && qeStage.qe2ModelUsed) modelsUsed.qe2 = qeStage.qe2ModelUsed + (resumedStages.indexOf('qe') !== -1 ? ' (resumed)' : '')
 
+// Step 8 has completed its teach/reinforce work and written 08_qe_report.md. Closing telemetry is
+// secondary: refusal is loud and reflected in roundClosed, but it never overturns the feature run.
+if (qe && pipelineRound !== null) {
+  const roundGrade = String(qe.grade || '').trim().toUpperCase()
+  const roundOutcome = ['A', 'A-', 'B+', 'B'].indexOf(roundGrade) !== -1 ? 'shipped' : (['C', 'D'].indexOf(roundGrade) !== -1 ? 'refuted' : null)
+  if (roundOutcome === null) {
+    log('round close refused: unsupported Step 8 grade ' + JSON.stringify(roundGrade))
+  } else {
+    const roundLessonIds = Array.isArray(qe.roundLessons) ? qe.roundLessons.filter(function (id) { return /^teach:[a-z0-9]+$/i.test(String(id)) }) : []
+    const roundLearningArg = roundLessonIds.length > 0
+      ? roundLessonIds.map(function (id) { return ' --lesson ' + shq(String(id)) }).join('')
+      : ' --no-new-knowledge ' + shq((typeof qe.roundNoNewKnowledge === 'string' && qe.roundNoNewKnowledge.trim() !== '') ? qe.roundNoNewKnowledge.trim() : 'Step 8 returned no new teach receipt for this round')
+    const roundCloseCmd = 'cd ' + shq(REPO) + ' && ' + DZ + ' round close --slug ' + shq(SLUG) + ' --round ' + pipelineRound + ' --outcome ' + roundOutcome + ' --reason ' + shq('grade ' + roundGrade) + roundLearningArg + ' --project ' + shq(BRAIN) + ' --no-cost --json'
+    const roundCloseOut = await dispatchAgent(newRung(), 'Run EXACTLY this one shell command via your Bash tool and return its stdout VERBATIM, nothing else: ' + roundCloseCmd, { label: 'round:close', phase: 'QE', effort: 'low' })
+    const roundCloseReceipt = parseRoundCommandJson(roundCloseOut)
+    roundClosed = !!(roundCloseReceipt && roundCloseReceipt.marker && roundCloseReceipt.row && roundCloseReceipt.row.stage === 'round')
+    if (!roundClosed) log('round close refused: ' + (roundCloseReceipt && roundCloseReceipt.message ? roundCloseReceipt.message : String(roundCloseOut || 'no JSON receipt')))
+  }
+}
+
 // Step 8 claim-gate: fold the QE agent's reported claim-check counts into an additive result field.
 const claimGate = step8ClaimGate(qe && qe.claimCheck ? qe.claimCheck : null)
 log(claimGate.note)
@@ -4411,6 +4615,7 @@ if (Object.keys(AUTOCOST).length > 0 && resumedStages.indexOf('qe') === -1) {
 let fleet = 'skipped (S/M)'
 if (isLplus) {
   phase('FleetQE')
+  await recordRegistryEvent('heartbeat', 'FleetQE')
   await usageProbe('FleetQE')
   const fleetDecision = resolveStageDecision('fleet')
   const fleetModel = fleetDecision.opts
@@ -4469,6 +4674,7 @@ let delivery = null
 if (DELIVERY_ON) {
   try {
     phase('Delivery')
+    await recordRegistryEvent('heartbeat', 'Delivery')
     await usageProbe('Delivery')
     // QE-D#2: cross-family is judged against the ACTUAL coder (coderUsed — the code stage already ran), and
     // codex PLANES are unsupported in v1: a plane is a data-returning schema stage, and the codex wrapper
@@ -4650,6 +4856,7 @@ const finalGates = {
   // DERIVED from the barrier's machine verdict, not from "is there a result object". A codex run
   // whose barrier came back INCONCLUSIVE used to render exactly like a clean synchronous one.
   code: (codeStage === null || codeStage === undefined || !code ? 'missing' : (codeStage.landingStatus === 'synchronous' ? 'produced' : (codeStage.landingStatus === 'landed' ? 'landed' : (codeStage.landingStatus === 'inconclusive' ? 'inconclusive' : 'not-landed')))),
+  confirmationFiles: confirmationFileGate.verdict,
   qe: (qe ? (qe.grade || 'ran') : 'not-run'),
   claimCheck: (qe && qe.claimCheck ? (qe.claimCheck.high > 0 ? 'high-findings' : 'clean') : 'not-run'),
   fleet: (isLplus ? (fleet ? 'ran' : 'not-run') : 'n/a'),
@@ -4664,6 +4871,7 @@ await appendRunCostRow('full', (isLplus ? 'FleetQE' : 'QE'), finalOutcome)
 // time) hit SCORE-EXISTS and froze the failed attempt's 0/N forever. An unfinished run is simply
 // not scored; the resume that finishes the work scores it.
 const score = finalOutcome === 'completed' ? await autoScore(qeHash) : null
+if (registryOutcome !== 'unverified') registryOutcome = finalOutcome
 return {
   slug: SLUG, tier: tier, mode: MODE, artifactsDir: FDIR,
   outcome: finalOutcome,
@@ -4671,6 +4879,7 @@ return {
   design: design.filter(Boolean).map((d) => d.wrote).flat(),
   codeWrote: code ? code.wrote : [],
   qeGrade: qe ? qe.grade : null,
+  roundClosed: roundClosed,
   score: score,
   gaps: qe ? qe.gaps : [],
   codeTestsAdequate: qe ? qe.codeTestsAdequate : null,
@@ -4696,9 +4905,16 @@ return {
   crossFamilyQe: crossFamilyQeReport,
   qeReportWritten: (qe && typeof qe.qeReportWritten === 'boolean') ? qe.qeReportWritten : null,
   claimGate: claimGate,
+  confirmationFileGate: confirmationFileGate,
   autoCost: Object.keys(AUTOCOST).length ? AUTOCOST : null,
   // P4 (checkpoint-gate-line): DERIVED gate map for the final banner — from actual run state, never prose.
   gates: finalGates,
   delivery: delivery,
   promiseTags: tags,
 }
+} finally {
+  if (finishRunRegistry) {
+    try { await finishRunRegistry() }
+    catch (error) { registryOutcome = 'unverified'; log('run registry: finished UNVERIFIED — ' + String(error)) }
+  }
+}