@dzhechkov/harness-cli 0.8.9 → 0.8.10

package/src/cli.ts

@@ -13,7 +13,7 @@ import { isBooleanFlag } from './boolean-flags.js';
 import { resolveInstallSpec } from './install-spec.js';
 import { execFile, execFileSync, execSync, spawn, spawnSync, type ChildProcess } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
-import { homedir, tmpdir } from 'node:os';
+import { homedir, hostname, tmpdir } from 'node:os';
 import { createRequire } from 'node:module';
 import { isDeepStrictEqual } from 'node:util';
 
@@ -30,6 +30,8 @@ import {
   runDoctor,
   runInit,
   discoverSkillIds,
+  resolveSelection,
+  formatSelectRefusal,
   runIntegrationsVerify,
   resolvePackageSkillRoots,
   PACKAGE_SKILL_LAYOUTS,
@@ -210,6 +212,8 @@ import {
   readTailInfo,
   appendChainedLines,
   verifyEventChainText,
+  classifyChainDefects,
+  CHAINED_JOURNALS,
   buildManifest,
   buildSbom,
   resolveTrustRoot,
@@ -371,6 +375,11 @@ import {
   type EpochOutcome,
   scoreRun,
   readQeGrade,
+  scoreReceiptToAggregateRow,
+  readScoreAggregateRows,
+  dedupeScoreAggregateRows,
+  buildScoreAggregateReport,
+  renderScoreAggregateReport,
   recapWindow,
   decideHorizon,
   withinWindow,
@@ -478,6 +487,7 @@ import {
   // Mutation gate (feature ha-mutation-gate) — break each named protection, run the suite, require red.
   parseMutationRegistry,
   applyMutationToText,
+  attributeBaselineRedness,
   countFailingTests,
   detectSuiteCompletionReceipt,
   detectSuiteReceiptMismatch,
@@ -487,6 +497,7 @@ import {
   mutationGateExitCode,
   summarizeMutationResults,
   renderMutationReport,
+  runWithOneInternalRetry,
   TRACE_BUNDLE_LEDGER_PATH,
   TRACE_BUNDLE_SCHEMA,
   TRACE_BUNDLE_RUN_META_FILE,
@@ -573,7 +584,7 @@ export const DZ_COMMANDS: readonly string[] = [
   'epoch-replay', 'score', 'recap', 'cadence', 'qe-rounds', 'restart-advisor', 'tg-post',
   'name-check', 'provenance-check', 'feature-adr-record', 'amendment-check', 'contract-check',
   'feature-adr-checkpoint', 'profile', 'reqe', 'qe-bridge', 'backlog', 'routing',
-  'bto-optimize', 'dashboard', 'roam', 'import-ecc',
+  'bto-optimize', 'dashboard', 'roam', 'import-ecc', 'chain',
 ];
 
 const USAGE = `dz - DZ cross-platform harness CLI
@@ -615,6 +626,7 @@ Usage:
   dz epoch-replay --judge <filled-work-order.json> [--out <file>]   (blind judge prompts from the filled plans)
   dz epoch-replay --score <judgments.json> --work-order <file> [--slice <name>] [--json]   (un-blind against the pre-registered assignment → SUPPORTED only when the two 95% Wilson CIs are DISJOINT, else FALSIFIED / INCONCLUSIVE)
   dz score --slug <feature> [--project <dir>] [--json]   (process scorecard for ONE feature-adr run, from its artifacts: ADR confirmation, discrimination, cross-model QE grade, live verification, README-first, learning loop, amendments — descriptive-only, a low score exits 0)
+  dz score --all [--project <dir>] [--json]              (sweep features/*/.fa-state/score-*.json into the append-only chained scorecards aggregate — descriptive-only, always exits 0)
   dz recap [--day|--week|--month] [--at <ISO date>] [--project <dir>] [--json]   (what was done over a window, from records only: deliveries with the grade an independent review STATED — a report naming two grades is reported ambiguous, never guessed — registry publishes, gate verdicts, knowledge reuse. --quarter/--half-year/--year are RECOGNISED and REFUSED with the real span in days: there is one complete quarter and the longest record is 174 days. Every section carries its own data-start date, and "the source was not read" never prints as zero. Contaminated measures — commit count, lines, tokens, learning-event volume, inventory counts, lesson count — are not computed, and the report says so. exit 0 reported / 2 refused)
   dz cadence [--window day|week|month|quarter|halfyear|year] [--json]   (the WHAT-SHIPPED aggregator: graded-shipment cadence by ISO week + npm-publish cadence (recap cache) + guard repeat decay on the FIXED rule set + recall reuse; a window deeper than 2× the record is REFUSED with the depth named (ADR: a cadence from one point is scale forgery); exit 0 report / 2 refused-window / 1 usage)
   dz qe-rounds (--slug <feature> | --feature-dir <abs>) [--ceiling <n>] [--project <dir>] [--json]   (how many Step-8 review rounds has this feature ALREADY had? Reads what dz qe-bridge already wrote — signoff-<runId>.json and failed-*.json under features/<slug>/.fa-state/qe-bridge — and writes nothing itself, so it can answer for runs already past. A round is a runId, not a file; an attempt with no verdict is counted SEPARATELY and never merged; an unreadable record is NAMED and the count is declared a LOWER BOUND. ONE directory, never a union across checkouts. exit 0 under the ceiling / 1 at-or-over — owner decides, the command does not judge whether the rounds were warranted / 2 NOT ESTABLISHED, which is never "zero rounds")
@@ -633,7 +645,7 @@ Usage:
   dz feature-adr-checkpoint (--slug <feature> | --feature-dir <abs>) --stage <s> --input-hash <h> --result <json> [--artifact a,b] [--json]   (record a pipeline stage ONLY after measuring its artifacts on disk; refuses a null result, an absent artifact, or a stage that declares none — the subagent runs a COMMAND instead of hand-writing durable state)
   dz profile [init|show|set|sync] [--json]   (WHO the assistant is talking to — per-user store at ~/.dz/profile.json (0600, NEVER in a project), delivered as a marked block in ~/.claude/CLAUDE.md so it loads in EVERY project, dz installed or not. init = five questions (language, register, deep/weak domains as comma lists — "networking (CCIE; NSX)" keeps the parenthetical as the note, Enter skips — teaches y/n with one re-ask, never a silent default); show ALWAYS prints the store path + age + drift verdict + the rendered block; set register|language|teaches <v> or set deep|weak add|rm <tag> [note] — register accepts the owner's own words (профи / профи лайт / просто), an unknown value is REFUSED naming the accepted set; sync re-writes the block (runs automatically after init/set; foreign content byte-for-byte, timestamped backup before every modifying write). The register changes FORM, never FACTS, and governs dialogue only — never ADRs/commits/QE reports; both rules are baked into the rendered block at every level. exit 0 done / 1 no profile or failed / 2 refused input)
   dz reqe [--slug <feature> [--done --report <f>]] [--json]   (the re-QE debt ledger: a usage-switched run whose Step-8 QE ran on the coder's OWN family records a debt; list debts, print the cross-family review brief, settle FAIL-CLOSED against a graded report — the settlement lands in 08_qe_report.md)
-  dz qe-bridge --family claude --slug <feature> [--coder-family codex|claude] [--model <id>] [--files a,b] [--out <f>] [--timeout <s>] [--allow-same-family] [--json]   (the REVERSE QE bridge: run an INDEPENDENT Claude reviewer over a feature's Step-8 artifacts from ANY host — a Codex session included, plain shell, no Claude agent plane needed — and land a PARSED signoff. The reviewer runs ISOLATED: an EMPTY temp cwd plus --safe-mode --strict-mcp-config --tools '' --no-session-persistence, so no CLAUDE.md/skills/plugins/hooks/MCP load, and the verdict is read from the --output-format json RESULT ENVELOPE — text a session customization printed onto the same stdout can never become a signoff. Probes the model before trusting it; sends SCOPED extracts with a loud 200k-char ceiling (never silent truncation); the grade must AGREE across three LAST-anchored channels (terminal marker line, fenced qe-bridge-signoff JSON, the report's own GRADE line) AND the marker must be the FINAL content — empty, gradeless, self-contradicting or miscounted output is one of 18 NAMED failures with an audit record under features/<slug>/.fa-state/qe-bridge/ (runId, resolved executable + binOverride, prompt sha256, channel offsets, requestedOut, reportWritten, retained raw stdout; 0600 files in a 0700 dir), never a clean review. A --coder-family that contradicts the recorded reqe debt is refused. Writes features/<slug>/08b_reqe_report.md, which dz reqe --done settles unchanged. DISCLOSURE: the extracts you scope are sent to the Claude runtime; the bridge cannot classify secrets. DZ_QE_BRIDGE_CLAUDE_BIN is a TEST SEAM, not a flag. exit 0 signoff parsed (ANY grade — it reports, it does not gate) / 1 named failure / 2 usage)
+  dz qe-bridge --family claude --slug <feature> [--coder-family codex|claude] [--model <id>] [--files a,b] [--out <f>] [--timeout <s>] [--allow-same-family] [--json]   (the REVERSE QE bridge: run an INDEPENDENT Claude reviewer over a feature's Step-8 artifacts from ANY host — a Codex session included, plain shell, no Claude agent plane needed — and land a PARSED signoff. The reviewer runs ISOLATED: an EMPTY temp cwd plus --safe-mode --strict-mcp-config --tools '' --no-session-persistence, so no CLAUDE.md/skills/plugins/hooks/MCP load, and the verdict is read from the --output-format json RESULT ENVELOPE — text a session customization printed onto the same stdout can never become a signoff. Probes the model before trusting it; sends SCOPED extracts with a loud 200k-char ceiling (never silent truncation); the grade must AGREE across three LAST-anchored channels (terminal marker line, fenced qe-bridge-signoff JSON, the report's own GRADE line) AND the marker must be the FINAL content — empty, gradeless, self-contradicting or miscounted output is one of 17 NAMED failures with an audit record under features/<slug>/.fa-state/qe-bridge/ (runId, resolved executable + binOverride, prompt sha256, channel offsets, requestedOut, reportWritten, retained raw stdout; 0600 files in a 0700 dir), never a clean review. A --coder-family that contradicts the recorded reqe debt is refused. Writes features/<slug>/08b_reqe_report.md, which dz reqe --done settles unchanged. DISCLOSURE: the extracts you scope are sent to the Claude runtime; the bridge cannot classify secrets. DZ_QE_BRIDGE_CLAUDE_BIN is a TEST SEAM, not a flag. exit 0 signoff parsed (ANY grade — it reports, it does not gate) / 1 named failure / 2 usage)
   dz mutation-gate [--package <dir>] [--registry <file>] [--test-cmd "<cmd>"] [--only <id[,id]>] [--timeout <ms>] [--rebaseline per-entry|final] [--keep-scratch] [--json]   (prove each NAMED protection has a test that DISCRIMINATES: copy the package to a scratch dir, verify the baseline suite is green, apply each registry mutation, run the suite, REQUIRE red, restore. The red must be BEHAVIOURAL: a mutation that no longer parses is MUTATION_UNPARSEABLE; a red run whose OWN output reports a test FILE failing to load (node --test file-level not-ok with exitCode, vitest Failed Suites) is MUTATION_LOAD_FATAL — the signal comes from the same run as the failing count, never from a separate isolated import; red output whose shape matches no known runner is INCONCLUSIVE (a runner-coverage gap, loud, never PROVEN); a count far above the entry's bound is OVER_FAILING; a restored tree that does not reproduce green makes the entry INCONCLUSIVE (flaky). Mutation writes are realpath-contained to the scratch copy: a symlink escape or a node_modules/ target is refused (exit 2), the real tree is never written. A mutation that does not apply, a green suite, or an inconclusive run is a FAILURE — never a skip. exit 0 all proven / 1 gate failed / 2 setup error)
   dz backlog add "<idea>" [--effort 1-5] [--proposal <text>] [--dry-run] [--project <dir>] [--json]   (capture an idea: semantic dedup against existing ideas via the Brain vector engine (DUPLICATE>=0.92 merges, RELATED links, NEW creates) + GoalMap alignment; --dry-run classifies without writing)
   dz backlog list [--status <s>] [--goal <id>] [--project <dir>] [--json]   (list captured ideas, filterable by status/goal)
@@ -672,6 +684,7 @@ Usage:
   dz statusline --fa-record --slug <s> --step "<label>" [--kind <feature-adr|loop>] [--recalled <n>] [--stored <n>] [--mode <m>]   (feature-adr: record live per-run learning state → 📐 panel segment)
   dz usage [--json] [--project <dir>] | dz usage --calibrate --session <pct> --weekly <pct> [--model fable=<pct>] [--project <dir>]  (ESTIMATE Claude usage from fixed reset windows; optional per-model weekly binding; exit 0 ALWAYS; pct=null when limits unconfigured)
   dz usage --by-stage [--run <runId> | --slug <slug>] [--epsilon <0..1>] [--write <file.jsonl>] [--json]   (per-stage cost ledger for ONE feature-adr run + the reconciliation invariant: accounted + unaccounted = run total; verdict BALANCED | DEFECT | INSUFFICIENT_DATA; local transcript ESTIMATES — catches ATTRIBUTION errors, not pricing errors)
+  dz chain [--project <dir>] [--json]   (verify EVERY hash-chained journal in ONE command: coverage is DERIVED from the CHAINED_JOURNALS registry, never typed, so a journal cannot be given a chain and checked by nobody. An ABSENT journal is NAMED absent, never omitted — omission and cleanliness are indistinguishable in a report. Statuses: ok | healed (defects the current unbroken run has outlived — verdicts over present records are sound) | unchained (present, no chained record yet — legal) | absent | broken | unreadable. Exit 1 on broken/unreadable: a verifier that reports damage and exits 0 is one no automation can act on)
   dz claim-check [paths...] [--json] [--fail-on high|medium|none] [--project <dir>]  (enforce the Integrity Rule: flag untagged/overstated accuracy claims; default scan = root README.md + every discovered package's README.md + features/*/08_qe_report.md + docs/**/*.md (historical feature artifacts are NOT scanned — pass paths explicitly); exit 1 only at/above --fail-on, default high)
   dz lint [paths...] [--json] [--config <file>] [--registry <file>] [--project <dir>]  (advisory EN/RU prose-style lint; findings exit 0, incomplete input/policy exits 1, usage exits 2)
   dz pretrain [--project <dir>]
@@ -717,6 +730,17 @@ Workflows: author loop-plan/1 plans with dz workflow init/validate/render; gate
 Targets: ${TARGET_NAMES.join(', ')}
 Presets: ${PRESET_NAMES.join(', ')}`;
 
+export interface MutationGateRunnerObservation {
+  readonly exitCode: number | null;
+  readonly output: string;
+  readonly failureReason?: string;
+}
+
+export type MutationGateRunner = (
+  command: string,
+  options: { readonly cwd: string; readonly timeoutMs: number },
+) => MutationGateRunnerObservation;
+
 /** Output sink + working directory — injectable so the CLI is testable. */
 export interface CliIo {
   readonly cwd?: string;
@@ -761,6 +785,8 @@ export interface CliIo {
    * offline, hermetically — mirrors the {@link CliIo.releaseRunner} idiom.
    */
   readonly installRunner?: (command: string, cwd: string) => void;
+  /** Fault seam for proving mutation-gate catches and retries thrown runner internals. */
+  readonly mutationGateRunner?: MutationGateRunner;
 }
 
 /** Injected subprocess runner used by `dz release` (see {@link CliIo.releaseRunner}). */
@@ -850,6 +876,12 @@ function discoverSkillsDirs(cwd: string, explicitSkillsDir?: string | undefined)
 
 /** Outcome of {@link installSkills}. */
 interface InstallSkillsResult {
+  /**
+   * Set when an explicit `--select` named an id no root provides (backlog 9d15b9b6, PR-A). The
+   * caller MUST print it and exit non-zero: `0 skill(s)` is not a success, and by the time this is
+   * set nothing has been written yet — the refusal is decided before the first byte.
+   */
+  readonly selectRefusal?: string;
   readonly results: { id: string; written: number; skipped: number }[];
   readonly dirsSearched: number;
   readonly written: number;
@@ -885,11 +917,44 @@ async function installSkills(opts: {
   noIntegrations?: boolean;
   noVerify?: boolean;
   allowIntegrations?: string;
+  writeErr?: (line: string) => void;
 }): Promise<InstallSkillsResult> {
   const { target, projectRoot, cwd, explicitSkillsDir, select, force, enrich } = opts;
 
   const skillsDirs = discoverSkillsDirs(cwd, explicitSkillsDir);
 
+  // PREFLIGHT (backlog 9d15b9b6, PR-A) — resolve the REQUEST once, before anything is written.
+  //
+  // Two defects lived in asking each root independently instead of resolving the request: a skill
+  // present in two roots was installed TWICE and counted twice (the field report's `2 skill(s)` was
+  // one skill installed twice), and a skill present in NO root produced a warning and exit 0 —
+  // `0 skill(s)` reading as success. Both are gone once the decision happens here.
+  //
+  // Placement is load-bearing: an exit 1 that arrives after hooks and memory are written leaves a
+  // half-configured project, which is worse than either clean outcome. This runs before the loop
+  // below and before every target adapter.
+  //
+  // Dependency closure is deliberately NOT resolved here — that is PR-B. This preflight fixes the
+  // count and the exit contract, and gives that work a base it can trust.
+  if (select !== undefined) {
+    const roots = skillsDirs.map((dir) => ({ dir, ids: discoverSkillIds(dir) }));
+    const resolution = resolveSelection(select, roots);
+    for (const shadow of resolution.shadowed) {
+      opts.writeErr?.(
+        `dz: skill '${shadow.id}' is offered by ${shadow.alsoIn.length + 1} roots; ` +
+        `installing from ${shadow.chosen} (earlier root wins). Also present in: ${shadow.alsoIn.join(', ')}`,
+      );
+    }
+    const refusal = formatSelectRefusal(resolution, roots);
+    if (refusal !== null) {
+      return {
+        selectRefusal: refusal,
+        results: [], dirsSearched: skillsDirs.length, written: 0, skipped: 0,
+        missing: [...resolution.missing], failures: [], applyFailures: [], integrations: [],
+      };
+    }
+  }
+
   // agents-md and gemini are FLATTENING single-file targets: each must aggregate
   // every selected skill from ALL discovered dirs into ONE root file (AGENTS.md /
   // GEMINI.md) in a single merge. A per-dir runInit loop (like the tree targets
@@ -1014,6 +1079,7 @@ async function cmdInit(options: Map<string, string>, flags: Set<string>, cwd: st
     cwd,
     explicitSkillsDir,
     select,
+    writeErr,
     force: flags.has('force'),
     enrich: flags.has('enrich'),
     noHooks: flags.has('no-hooks'),
@@ -1022,6 +1088,13 @@ async function cmdInit(options: Map<string, string>, flags: Set<string>, cwd: st
     ...(options.get('allow-integrations') !== undefined ? { allowIntegrations: options.get('allow-integrations')! } : {}),
   });
 
+  // PR-A: an explicit --select that named a skill no root provides is a REFUSAL, not a warning.
+  // Printed and returned here, before any target adapter runs — nothing has been written yet.
+  if (r.selectRefusal !== undefined) {
+    writeErr(r.selectRefusal);
+    return 1;
+  }
+
   // Codex keeps its established user-registry writer, but its result is normalized into the same
   // two-outcome contract before JSON/human rendering. A write without a live ready observation is
   // a refusal with applied=true, never a second success channel.
@@ -5471,6 +5544,26 @@ async function cmdSetup(options: Map<string, string>, flags: Set<string>, cwd: s
   const projectRoot = resolve(cwd, options.get('project') ?? '.');
   const presetName = options.get('preset');
 
+  // PREFLIGHT BEFORE THE FIRST WRITE (backlog 9d15b9b6, PR-A). Step 3 configures the learning
+  // environment and step 4 installs skills, so refusing at step 4 would leave a project that has
+  // memory and hooks but not the skills the operator asked for — a half-configured state worse than
+  // either clean outcome. The request is therefore resolved HERE, before the banner's first step.
+  //
+  // Only an EXPLICIT --select is refused. A preset names skills the package itself ships, so a gap
+  // there is our packaging defect, not the operator's typo, and it is reported by the existing
+  // missing-list rather than by refusing the whole run.
+  const setupSelectRaw = options.get('select');
+  if (setupSelectRaw !== undefined) {
+    const requested = setupSelectRaw.split(',').map((x) => x.trim()).filter((x) => x.length > 0);
+    const roots = discoverSkillsDirs(cwd, options.get('skills-dir')).map((dir) => ({ dir, ids: discoverSkillIds(dir) }));
+    const resolution = resolveSelection(requested, roots);
+    for (const shadow of resolution.shadowed) {
+      writeErr(`dz: skill '${shadow.id}' is offered by ${shadow.alsoIn.length + 1} roots; installing from ${shadow.chosen} (earlier root wins). Also present in: ${shadow.alsoIn.join(', ')}`);
+    }
+    const refusal = formatSelectRefusal(resolution, roots);
+    if (refusal !== null) { writeErr(refusal); return 1; }
+  }
+
   write(`\n╔══════════════════════════════════════════════════════╗`);
   write(`║           DZ SETUP — Full Environment                ║`);
   write(`╠══════════════════════════════════════════════════════╣`);
@@ -5622,7 +5715,7 @@ function cmdPretrain(options: Map<string, string>, cwd: string, write: Write): n
   return 0;
 }
 
-function cmdRecommend(options: Map<string, string>, cwd: string, write: Write): number {
+function cmdRecommend(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
   const task = options.get('_positional_0');
   if (!task) {
     write('dz recommend: task description required');
@@ -5632,17 +5725,41 @@ function cmdRecommend(options: Map<string, string>, cwd: string, write: Write):
 
   const registry = buildRegistry(cwd);
   const report = recommend(task, registry, cwd);
+  if (flags.has('json')) {
+    write(JSON.stringify(report, null, 2));
+    return 0;
+  }
 
   write(`\n╔══════════════════════════════════════════════════════════════╗`);
   write(`║                 DZ RECOMMEND — Task Advisor                 ║`);
   write(`╠══════════════════════════════════════════════════════════════╣`);
   write(`║  Task: ${report.task.slice(0, 52).padEnd(52)}║`);
-  const topicSuffix = report.pretrainFallback ? ' (via pretrain)' : '';
-  write(`║  Topics: ${(report.topics.join(', ') + topicSuffix).slice(0, 50).padEnd(50)}║`);
+  if (report.topicSource === 'task') {
+    write(`║  Topics: ${report.topics.join(', ').slice(0, 50).padEnd(50)}║`);
+  } else if (report.topicSource === 'project-stack') {
+    write(`║  Topics: ${'not matched in the question'.padEnd(50)}║`);
+  } else {
+    write(`║  Topics: ${'not recognized — no recommendations'.padEnd(50)}║`);
+  }
   write(`╠══════════════════════════════════════════════════════════════╣`);
 
+  if (report.topicSource === 'project-stack') {
+    write(`⚠ Тема запроса не распознана — подбор ниже сделан по СТЕКУ ПРОЕКТА, не по вашему вопросу.`);
+    write(`  (topic not recognized — recommendations reflect the project stack, not the question)`);
+    write(`PROJECT-STACK SUGGESTIONS`);
+  } else if (report.topicSource === 'none') {
+    write(`Тема запроса не распознана; рекомендаций нет.`);
+    write(`Переформулируйте задачу или используйте dz registry search <слово> / /skill-advisor.`);
+    write(`╚══════════════════════════════════════════════════════════════╝`);
+    return 0;
+  }
+
+  const stackDerived = report.topicSource === 'project-stack';
+
   if (report.presets.length > 0) {
-    write(`║  RECOMMENDED PRESETS                                        ║`);
+    write(stackDerived
+      ? `║  PROJECT-STACK PRESETS                                      ║`
+      : `║  RECOMMENDED PRESETS                                        ║`);
     for (const p of report.presets) {
       const matched = p.matchedSkills.length > 0 ? ` (${p.matchedSkills.slice(0, 3).join(', ')})` : '';
       write(`║    ${p.name.padEnd(15)} ${String(p.skills).padStart(2)} skills  coverage: ${String(p.coverage).padStart(2)} topics${matched.padEnd(15)}║`);
@@ -5651,7 +5768,9 @@ function cmdRecommend(options: Map<string, string>, cwd: string, write: Write):
   }
 
   if (report.skills.length > 0) {
-    write(`║  RECOMMENDED SKILLS (top ${Math.min(report.skills.length, 8)})${' '.repeat(35)}║`);
+    write(stackDerived
+      ? `║  PROJECT-STACK SKILLS (top ${Math.min(report.skills.length, 8)})${' '.repeat(35)}║`
+      : `║  RECOMMENDED SKILLS (top ${Math.min(report.skills.length, 8)})${' '.repeat(35)}║`);
     for (const s of report.skills.slice(0, 8)) {
       const desc = s.description.length > 35 ? s.description.slice(0, 32) + '...' : s.description;
       write(`║    ${s.id.padEnd(24)} ${desc.padEnd(36)}║`);
@@ -5660,7 +5779,9 @@ function cmdRecommend(options: Map<string, string>, cwd: string, write: Write):
   }
 
   if (report.toolkits.length > 0) {
-    write(`║  FULL PIPELINE (npx toolkits)                               ║`);
+    write(stackDerived
+      ? `║  PROJECT-STACK PIPELINE (npx toolkits)                      ║`
+      : `║  FULL PIPELINE (npx toolkits)                               ║`);
     for (const tk of report.toolkits) {
       const desc = tk.description.length > 44 ? tk.description.slice(0, 41) + '...' : tk.description;
       write(`║    ${tk.name.padEnd(16)} ${desc.padEnd(44)}║`);
@@ -5671,13 +5792,17 @@ function cmdRecommend(options: Map<string, string>, cwd: string, write: Write):
   }
 
   write(`╠══════════════════════════════════════════════════════════════╣`);
-  write(`║  STEP-BY-STEP PLAN                                         ║`);
+  write(stackDerived
+    ? `║  PROJECT-STACK PLAN                                         ║`
+    : `║  STEP-BY-STEP PLAN                                         ║`);
   for (const step of report.plan) {
     const line = step.length > 60 ? step.slice(0, 57) + '...' : step;
     write(`║    ${line.padEnd(58)}║`);
   }
   write(`╠══════════════════════════════════════════════════════════════╣`);
-  write(`║  QUICK INSTALL                                              ║`);
+  write(stackDerived
+    ? `║  PROJECT-STACK QUICK INSTALL                                ║`
+    : `║  QUICK INSTALL                                              ║`);
   const cmd = report.installCommand.length > 58 ? report.installCommand.slice(0, 55) + '...' : report.installCommand;
   write(`║    ${cmd.padEnd(58)}║`);
   write(`╚══════════════════════════════════════════════════════════════╝`);
@@ -7426,6 +7551,84 @@ function looksBinaryText(text: string): boolean {
  * per-file findings (each enriched with its `file`), and applies the exit-code contract.
  * `--json` ALWAYS emits valid JSON `{ok, findings, scanned}`, even on the failure path.
  */
+/**
+ * `dz chain` — verify EVERY hash-chained journal in one command (W0-chain, backlog bc4ee35c).
+ *
+ * The machinery to verify a chain has worked for weeks. What was missing is the ABILITY TO ASK:
+ * verification lived inside two consumers, each carrying its own hardcoded list of which files are
+ * chained, so a journal could be given a chain and still be checked by nobody. Coverage here is
+ * DERIVED from CHAINED_JOURNALS, never typed — adding a journal to the registry adds it to this
+ * report by construction.
+ *
+ * An ABSENT journal is reported as `absent`, not omitted. Omission and cleanliness are
+ * indistinguishable in a report, and that indistinguishability is how the original blind spot
+ * survived; the same reason `broken` exits NON-ZERO rather than merely printing — a verifier that
+ * reports damage and exits 0 is one no automation can act on, and this verb exists to run unattended.
+ *
+ * A journal that exists but carries NO chained records is `unchained`, which is legal (a log may
+ * predate the chain) and therefore does not fail the command. Calling it a defect would train the
+ * reader to ignore the output — the failure mode already measured once on the doctor's own line.
+ */
+function cmdChain(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  const root = options.get('project') ?? cwd;
+  const journals = CHAINED_JOURNALS.map((journal) => {
+    const path = join(root, journal.rel);
+    if (!existsSync(path)) {
+      return { rel: journal.rel, decides: journal.decides, status: 'absent' as const, chained: 0, defects: 0, detail: 'file not present' };
+    }
+    let text = '';
+    try {
+      text = readFileSync(path, 'utf-8');
+    } catch {
+      // Unreadable is NOT clean. It is the one outcome that must never be quietly folded into
+      // "nothing to report": we did not look, so we know nothing.
+      return { rel: journal.rel, decides: journal.decides, status: 'unreadable' as const, chained: 0, defects: 0, detail: 'file could not be read' };
+    }
+    const v = verifyEventChainText(text);
+    if (v.chained === 0) {
+      return { rel: journal.rel, decides: journal.decides, status: 'unchained' as const, chained: 0, defects: 0, detail: 'present, but no record carries a chain (legal — the log predates chaining)' };
+    }
+    const total = text.split('\n').filter((l) => l.trim() !== '').length;
+    const age = classifyChainDefects(v, total);
+    if (v.ok) {
+      return { rel: journal.rel, decides: journal.decides, status: 'ok' as const, chained: v.chained, defects: 0, detail: `${v.chained} chained record(s), ${v.resets} recorded restart(s)` };
+    }
+    // A break the current unbroken run has already outlived does not make TODAY's records unsound.
+    // Reporting both alike is what made the doctor's equivalent line permanently red for four weeks.
+    const historical = age.inRun.length === 0 && age.runRecords > 0;
+    return {
+      rel: journal.rel,
+      decides: journal.decides,
+      status: historical ? ('healed' as const) : ('broken' as const),
+      chained: v.chained,
+      defects: v.defects.length,
+      detail: historical
+        ? `${v.defects.length} defect(s), all BEFORE the current run — the last ${age.runRecords} record(s) are unbroken, so verdicts over those are sound`
+        : `${v.defects.length} defect(s) with NO sound records after them: verdicts computed from this log are unsafe`,
+    };
+  });
+
+  const failed = journals.filter((j) => j.status === 'broken' || j.status === 'unreadable');
+  const ok = failed.length === 0;
+
+  if (flags.has('json')) {
+    write(JSON.stringify({ ok, root, journals }, null, 2));
+    return ok ? 0 : 1;
+  }
+
+  write(`dz chain — ${journals.length} registered journal(s) under ${root}`);
+  write('');
+  const MARK: Record<string, string> = { ok: '\u2713', healed: '\u2713', unchained: '\u00b7', absent: '\u00b7', broken: '\u2717', unreadable: '\u2717' };
+  for (const j of journals) {
+    write(`  ${MARK[j.status] ?? '?'} ${j.rel} — ${j.status}`);
+    write(`      ${j.detail}`);
+    write(`      decides: ${j.decides}`);
+  }
+  write('');
+  write(ok ? '  all registered journals are sound for present verdicts' : `  ${failed.length} journal(s) UNSAFE — see above`);
+  return ok ? 0 : 1;
+}
+
 function cmdClaimCheck(
   options: Map<string, string>,
   _optionLists: Map<string, string[]>,
@@ -10098,9 +10301,74 @@ function cmdDiscriminationCheck(options: Map<string, string>, flags: Set<string>
   const timeoutOpt = Number(options.get('timeout') ?? '300000');
   const timeoutMs = Number.isFinite(timeoutOpt) && timeoutOpt > 0 ? timeoutOpt : 300000;
 
-  const plan = planDiscriminationCheck(runnerOpt !== undefined ? { baseRef, propertyTests, runner: runnerOpt } : { baseRef, propertyTests });
+  // Runner honesty (feature instrument-honesty, ADR-001): the runner is selected from the TARGET
+  // package's own scripts.test, never from a global default. The package dir is the nearest
+  // ancestor of the FIRST named test that carries a package.json — walked here, at the seam,
+  // because the pure half deliberately takes the script text as data and never touches the fs.
+  let packageTestScript: string | null = null;
+  let packageDevDependencies: string[] = [];
+  let packageDir = repoRoot;
+  {
+    const firstTest = propertyTests[0]?.file;
+    // QE-1 (instrument-honesty, HIGH): this walk runs on the RAW --test argument, BEFORE the
+    // engine's sanitation — a `../` traversal made it read an arbitrary package.json OUTSIDE the
+    // repo and echo its scripts.test verbatim into the JSON output (MEASURED with a planted
+    // marker file). Containment first: a start point outside the repo root never gets walked,
+    // the script stays null, and the engine's own path sanitation then refuses the test path.
+    const walkStart = firstTest !== undefined ? resolve(cwd, dirname(firstTest)) : undefined;
+    if (firstTest !== undefined && walkStart !== undefined
+      && (walkStart === resolve(repoRoot) || walkStart.startsWith(resolve(repoRoot) + sep))) {
+      let probe = walkStart;
+      // walk up to the repo root looking for package.json (bounded by the fs root either way)
+      for (;;) {
+        if (existsSync(join(probe, 'package.json'))) { packageDir = probe; break; }
+        const parent = dirname(probe);
+        if (parent === probe || probe === repoRoot) break;
+        probe = parent;
+      }
+      try {
+        const pkg = JSON.parse(readFileSync(join(packageDir, 'package.json'), 'utf-8')) as {
+          scripts?: Record<string, string>; devDependencies?: Record<string, string>;
+        };
+        packageTestScript = typeof pkg.scripts?.test === 'string' ? pkg.scripts.test : null;
+        packageDevDependencies = Object.keys(pkg.devDependencies ?? {});
+      } catch { /* unreadable package.json → selection falls through to the honest REFUSE */ }
+    }
+  }
+  // The pure half's path sanitation expects a REPO-RELATIVE package dir ('.'-rooted), not an
+  // absolute one — an absolute path is refused as unsafe-package-dir by design.
+  const packageDirRel = relative(repoRoot, packageDir) || '.';
+  const planInput = runnerOpt !== undefined
+    ? { baseRef, propertyTests, runner: runnerOpt, packageTestScript, packageDevDependencies, packageDir: packageDirRel }
+    : { baseRef, propertyTests, packageTestScript, packageDevDependencies, packageDir: packageDirRel };
+  const plan = planDiscriminationCheck(planInput);
 
   if (!plan.runnable) {
+    // QE-2 (instrument-honesty, MEDIUM): a runner REFUSE used to be reported through the generic
+    // "no property test to check"/map-a-test framing — the operator-facing surface re-created the
+    // exact "instrument gap misread as test gap" class ADR-001 names as the reason three duplicate
+    // backlog entries existed. The plan's own named reason is the verdict; the generic classify
+    // stays only for the genuinely-empty-target case.
+    const runnerRefusal = typeof plan.reason === 'string' && plan.reason.startsWith('unsupported-runner');
+    if (runnerRefusal) {
+      const refusal = {
+        aggregate: 'CANNOT_ISOLATE',
+        measurementValid: false,
+        primaryAction: plan.primaryAction ?? 'fix-runner-invocation',
+        finding: {
+          severity: 'high',
+          verdict: 'CANNOT_ISOLATE',
+          files: plan.targets.map((t) => t.file),
+          detail: `runner refused: ${plan.reason} — the INSTRUMENT could not run, nothing was measured; `
+            + `declare scripts.test in the target package (or pass --runner) and re-run. `
+            + `This is NOT a statement about the tests.`,
+        },
+      };
+      if (flags.has('json')) { write(JSON.stringify({ plan, results: [], perTest: [], ...refusal }, null, 2)); return 0; }
+      write(`discrimination-check: REFUSED (${plan.reason})`);
+      write(`  → ${refusal.finding.detail}`);
+      return 0;
+    }
     // No safe target to run → this is the existing "property untested" finding (empty propertyTests classify).
     const result = classifyDiscrimination({ propertyTests: [], results: [] });
     if (flags.has('json')) { write(JSON.stringify({ plan, results: [], ...result }, null, 2)); return 0; }
@@ -10189,10 +10457,24 @@ function cmdDiscriminationCheck(options: Map<string, string>, flags: Set<string>
 
         // t.file + t.name already passed the engine's strict sanitation (no quotes/metacharacters/leading-dash);
         // still quote + `--` so a path can never be read as a runner option or split a word.
+        // Runner honesty (ADR-001): the run executes FROM the target package dir with a
+        // package-relative path — a root-cwd `npx vitest run packages/...` loads the ROOT config
+        // (none) and reds unclassifiably, which is exactly the CANNOT_ISOLATE artifact this
+        // feature removes. The plan's own commands encode the same cd; this body mirrors it.
+        const pkgRel = plan.packageDir === '.' ? '' : plan.packageDir;
+        const fileInPkg = pkgRel !== '' && t.file.startsWith(pkgRel + '/') ? t.file.slice(pkgRel.length + 1) : t.file;
+        const execDirBase = pkgRel === '' ? worktree : join(worktree, pkgRel);
+        const execDirTip = pkgRel === '' ? repoRoot : join(repoRoot, pkgRel);
         const nameArg = t.name ? ` -t '${t.name}'` : '';
-        const cmd = `${runner}${nameArg} -- '${t.file}'`;
-        const base = runCapturedTest(cmd, worktree, timeoutMs);
-        const evidence = classifyExecutionEvidence(base.output, base.exitCode, t.file);
+        // NO `--` before the path: MEASURED 2026-09-02 — `npx vitest run -- 'file'` IGNORES the
+        // filter and runs the whole suite (5269 tests), which is the exact whole-repo artifact
+        // this feature removes (QE ha-intake-archive F5). The path is engine-sanitized (no
+        // leading dash, no metacharacters), so it can never be read as an option.
+        const cmd = `${runner}${nameArg} '${fileInPkg}'`;
+        const base = runCapturedTest(cmd, execDirBase, timeoutMs);
+        // The classifier's targetSeen is a substring probe: the run now prints PACKAGE-relative
+        // paths, so it must be probed with the same form, or every hit reads as target-unseen.
+        const evidence = classifyExecutionEvidence(base.output, base.exitCode, fileInPkg);
         const outcome = discriminationOutcomeOf(base.exitCode, evidence);
         const row: Record<string, unknown> = t.name !== undefined
           ? { file: t.file, name: t.name, outcome, evidence }
@@ -10204,8 +10486,8 @@ function cmdDiscriminationCheck(options: Map<string, string>, flags: Set<string>
         // base rows per the matrix; running it is cheap and only ever on an already-broken path.
         // Do NOT "simplify" this to evidenced-error-only — that silently breaks Confirmation 17.
         if (base.exitCode !== null && base.exitCode !== 0 && evidence.failureKind !== 'assertions') {
-          const tip = runCapturedTest(cmd, repoRoot, timeoutMs);
-          const tipEvidence = classifyExecutionEvidence(tip.output, tip.exitCode, t.file);
+          const tip = runCapturedTest(cmd, execDirTip, timeoutMs);
+          const tipEvidence = classifyExecutionEvidence(tip.output, tip.exitCode, fileInPkg);
           row['tipOutcome'] = discriminationOutcomeOf(tip.exitCode, tipEvidence);
           row['tipEvidence'] = tipEvidence;
           // R15, named honestly: the base run is isolated in a worktree, but the tip runs in the LIVE
@@ -10329,9 +10611,9 @@ function nameFor(t: { file: string; name?: string }, outcome: 'pass' | 'fail' |
  *
  * Exit codes: 0 every entry PROVEN · 1 the gate ran and failed (undefended / not-applied /
  * below-min / unparseable / load-fatal / over-failing / inconclusive entry) · 2 usage or setup
- * error (missing registry, red BASELINE — a red unmutated copy proves nothing and must not be
- * read as a mutation result — or an entry whose file RESOLVES outside the scratch copy: a
+ * error (missing registry or an entry whose file RESOLVES outside the scratch copy: a
  * symlink escape is refused before anything is written, SPEC rule 3).
+ * A RED/no-exit baseline is a measured failing verdict (exit 1), never a usage error.
  */
 /**
  * Route-a guard for `dz mutation-gate`: parse-check a MUTATED file as its own language BEFORE the
@@ -10340,7 +10622,14 @@ function nameFor(t: { file: string; name?: string }, outcome: 'pass' | 'fail' |
  * redness says nothing about the named protection. Returns `{error}` when a parser ran and the
  * text does not parse; `{skipped}` (reported loudly, never silently) when no parser is available.
  */
-function parseCheckMutatedFile(absFile: string, text: string): { error?: string; skipped?: string } {
+interface MutationParseCheckResult {
+  readonly error?: string;
+  readonly skipped?: string;
+  readonly internalFailureReason?: string;
+  readonly internalAttempts?: ReturnType<typeof runWithOneInternalRetry>['attempts'];
+}
+
+function parseCheckMutatedFile(absFile: string, text: string): MutationParseCheckResult {
   interface TsLike {
     transpileModule(t: string, o: { reportDiagnostics: boolean; compilerOptions: Record<string, unknown> }): { diagnostics?: { category: number; code: number; messageText: unknown }[] };
     flattenDiagnosticMessageText(m: unknown, s: string): string;
@@ -10364,17 +10653,34 @@ function parseCheckMutatedFile(absFile: string, text: string): { error?: string;
       try { JSON.parse(text); return {}; } catch (e) { return { error: String((e as Error).message).slice(0, 200) }; }
     }
     if (ext === '.js' || ext === '.cjs' || ext === '.mjs' || ext === '') {
-      try {
-        // `node --check` on the file IN PLACE, so the nearest package.json decides the module goal.
-        execFileSync(process.execPath, ['--check', absFile], { stdio: 'pipe' });
-        return {};
-      } catch (e) {
-        const err = e as { stderr?: Buffer | string };
-        const stderrLines = String(err.stderr ?? '').split('\n').map((l) => l.trim()).filter((l) => l !== '');
-        // prefer the actual `SyntaxError: …` line over node's trailing version footer.
-        const msg = [...stderrLines].reverse().find((l) => l.includes('Error')) ?? stderrLines.at(-1) ?? 'node --check failed';
-        return { error: msg.slice(0, 200) };
+      const checked = runWithOneInternalRetry<MutationParseCheckResult>(() => {
+        try {
+          // `node --check` on the file IN PLACE, so the nearest package.json decides the module goal.
+          execFileSync(process.execPath, ['--check', absFile], { stdio: 'pipe' });
+          return {};
+        } catch (e) {
+          const err = e as { code?: unknown; status?: unknown; stderr?: Buffer | string; message?: string };
+          // A launched parser that exits non-zero with a SyntaxError is a parse verdict. A child
+          // launch/internal error (EPERM, ENOENT, Node's thrown internal) is runner infrastructure
+          // and must take the bounded retry → INCONCLUSIVE route instead of masquerading as bad JS.
+          if (typeof err.code === 'string' || typeof err.status !== 'number') throw e;
+          const stderrLines = String(err.stderr ?? '').split('\n').map((line) => line.trim()).filter((line) => line !== '');
+          const msg = [...stderrLines].reverse().find((line) => line.includes('Error'))
+            ?? stderrLines.at(-1)
+            ?? err.message
+            ?? 'node --check failed';
+          return { error: msg.slice(0, 200) };
+        }
+      });
+      if (checked.value === null) {
+        return {
+          internalFailureReason: checked.failureReason ?? 'runner-internal-error: persistent after 2/2 attempts',
+          internalAttempts: checked.attempts,
+        };
       }
+      return checked.internalRetries === 1
+        ? { ...checked.value, internalAttempts: checked.attempts }
+        : checked.value;
     }
     return { skipped: `no parser for '${ext}' files — parse-check unavailable` };
   } catch (e) {
@@ -10382,7 +10688,13 @@ function parseCheckMutatedFile(absFile: string, text: string): { error?: string;
   }
 }
 
-function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+function cmdMutationGate(
+  options: Map<string, string>,
+  flags: Set<string>,
+  cwd: string,
+  write: Write,
+  injectedRunner?: MutationGateRunner,
+): number {
   const json = flags.has('json');
   const fail = (what: string): number => {
     write(json ? JSON.stringify({ error: what, exitCode: 2 }) : `dz mutation-gate: ${what}`);
@@ -10453,6 +10765,11 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
   const results: MutationEntryResult[] = [];
   const observations: MutationObservation[] = [];
   const warnings: string[] = [];
+  const internalRetries: {
+    readonly phase: 'baseline' | 'parse-check' | 'mutation' | 'rebaseline' | 'final-rebaseline';
+    readonly entryId?: string;
+    readonly attempts: ReturnType<typeof runWithOneInternalRetry>['attempts'];
+  }[] = [];
   let baseline: ReturnType<typeof classifyBaseline>;
   try {
     if (gitTop !== null && gitTop !== pkgDir && resolve(pkgDir).startsWith(resolve(gitTop) + sep)) {
@@ -10492,7 +10809,11 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
     const realScratchRoot = realpathSync(copyDir);
     const requireCompletionReceipt = parsed.registry.requireCompletionReceipt === true;
 
-    const runSuite = (): { exitCode: number | null; output: string; failureReason?: string } => {
+    type SuiteRun = MutationGateRunnerObservation & { readonly internalAttemptLog?: string };
+    const invokeSuite = (): MutationGateRunnerObservation => {
+      if (injectedRunner !== undefined) {
+        return injectedRunner(testCmd, { cwd: copyDir, timeoutMs: timeout });
+      }
       const run = spawnSync(testCmd, {
         cwd: copyDir,
         shell: true,
@@ -10504,6 +10825,12 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
       const errorCode = run.error && 'code' in run.error && typeof run.error.code === 'string'
         ? run.error.code
         : undefined;
+      // Node may populate both `error` and a numeric `status` for an internal spawn failure. The
+      // error wins except for the two already-named resource observations: a status alongside
+      // EPERM/Unreachable-code is not a suite verdict and takes the one-retry internal-error path.
+      if (run.error !== undefined && errorCode !== 'ETIMEDOUT' && errorCode !== 'ENOBUFS') {
+        throw run.error;
+      }
       const signal = typeof run.signal === 'string' ? run.signal : undefined;
       let failureReason: string | undefined;
       if (typeof run.status !== 'number') {
@@ -10515,22 +10842,62 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
       }
       return {
         exitCode: typeof run.status === 'number' ? run.status : null,
-        // Receipt markers may be on stderr. Preserve both streams even on exit 0; stdout-only
-        // collection would silently lose a green-run marker.
         output: `${String(run.stdout ?? '')}\n${String(run.stderr ?? '')}`,
         ...(failureReason !== undefined ? { failureReason } : {}),
       };
     };
 
+    const runSuite = (
+      phase: 'baseline' | 'mutation' | 'rebaseline' | 'final-rebaseline',
+      entryId?: string,
+    ): SuiteRun => {
+      const retried = runWithOneInternalRetry(invokeSuite);
+      const loggedAttempts = retried.attempts.map((attempt) => {
+        if (attempt.outcome !== 'completed' || retried.value === null) return attempt;
+        const outcome = retried.value.exitCode === null
+          ? `no exit code (${retried.value.failureReason ?? 'unnamed failure'})`
+          : `exit ${retried.value.exitCode}`;
+        return { ...attempt, detail: `attempt ${attempt.attempt}: completed — ${outcome}` };
+      });
+      if (retried.internalRetries === 1) {
+        const record = entryId === undefined
+          ? { phase, attempts: loggedAttempts }
+          : { phase, entryId, attempts: loggedAttempts };
+        internalRetries.push(record);
+        if (!json) write(`mutation-gate: internal retry — ${loggedAttempts.map((attempt) => attempt.detail).join('; ')}`);
+      }
+      const internalAttemptLog = retried.internalRetries === 1
+        ? loggedAttempts.map((attempt) => attempt.detail).join('; ')
+        : undefined;
+      if (retried.value !== null) {
+        return {
+          ...retried.value,
+          ...(internalAttemptLog !== undefined ? { internalAttemptLog } : {}),
+        };
+      }
+      return {
+        exitCode: null,
+        output: '',
+        failureReason: retried.failureReason ?? 'runner-internal-error: persistent after 2/2 attempts',
+        ...(internalAttemptLog !== undefined ? { internalAttemptLog } : {}),
+      };
+    };
+
     // Baseline BEFORE any mutation: a red copy proves nothing, and reading it as a mutation
     // result would be this gate shipping the defect class it exists to catch.
     if (!json) write(`mutation-gate: baseline suite in scratch copy of ${pkgDir} …`);
-    const base = runSuite();
-    baseline = classifyBaseline(base.exitCode, base.failureReason);
+    const base = runSuite('baseline');
+    baseline = classifyBaseline(
+      base.exitCode,
+      base.failureReason,
+      base.exitCode !== null && base.exitCode !== 0
+        ? attributeBaselineRedness(base.output, entries.map((entry) => entry.file))
+        : undefined,
+    );
     if (!baseline.ok) {
-      if (json) { write(JSON.stringify({ packageDir: pkgDir, registryPath, testCommand: testCmd, baseline, results: [], exitCode: 2 }, null, 2)); return 2; }
+      if (json) { write(JSON.stringify({ packageDir: pkgDir, registryPath, testCommand: testCmd, baseline, results: [], internalRetries, exitCode: 1 }, null, 2)); return 1; }
       write(renderMutationReport([], baseline, pkgDir));
-      return 2;
+      return 1;
     }
 
     for (const entry of entries) {
@@ -10565,8 +10932,10 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
         return fail(`entry '${entry.id}': ${entry.file} resolves to ${realTarget ?? '<unresolvable>'} — OUTSIDE the scratch copy (${realScratchRoot}). A path component is a symlink escaping the scratch tree, so writing the mutation would mutate the REAL working tree (SPEC rule 3). Refused; nothing was written.`);
       }
       if (!json) write(`mutation-gate: ${entry.id} — mutating ${entry.file}, running suite …`);
-      let run: { exitCode: number | null; output: string; failureReason?: string } | null = null;
+      let run: SuiteRun | null = null;
       let parseError: string | undefined;
+      let parseInternalFailureReason: string | undefined;
+      let parseInternalAttemptLog: string | undefined;
       try {
         writeFileSync(filePath, applied.text);
         // Route-a guard: the mutated file must still PARSE — a load failure reddens the whole
@@ -10576,10 +10945,16 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
           warnings.push(`${entry.id}: parse-check SKIPPED — ${check.skipped}`);
           if (!json) write(`mutation-gate: WARNING ${entry.id}: parse-check skipped — ${check.skipped}`);
         }
+        if (check.internalAttempts !== undefined) {
+          internalRetries.push({ phase: 'parse-check', entryId: entry.id, attempts: check.internalAttempts });
+          parseInternalAttemptLog = check.internalAttempts.map((attempt) => attempt.detail).join('; ');
+          if (!json) write(`mutation-gate: internal retry — ${parseInternalAttemptLog}`);
+        }
+        parseInternalFailureReason = check.internalFailureReason;
         if (check.error !== undefined) {
           parseError = check.error; // no suite run: the verdict is MUTATION_UNPARSEABLE regardless
-        } else {
-          run = runSuite();
+        } else if (parseInternalFailureReason === undefined) {
+          run = runSuite('mutation', entry.id);
         }
       } finally {
         writeFileSync(filePath, sourceText); // restore the COPY so the next entry starts pristine
@@ -10613,13 +10988,26 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
       // those verdicts outrank the rebaseline check, so the extra suite run would buy nothing.
       let rebaselineExitCode: number | null | undefined;
       let rebaselineFailureReason: string | undefined;
+      let rebaselineAttribution: ReturnType<typeof attributeBaselineRedness> | undefined;
+      let rebaselineInternalAttemptLog: string | undefined;
       if (rebaselineMode === 'per-entry' && run !== null && run.exitCode !== null && run.exitCode !== 0
         && fileLoadFailure === undefined && outputUnrecognised === undefined && receiptMismatch === undefined) {
         if (!json) write(`mutation-gate: ${entry.id} — re-baselining the restored tree …`);
-        const rebaselineRun = runSuite();
+        const rebaselineRun = runSuite('rebaseline', entry.id);
         rebaselineExitCode = rebaselineRun.exitCode;
         rebaselineFailureReason = rebaselineRun.failureReason;
+        rebaselineInternalAttemptLog = rebaselineRun.internalAttemptLog;
+        if (rebaselineRun.exitCode !== null && rebaselineRun.exitCode !== 0) {
+          rebaselineAttribution = attributeBaselineRedness(
+            rebaselineRun.output,
+            entries.map((candidate) => candidate.file),
+          );
+        }
       }
+      const entryRunFailureReason = run?.failureReason ?? parseInternalFailureReason;
+      const entryInternalAttemptLog = [parseInternalAttemptLog, run?.internalAttemptLog, rebaselineInternalAttemptLog]
+        .filter((log): log is string => log !== undefined)
+        .join('; ');
       const obs: MutationObservation = {
         entry,
         occurrences: 1,
@@ -10629,9 +11017,11 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
         ...(fileLoadFailure !== undefined ? { fileLoadFailure } : {}),
         ...(outputUnrecognised !== undefined ? { outputUnrecognised } : {}),
         ...(receiptMismatch !== undefined ? { receiptMismatch } : {}),
-        ...(run?.failureReason !== undefined ? { runFailureReason: run.failureReason } : {}),
+        ...(entryRunFailureReason !== undefined ? { runFailureReason: entryRunFailureReason } : {}),
+        ...(entryInternalAttemptLog !== '' ? { internalAttemptLog: entryInternalAttemptLog } : {}),
         ...(rebaselineExitCode !== undefined ? { rebaselineExitCode } : {}),
         ...(rebaselineFailureReason !== undefined ? { rebaselineFailureReason } : {}),
+        ...(rebaselineAttribution !== undefined ? { rebaselineAttribution } : {}),
       };
       observations.push(obs);
       results.push(classifyMutationOutcome(obs));
@@ -10644,7 +11034,7 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
     // MUTATION_LOAD_FATAL / RECEIPT_MISMATCH untouched.
     if (rebaselineMode === 'final') {
       if (!json) write('mutation-gate: final re-baseline of the restored tree …');
-      const finalRun = runSuite();
+      const finalRun = runSuite('final-rebaseline');
       const finalExit = finalRun.exitCode;
       if (finalExit !== 0) {
         const what = finalExit === null ? `no exit code: ${finalRun.failureReason ?? 'unknown timeout / spawn failure'}` : `exit ${finalExit}`;
@@ -10654,6 +11044,12 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
           ...obs,
           rebaselineExitCode: finalExit,
           ...(finalRun.failureReason !== undefined ? { rebaselineFailureReason: finalRun.failureReason } : {}),
+          ...(finalRun.internalAttemptLog !== undefined
+            ? { internalAttemptLog: [obs.internalAttemptLog, finalRun.internalAttemptLog].filter((log): log is string => log !== undefined).join('; ') }
+            : {}),
+          ...(finalExit !== null && finalExit !== 0
+            ? { rebaselineAttribution: attributeBaselineRedness(finalRun.output, entries.map((entry) => entry.file)) }
+            : {}),
         }));
         results.length = 0;
         results.push(...reclassified);
@@ -10669,7 +11065,7 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
 
   const exitCode = mutationGateExitCode(results, baseline.ok);
   if (json) {
-    write(JSON.stringify({ packageDir: pkgDir, registryPath, testCommand: testCmd, rebaselineMode, baseline, results, summary: summarizeMutationResults(results), warnings, exitCode }, null, 2));
+    write(JSON.stringify({ packageDir: pkgDir, registryPath, testCommand: testCmd, rebaselineMode, baseline, results, summary: summarizeMutationResults(results), warnings, internalRetries, exitCode }, null, 2));
     return exitCode;
   }
   write(renderMutationReport(results, baseline, pkgDir));
@@ -12382,6 +12778,13 @@ function cmdFeatureAdrRecord(options: Map<string, string>, flags: Set<string>, c
     targetExists: existsSync(target),
     targetHasPair: flags.has('once') && existsSync(target),
     timestamp: new Date().toISOString(),
+    // WHO ran it: `--runner <id>` when the caller knows, otherwise this host. The workflow cannot
+    // supply it — it has no host inside its sandbox — so the identity is resolved here, at the one
+    // seam that runs outside. hostname() can throw on an exotic setup; an unresolvable runner stays
+    // ABSENT rather than becoming the string 'unknown', which would later join as if it were one.
+    runnerId: (options.get('runner') ?? '').trim() !== ''
+      ? (options.get('runner') ?? '').trim()
+      : (() => { try { return hostname(); } catch { return null; } })(),
   });
   if (decision.line === null) return emit(decision);
 
@@ -13777,6 +14180,145 @@ async function cmdQeBridge(options: Map<string, string>, flags: Set<string>, cwd
 }
 
 
+interface ScoreReceiptFile {
+  readonly path: string;
+  readonly displayPath: string;
+  readonly qeHash: string;
+}
+
+function scoreReceiptFiles(root: string): ScoreReceiptFile[] {
+  const featuresDir = join(root, 'features');
+  let features: Dirent[];
+  try {
+    features = readdirSync(featuresDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const receipts: ScoreReceiptFile[] = [];
+  for (const feature of features) {
+    if (!feature.isDirectory()) continue;
+    const stateDir = join(featuresDir, feature.name, '.fa-state');
+    let entries: Dirent[];
+    try {
+      if (lstatSync(stateDir).isSymbolicLink()) continue;
+      entries = readdirSync(stateDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const match = /^score-(.+)\.json$/.exec(entry.name);
+      if (match === null || match[1] === undefined || match[1] === '') continue;
+      const path = join(stateDir, entry.name);
+      receipts.push({ path, displayPath: relative(root, path), qeHash: match[1] });
+    }
+  }
+  return receipts.sort((a, b) => a.displayPath < b.displayPath ? -1 : a.displayPath > b.displayPath ? 1 : 0);
+}
+
+function scoreAggregateChainLine(text: string): {
+  readonly line: string;
+  readonly verification: ReturnType<typeof verifyEventChainText> | null;
+  readonly defectAges: ReturnType<typeof classifyChainDefects> | null;
+} {
+  if (text === '') {
+    return { line: 'chain: NOT_PRESENT — no aggregate evidence file was created', verification: null, defectAges: null };
+  }
+  const verification = verifyEventChainText(text);
+  const defectAges = classifyChainDefects(verification, verification.lines);
+  const kinds = new Map<string, number>();
+  for (const defect of verification.defects) kinds.set(defect.kind, (kinds.get(defect.kind) ?? 0) + 1);
+  const kindText = [...kinds.entries()].map(([kind, count]) => `${kind}: ${count}`).join(' · ');
+  const line =
+    `chain: ${verification.ok ? 'OK' : 'FAILED'} · ${verification.chained} chained · ` +
+    `${verification.resets} recorded restart(s) · before-run defects ${defectAges.beforeRun.length} · ` +
+    `in-run defects ${defectAges.inRun.length} · current run ${defectAges.runRecords} record(s)` +
+    (kindText === '' ? '' : ` · ${kindText}`) +
+    ` — ${verification.scope}`;
+  return { line, verification, defectAges };
+}
+
+function cmdScoreAll(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  const json = flags.has('json');
+  if (options.has('slug')) {
+    write(json
+      ? JSON.stringify({ error: '--all and --slug are mutually exclusive', exitCode: 1 })
+      : 'dz score: --all and --slug are mutually exclusive');
+    return 1;
+  }
+  const root = resolve(cwd, options.get('project') ?? '.');
+  const receiptFiles = scoreReceiptFiles(root);
+  if (receiptFiles.length === 0) {
+    const report = buildScoreAggregateReport([], [], 0);
+    const chain = scoreAggregateChainLine('');
+    if (json) write(JSON.stringify({ ...report, chain: null, aggregatePath: '.dz/feature-adr/scorecards.jsonl', exitCode: 0 }, null, 2));
+    else {
+      write(renderScoreAggregateReport(report));
+      write(chain.line);
+    }
+    return 0;
+  }
+
+  const ts = new Date().toISOString();
+  const rows: ReturnType<typeof scoreReceiptToAggregateRow>[] = [];
+  const unreadableReceipts: string[] = [];
+  for (const receipt of receiptFiles) {
+    try {
+      rows.push(scoreReceiptToAggregateRow({
+        content: readFileSync(receipt.path, 'utf8'),
+        qeHash: receipt.qeHash,
+        ts,
+      }));
+    } catch {
+      unreadableReceipts.push(receipt.displayPath);
+    }
+  }
+
+  const storeDir = join(root, '.dz', 'feature-adr');
+  const aggregatePath = join(storeDir, 'scorecards.jsonl');
+  let finalText = '';
+  let finalRows = rows;
+  let appended = 0;
+  let storeError: string | null = null;
+  try {
+    const result = withNamedLockSync(storeDir, 'scorecards', () => {
+      let existingText = '';
+      try {
+        existingText = readFileSync(aggregatePath, 'utf8');
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      }
+      const fresh = dedupeScoreAggregateRows(rows, readScoreAggregateRows(existingText));
+      const appendText = appendChainedLines(fresh, readTailInfo(existingText));
+      if (appendText !== '') appendFileSync(aggregatePath, appendText, { encoding: 'utf8', mode: 0o600 });
+      const settledText = existingText + appendText;
+      return { text: settledText, rows: readScoreAggregateRows(settledText), appended: fresh.length };
+    });
+    finalText = result.text;
+    finalRows = result.rows;
+    appended = result.appended;
+  } catch (error) {
+    storeError = error instanceof Error ? error.message : String(error);
+  }
+
+  const report = buildScoreAggregateReport(finalRows, unreadableReceipts, appended);
+  const chain = scoreAggregateChainLine(finalText);
+  if (json) {
+    write(JSON.stringify({
+      ...report,
+      aggregatePath: '.dz/feature-adr/scorecards.jsonl',
+      chain: chain.verification === null ? null : { verification: chain.verification, defectAges: chain.defectAges },
+      storeError,
+      exitCode: 0,
+    }, null, 2));
+  } else {
+    write(renderScoreAggregateReport(report));
+    write(chain.line);
+    if (storeError !== null) write(`store error (nothing was claimed appended): ${storeError}`);
+  }
+  return 0;
+}
+
 function cmdScore(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
   const json = flags.has('json');
   if (flags.has('help')) {
@@ -13784,13 +14326,14 @@ function cmdScore(options: Map<string, string>, flags: Set<string>, cwd: string,
     if (json) write(JSON.stringify({ help: usage, exitCode: 0 })); // --json stays ONE document even for help
     else {
       write(usage);
+      write('dz score --all [--project <dir>] [--json] — sweep immutable score receipts into the append-only chained aggregate');
       write('  disciplines: ADR confirmation · discrimination · cross-model QE · live verification · README-first · learning loop · amendments');
       write('  descriptive-only, never a gate: a low score exits 0');
     }
     return 0;
   }
   for (const flag of flags) {
-    if (!new Set(['json', 'help']).has(flag)) {
+    if (!new Set(['json', 'help', 'all']).has(flag)) {
       write(json ? JSON.stringify({ error: `unknown option --${flag}`, exitCode: 1 }) : `dz score: unknown option --${flag}\n  allowed: --slug <feature>, --project <dir>, --json`);
       return 1;
     }
@@ -13802,6 +14345,7 @@ function cmdScore(options: Map<string, string>, flags: Set<string>, cwd: string,
       return 1;
     }
   }
+  if (flags.has('all')) return cmdScoreAll(options, flags, cwd, write);
   const slug = options.get('slug') ?? '';
   // The delivery-check traversal lesson, upgraded to a WHITELIST: `.` slipped the blacklist and
   // silently aggregated the entire features/ tree as one "run" (Codex QE #2).
@@ -15582,17 +16126,19 @@ function cmdStats(cwd: string, write: Write): number {
   }
   const dirs = readdirSync(baseDir, { withFileTypes: true }).filter((e) => e.isDirectory());
   const packages = dirs.length;
-  let totalSkills = 0;
-  let skillPacks = 0;
-  for (const dir of dirs) {
-    if (dir.name.startsWith('skills-')) {
-      skillPacks++;
-      const skillDir = join(baseDir, dir.name);
-      const skillDirs = readdirSync(skillDir, { withFileTypes: true })
-        .filter((e) => e.isDirectory() && existsSync(join(skillDir, e.name, 'SKILL.md')));
-      totalSkills += skillDirs.length;
-    }
-  }
+  // Backlog e160aeee. This used to walk the tree ITSELF, and was wrong in two independent ways:
+  // it counted only packages whose NAME starts with `skills-` (health-advisor, p-replicator,
+  // keysarium and trip-planner were therefore invisible), and it knew only ONE of the three skill
+  // layouts. Result: 203 here against 250 from `dz registry` on the same tree — two counters of one
+  // quantity, each unable to refute the other because neither knew the other existed.
+  //
+  // The fix is structural, not arithmetic: there is now ONE enumerator, and both commands ask it.
+  // Pinned by test/stats-registry-parity.test.ts, whose red half is this exact divergence.
+  // The registry already PUBLISHES these totals; recomputing them from `entries` here would be a
+  // third implementation of the same count, which is the very defect being fixed.
+  const registry = buildRegistry(cwd);
+  const totalSkills = registry.totalSkills;
+  const skillPacks = registry.totalPacks;
   const targets = TARGET_NAMES.length;
   const presets = PRESET_NAMES.length;
   write(`dz stats — DZ Harness Hub`);
@@ -16065,7 +16611,31 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
     return version === 'unknown' ? 1 : 0;
   }
 
-  if (command === '' || command === 'help' || flags.has('help')) {
+  // `-h` is the most-typed help flag and is NOT a command: before the unknown-command contract
+  // landed it fell through to the switch and still printed usage; afterwards it would have died
+  // with exit 2 and an empty stdout (measured regression, cross-model QE M1). It belongs beside
+  // `-v` above — an argv-level flag, resolved before command dispatch.
+  if (argv[0] === '-h') {
+    write(USAGE);
+    return 0;
+  }
+  // A bare `--typo` leaves the command empty, so the usage branch reported SUCCESS on a misspelled
+  // FLAG exactly as it used to on a misspelled VERB (cross-model QE M2): `dz --frobnicate` exited 0
+  // with 30 KB of usage. The refusal is deliberately narrowed to the no-command case, because the
+  // warn-don't-refuse decision above is measured and still stands: with a command present, an
+  // unrecognised name may simply be missing from KNOWN_CLI_FLAGS and refusing would break working
+  // invocations. With NO command there is nothing the flag could belong to, so it is a usage error.
+  if (command === '') {
+    const strayNames = unknownFlagNotice(
+      [...flags, ...options.keys()].filter((k) => !k.startsWith('_positional_')),
+      KNOWN_CLI_FLAGS,
+    ).map((n) => n.name);
+    if (strayNames.length > 0) {
+      writeErr(`dz: unknown option --${strayNames[0]} — run 'dz help' for usage`);
+      return 2;
+    }
+  }
+  if (command === '' || command === 'help' || (flags.has('help') && DZ_COMMANDS.includes(command))) {
     write(USAGE);
     return 0;
   }
@@ -16134,6 +16704,8 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
         return cmdStatusline(options, flags, cwd, write, readStdin);
       case 'usage':
         return cmdUsage(options, optionLists, flags, cwd, write);
+      case 'chain':
+        return cmdChain(options, flags, cwd, write);
       case 'claim-check':
         return cmdClaimCheck(options, optionLists, flags, cwd, write);
       case 'lint':
@@ -16155,7 +16727,7 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
       case 'diff':
         return cmdDiff(options, cwd, write);
       case 'recommend':
-        return cmdRecommend(options, cwd, write);
+        return cmdRecommend(options, flags, cwd, write);
       case 'upgrade':
         return cmdUpgrade(options, flags, cwd, write, writeErr);
       case 'auto-canonicalize':
@@ -16204,8 +16776,20 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
         return cmdChallenge(options, flags, cwd, write);
       case 'discrimination-check':
         return cmdDiscriminationCheck(options, flags, cwd, write);
-      case 'mutation-gate':
-        return cmdMutationGate(options, flags, cwd, write);
+      case 'mutation-gate': {
+        try {
+          return cmdMutationGate(options, flags, cwd, write, io.mutationGateRunner);
+        } catch (error) {
+          const raw = error instanceof Error ? error.message : String(error);
+          const head = Array.from(raw.split(/\r?\n/, 1)[0]?.trim() || 'unknown internal error').slice(0, 160).join('');
+          if (flags.has('json')) {
+            write(JSON.stringify({ verdict: 'INCONCLUSIVE', reason: 'runner-internal-error', error: head, exitCode: 1 }));
+          } else {
+            write(`mutation-gate: INTERNAL ERROR (${head}) — verdict INCONCLUSIVE, exit 1`);
+          }
+          return 1;
+        }
+      }
       case 'delivery-check':
         return cmdDeliveryCheck(options, flags, cwd, write);
       case 'skills-verify':
@@ -16259,9 +16843,8 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
       case 'import-ecc':
         return await cmdImportEcc(options, flags, cwd, write);
       default:
-        write(`dz: unknown command ${JSON.stringify(command)}`);
-        write(USAGE);
-        return 1;
+        writeErr(`dz: unknown command ${JSON.stringify(command)} — run 'dz help' for the command list`);
+        return 2;
     }
   } catch (error) {
     // stderr, not stdout: an uncaught failure is a diagnostic, and routing it through