@dzhechkov/harness-cli 0.3.235 → 0.3.237

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/harness-cli",
-  "version": "0.3.235",
+  "version": "0.3.237",
   "description": "The dz CLI — install AI skills for Claude Code, Codex, OpenCode, Hermes, OpenClaude, GitHub Copilot. 35 commands, 13 presets, 6 platform targets.",
   "type": "module",
   "license": "MIT",
@@ -57,7 +57,7 @@
     "@dzhechkov/skills-reverse-engineering": "^0.1.0",
     "@dzhechkov/skills-presentation-storyteller": "^0.1.0",
     "@dzhechkov/skills-website-cloner": "^0.1.0",
-    "@dzhechkov/harness-core": "0.3.126"
+    "@dzhechkov/harness-core": "0.3.128"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/sbom.json

@@ -9,86 +9,6 @@
     }
   },
   "components": [
-    {
-      "type": "file",
-      "name": ".agentic-qe/brain.rvf",
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "8136cd4cc145d3dbe6ed3ae4489946bbc26e3e44172f0e5241ac45dde38bfead"
-        }
-      ]
-    },
-    {
-      "type": "file",
-      "name": ".agentic-qe/brain.rvf.lock",
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "99fa5178a48b6953b8f3a6f1690204a3b5449004b7dd105e7a3155ad3658266c"
-        }
-      ]
-    },
-    {
-      "type": "file",
-      "name": ".agentic-qe/memory.db",
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "456372cb9a8c12f98ae6378338b8469d9be6df05cbe03a99b412d83d962b3d11"
-        }
-      ]
-    },
-    {
-      "type": "file",
-      "name": ".agentic-qe/memory.db-shm",
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "cab99dd5d4068013a0c5f4f1c2d29dbec07729dc47c1d77adba6a53b773d0026"
-        }
-      ]
-    },
-    {
-      "type": "file",
-      "name": ".agentic-qe/memory.db-wal",
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "2cc80ec378c1f9cd2588676588ee1b73bfe4f2f7ef3b96879c295eb86dccd2c2"
-        }
-      ]
-    },
-    {
-      "type": "file",
-      "name": ".agentic-qe/patterns.rvf",
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "9090b2e6d339eaa183672ac0cf9f625dbd5f9fc76d64afcdb34a3f5871c31c5a"
-        }
-      ]
-    },
-    {
-      "type": "file",
-      "name": ".agentic-qe/patterns.rvf.idmap.json",
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "c2693f9a7f47a2d2bffe3004188e70ce08411bf8db47d07c60551d18ff7640c4"
-        }
-      ]
-    },
-    {
-      "type": "file",
-      "name": ".agentic-qe/patterns.rvf.lock",
-      "hashes": [
-        {
-          "alg": "SHA-256",
-          "content": "84842f3916c558b1f4f2da2a5b0236587f146dda1f6ab4ba4c31ed7b8b17f943"
-        }
-      ]
-    },
     {
       "type": "file",
       "name": "CHANGELOG.md",
@@ -105,7 +25,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "378ef9c8fcde4e77594b29a5f043b57f880f5df2b40fce679addfae756670154"
+          "content": "7e8b772a6fa9ca0f36364cafd5ea996abeb62dc894c2f67f50ea7704a7a8824d"
         }
       ]
     },
@@ -115,7 +35,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "1abb00d07ab57ad413d2747baa6a68cda0876a9e0c6f75db89c205fbf4863530"
+          "content": "667bf610bf890a7b93480a4b1045e98dc0c765effd80b78fde4e48538f595b3e"
         }
       ]
     },
@@ -125,7 +45,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "42d2a98f54c2ec773b49a0a43c959a78d070c8c427724f4affbd5bafef35621d"
+          "content": "593705e81f851c0e65ffa9feaa9bbd396e7a3295b9b21076cfd953ee5a05b93a"
         }
       ]
     },
@@ -185,7 +105,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "45c0c1328829a56cfe0ea0ebc74c15477a00bb683b496404688ab4b7b7a88ef8"
+          "content": "cf6a3265890a8856ef31e3e7ac58026c15232c3c118ba0fcd1ce0d7590b84dd8"
         }
       ]
     },
@@ -195,7 +115,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "20974a159438ac73a4c308cdb3710154dd9fe0450ed5184f6f3938792380fece"
+          "content": "b9af9be1bd31acd60e76275ff1055dd8e9b39b531b0c375467648f142b74d2c4"
         }
       ]
     },
@@ -205,7 +125,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "bfb9ecebeb1c3cc631f2c8e7f46af4318e3698789c9dda49aaebbe26fe1c7fa7"
+          "content": "6a51963ede51129e43524d62f3d757255a002dfec3df2c1dfa519af6f235a667"
         }
       ]
     },
@@ -265,7 +185,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c03aafaeaf663bb47b756608049bf77f6460615f1e806054644ec830c524cf72"
+          "content": "1e7ef1d6e0796144999ad64d3650aeb4a2ccc7dfc66c5c5a8b705d783a9d0801"
         }
       ]
     },
@@ -285,7 +205,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "6b8d21416576a2744b5d9bf973d7b878c255495829fcf3679b183a977abc55a2"
+          "content": "5180330ac6612542c80a74ea8e0983f5cd231e95bb3962eccdd65fbdbf6611a8"
         }
       ]
     },
@@ -305,7 +225,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "09472c195254c359f14256c39e8c7afd08c0b71aadb57cd077534f0d7c482005"
+          "content": "461beed08ad6cfde7bbf559701fcbc6978f622c3951c80463c4e4943c538eff5"
         }
       ]
     },

package/src/cli.ts

@@ -48,6 +48,9 @@ import {
   runInitAgentsMd,
   runInitGeminiMd,
   TARGET_NAMES,
+  buildParityMatrix,
+  TARGET_CAPABILITIES,
+  TARGET_SHORT_LABELS,
   WORKFLOW_NAMES,
   importEcc,
   recordPattern,
@@ -176,6 +179,12 @@ import {
   renderProseDiff,
   readScenarioIds,
   DEFAULT_MAX_JUDGE_RUNS,
+  collectDeliveryFacts,
+  planDeliveryCheck,
+  renderDeliveryBrief,
+  classifyDelivery,
+  isUsablePlaneResult,
+  renderDeliveryReview,
 } from '@dzhechkov/harness-core';
 import type { Family, ModelRung, Candidate as BtoCandidate, DimScores } from '@dzhechkov/harness-core';
 import type { SetupSpec } from '@dzhechkov/harness-core';
@@ -204,6 +213,8 @@ Usage:
   dz verify-pack --pack <dir> [--pubkey <path>]             (signature check; fail-closed; key from the repo, never the pack)
   dz publish [--filter <name>] [--bump-only] [--claim-check <off|warn|error>] [--require-signing] [--provenance|--no-provenance]   (dry-run by default; pass --yes/--confirm/--no-dry-run to go live; claim-check gate default warn — surfaces README claim findings, never blocks; error fails an offending package)
   dz release [--filter <name>] [--tag] [--publish] [--json] [--dry-run] [--no-issue]   (VERIFIED release: 4 HARD gates in FRONT of dz publish — full package test suites, audit >=high, node --check of every dist/bin file, bin smoke-boot via "node <bin> --help" — any red gate STOPS the release (exit 1) + best-effort gh issue; all green ⇒ re-sign reminder, then prints the ready dz publish command (or chains with --publish); never duplicates publish's own gates)
+  dz parity [--target <name>] [--json]   (the honest feature×target map, COMPUTED from the capability model — which harness feature is full / manual / absent on each of the ${TARGET_NAMES.length} targets, and via which form)
+  dz delivery-check --slug <slug> [--context-only] [--findings <f.json>] [--strict] [--author <model>] [--json]   (portable Step-10 Delivery Gate: prints the 4-plane review brief + artifact probes; --findings classifies a fed-back review into a fail-closed ready|blocked hand-off and writes features/<slug>/10_delivery_review.md; --strict exits 1 on blocked)
   dz setup --target <name> [--preset <name>] [--select id,id,...] [--skills-dir <dir>] [--project <dir>] [--memory agentdb] [--no-memory] [--no-hooks] [--install-driver] [--force] [--enrich]
   dz teach "<pattern>" [--reward <0-1>] [--domain <name>] [--type rule|success-pattern|lesson-learned] [--project <dir>] [--no-mirror]   (--project pins the learned store to <dir>/.dz, not the cwd — pin to a canonical brain)
   dz teach --from-json <file> [--project <dir>] [--no-mirror]   (bulk-import a 'dz recall --all --json' export — share a learned store across machines)
@@ -3571,6 +3582,88 @@ function cmdPublish(options: Map<string, string>, flags: Set<string>, cwd: strin
   return report.errors > 0 ? 1 : 0;
 }
 
+/* ------------------------------------------------------------------ */
+/*  dz parity — the honest feature×target map (target-parity-matrix,   */
+/*  ADR-001): computed from the declarative model, never hand-written  */
+/* ------------------------------------------------------------------ */
+
+function cmdParity(options: Map<string, string>, flags: Set<string>, write: Write): number {
+  const json = flags.has('json');
+  if (flags.has('help')) {
+    write('dz parity [--target <name>] [--json] — the computed feature×target map (never hand-written)');
+    write(`  targets: ${TARGET_NAMES.join(', ')}`);
+    return 0;
+  }
+  const allowedFlags = new Set(['json', 'help']);
+  const allowedOptions = new Set(['target']);
+  // A stray positional is a typo'd invocation, not something to silently ignore (Codex QE gap 7).
+  if (options.has('_positional_0')) {
+    write(json ? JSON.stringify({ error: `unexpected argument "${options.get('_positional_0')}"`, exitCode: 1 }) : `dz parity: unexpected argument "${options.get('_positional_0')}"\n  allowed: --target <name>, --json`);
+    return 1;
+  }
+  for (const flag of flags) {
+    if (!allowedFlags.has(flag)) {
+      write(json ? JSON.stringify({ error: `unknown option --${flag}`, exitCode: 1 }) : `dz parity: unknown option --${flag}\n  allowed: --target <name>, --json`);
+      return 1;
+    }
+  }
+  for (const key of options.keys()) {
+    if (key.startsWith('_positional_')) continue;
+    if (!allowedOptions.has(key)) {
+      write(json ? JSON.stringify({ error: `unknown option --${key}`, exitCode: 1 }) : `dz parity: unknown option --${key}\n  allowed: --target <name>, --json`);
+      return 1;
+    }
+  }
+
+  const matrix = buildParityMatrix();
+  const target = options.get('target');
+  if (target !== undefined && !TARGET_NAMES.includes(target as (typeof TARGET_NAMES)[number])) {
+    if (json) write(JSON.stringify({ error: `unknown target "${target}"`, targets: TARGET_NAMES, exitCode: 1 }, null, 2));
+    else write(`dz parity: unknown target "${target}" — one of: ${TARGET_NAMES.join(', ')}`);
+    return 1;
+  }
+
+  if (json) {
+    const rows = matrix.map((r) => ({
+      id: r.feature.id,
+      title: r.feature.title,
+      cells: target !== undefined ? { [target]: r.cells[target as (typeof TARGET_NAMES)[number]] } : r.cells,
+    }));
+    // A filtered response stays internally consistent: capabilities are filtered too (Codex QE gap 9).
+    const caps = target !== undefined ? { [target]: TARGET_CAPABILITIES[target as (typeof TARGET_NAMES)[number]] } : TARGET_CAPABILITIES;
+    write(JSON.stringify({ targets: target !== undefined ? [target] : TARGET_NAMES, capabilities: caps, features: rows }, null, 2));
+    return 0;
+  }
+
+  if (target !== undefined) {
+    const t = target as (typeof TARGET_NAMES)[number];
+    write(`\ndz parity — ${t}  (capabilities: ${TARGET_CAPABILITIES[t].join(', ')})\n`);
+    for (const r of matrix) {
+      const c = r.cells[t];
+      const icon = c.level === 'full' ? '✓' : c.level === 'manual' ? '◐' : '—';
+      write(`  ${icon} ${r.feature.title.padEnd(58)} ${c.level === 'none' ? 'not available on this target' : `via ${c.via ?? ''}`}`);
+    }
+    write('\n  ✓ full (the complete experience)   ◐ manual (works, you drive it by hand)   — not available');
+    return 0;
+  }
+
+  // Grid: one column per target, short header, one row per feature. Computed, never hand-written;
+  // the labels live NEXT TO the model (a local map here would be a second, unchecked registry).
+  const short: Record<string, string> = TARGET_SHORT_LABELS;
+  write('\ndz parity — feature × target (computed from the model; dz parity --target <name> for detail)\n');
+  write(`  ${'feature'.padEnd(52)} ${TARGET_NAMES.map((t) => (short[t] ?? t).padStart(4)).join('')}`);
+  for (const r of matrix) {
+    const cells = TARGET_NAMES.map((t) => {
+      const c = r.cells[t];
+      return (c.level === 'full' ? '✓' : c.level === 'manual' ? '◐' : '—').padStart(4);
+    }).join('');
+    write(`  ${r.feature.title.slice(0, 52).padEnd(52)} ${cells}`);
+  }
+  write('\n  ✓ full   ◐ manual (available, driven by hand)   — not available');
+  write(`  columns: ${TARGET_NAMES.map((t) => `${short[t] ?? t}=${t}`).join('  ')}`);
+  return 0;
+}
+
 /* ------------------------------------------------------------------ */
 /*  dz release — verified-release conveyor (feature release-verified,  */
 /*  ADR-001): 4 HARD gates in FRONT of the untouched dz publish.       */
@@ -5115,8 +5208,18 @@ function cmdFeatureAdrSetup(options: Map<string, string>, flags: Set<string>, cw
     return 1;
   }
 
+  // portable-gates (direction b): --gates scaffolds the zero-config architecture/gates/delivery-check.md.
+  // Its "runnable here" list is computed for --target (default agents-md, the AGENTS.md-class target class).
+  const wantGates = flags.has('gates');
+  const targetOpt = options.get('target');
+  if (targetOpt !== undefined && !isTargetName(targetOpt)) {
+    write(`dz feature-adr-setup: --target must be one of: ${TARGET_NAMES.join(', ')}`);
+    return 1;
+  }
+  const gatesTarget: TargetName = isTargetName(targetOpt ?? '') ? (targetOpt as TargetName) : 'agents-md';
+
   const specPath = options.get('from-spec');
-  if (specPath === undefined && !wantGuards) {
+  if (specPath === undefined && !wantGuards && !wantGates) {
     // default + --plan: the read-only "which documents, and where?" answer.
     const plan = buildSetupPlan(scanForSetup(repoRoot));
     if (flags.has('json')) { write(JSON.stringify(plan, null, 2)); return 0; }
@@ -5138,8 +5241,9 @@ function cmdFeatureAdrSetup(options: Map<string, string>, flags: Set<string>, cw
     spec = {}; // --guards standalone: scaffold just the guard set
   }
   if (wantGuards) spec = { ...spec, guards: locCap !== undefined ? { locCap } : true };
+  if (wantGates) spec = { ...spec, gates: true };
 
-  const result = scaffoldFromSpec(spec, readExistingForScaffold(repoRoot));
+  const result = scaffoldFromSpec(spec, readExistingForScaffold(repoRoot), gatesTarget);
   if (flags.has('json') && !flags.has('apply')) { write(JSON.stringify(result, null, 2)); return 0; }
   write(renderScaffoldPreview(result));
 
@@ -5342,6 +5446,137 @@ function nameFor(t: { file: string; name?: string }, outcome: 'pass' | 'fail' |
   return t.name !== undefined ? { file: t.file, name: t.name, outcome } : { file: t.file, outcome };
 }
 
+/**
+ * `dz delivery-check` — the portable Step-10 Delivery Gate (feature portable-gates). The `manual` form that
+ * travels to every `shell` target: the deterministic parts (artifact probes, hand-off arithmetic,
+ * cross-validation bookkeeping) run IN the CLI; the semantic 4-plane review is DISPATCHED to the caller's own
+ * agent runtime — the `dz challenge` cartridge shape. All logic lives in harness-core's pure engine; this is
+ * the executor. Advisory exit codes (0 by default; `--strict` ⇒ 1 on `blocked`).
+ *
+ *   --slug <slug>            the feature under features/<slug> (required; featureDir derived internally)
+ *   --context-only           default mode: print artifact probes + the 4-plane review brief (no verdict)
+ *   --findings <f.json>      classify a fed-back findings array → write 10_delivery_review.md + print ready/blocked
+ *   --strict                 with --findings: exit 1 iff handoff === 'blocked' (CI gate)
+ *   --author <model>         cosmetic: the reviewer to dispatch, printed alongside the brief
+ *   --json                   machine contract { planesChecked, planesSkipped, findings, handoff, artifact }
+ */
+function cmdDeliveryCheck(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  let repoRoot = cwd;
+  try { repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || cwd; } catch { /* not git */ }
+
+  const json = flags.has('json');
+  const errOut = (error: string): number => {
+    if (json) write(JSON.stringify({ error, planesChecked: [], planesSkipped: [], findings: [], handoff: null, artifact: 'not-written' }, null, 2));
+    else { write(`dz delivery-check: ${error}`); write('  allowed: --slug <slug>, --findings <f.json>, --author <model>, --context-only, --strict, --json'); }
+    return 1;
+  };
+  // Strict allowlist (delivery finding: a typo'd --findings silently downgraded the --strict CI
+  // gate to a vacuous exit-0 pass — a mistyped option must be an ERROR, never a mode change).
+  const allowedFlags = new Set(['context-only', 'strict', 'json', 'help']);
+  const allowedOptions = new Set(['slug', 'findings', 'author']);
+  for (const flag of flags) if (!allowedFlags.has(flag)) return errOut(`unknown option --${flag}`);
+  for (const key of options.keys()) {
+    if (key.startsWith('_positional_')) return errOut(`unexpected argument "${options.get(key)}"`);
+    if (!allowedOptions.has(key)) return errOut(`unknown option --${key}`);
+  }
+
+  const slug = options.get('slug');
+  if (slug === undefined || slug.trim() === '') return errOut('pass --slug <slug> (the feature under features/<slug>)');
+  // Slug convention is a SECURITY boundary here (delivery finding, CONFIRMED traversal reproducer:
+  // --slug '../../outside/evil' wrote 10_delivery_review.md outside the repo). kebab-case Latin,
+  // <=40 chars — the repo's own slug rule as a layer-1 three-line check.
+  const slugTrimmed = slug.trim();
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slugTrimmed) || slugTrimmed.length > 40) {
+    return errOut(`invalid --slug "${slugTrimmed}" — kebab-case Latin, max 40 chars (a path-like slug would redirect the report write)`);
+  }
+  const featureDir = join(repoRoot, 'features', slugTrimmed);
+
+  // --context-only is a real mode flag, not decoration: combining it with --findings contradicts
+  // itself (delivery finding — the flag was accepted and silently ignored).
+  if (flags.has('context-only') && options.get('findings') !== undefined) {
+    return errOut('--context-only and --findings are mutually exclusive (context-only prints the brief; findings classifies the verdict)');
+  }
+
+  // git status --porcelain — CLI layer only (the `no child_process in core` contract); a non-git target
+  // degrades to an empty list, which is honest (AM-10: changed-files is informational, never a required gate).
+  let changedFiles: string[] = [];
+  try {
+    const out = execSync('git status --porcelain', { cwd: repoRoot, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+    changedFiles = out.split('\n').map((l) => l.slice(3).trim()).filter((s) => s.length > 0);
+  } catch { /* non-git / unavailable → empty (honest) */ }
+
+  const facts = collectDeliveryFacts(featureDir, { changedFiles, repoRoot });
+  const plan = planDeliveryCheck(facts);
+  const author = options.get('author');
+
+  const findingsPath = options.get('findings');
+  if (findingsPath === undefined) {
+    // Default / --context-only: emit the led protocol (probes + brief). No verdict — the CLI has no model.
+    if (json) {
+      write(JSON.stringify({
+        planesChecked: [],
+        planesSkipped: plan.planes.map((p) => p.id),
+        findings: [],
+        handoff: null,
+        artifact: 'not-written',
+        probes: plan.probes,
+      }, null, 2));
+      return 0;
+    }
+    write(`dz delivery-check — ${slug} (portable 4-plane hand-off protocol; you drive the review)`);
+    for (const p of plan.probes) {
+      const mark = p.passed === true ? '✓' : p.passed === false ? '✗' : '○';
+      write(`  ${mark} ${p.description}${p.required ? ' [required]' : ' [informational]'}`);
+    }
+    write('');
+    write(renderDeliveryBrief(plan, facts));
+    // The hand-off criterion the verdict will be judged by, shown UP FRONT (this also makes
+    // plan.criterionTemplate a consumed surface, not dead product code — delivery finding).
+    write('\n── hand-off criterion (all must PASS for ready) ──');
+    for (const c of plan.criterionTemplate) write(`  ○ ${c.label}`);
+    if (author !== undefined && author.trim() !== '') write(`\n── reviewer to dispatch ──\n${author.trim()}`);
+    write('\n(next: run the four planes, then `dz delivery-check --slug ' + slug + ' --findings findings.json` for the verdict)');
+    return 0;
+  }
+
+  // --findings mode: parse (malformed/missing ⇒ [], a failed-plane input — fail-closed, never a throw).
+  let reviewResults: unknown[] = [];
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(resolve(cwd, findingsPath), 'utf-8'));
+    if (Array.isArray(parsed)) reviewResults = parsed;
+    else if (parsed !== null && typeof parsed === 'object' && Array.isArray((parsed as { planes?: unknown }).planes)) reviewResults = (parsed as { planes: unknown[] }).planes;
+    else reviewResults = [];
+  } catch { reviewResults = []; }
+
+  const verdict = classifyDelivery(plan, reviewResults as ({ findings?: readonly unknown[] } | null | undefined)[]);
+  // The SAME predicate as the fail-closed verdict (core-exported) — a local copy was a drift channel.
+  const planesChecked = plan.planes.filter((_, i) => isUsablePlaneResult(reviewResults[i])).map((p) => p.id);
+  const planesSkipped = plan.planes.filter((_, i) => !isUsablePlaneResult(reviewResults[i])).map((p) => p.id);
+
+  // Write the regenerable report (NOT augment-never-clobber — deliberately overwritten each run).
+  let artifact: 'written' | 'not-written' = 'not-written';
+  try {
+    const reviewPath = join(featureDir, '10_delivery_review.md');
+    mkdirSync(dirname(reviewPath), { recursive: true });
+    writeFileSync(reviewPath, renderDeliveryReview(verdict, facts));
+    artifact = 'written';
+  } catch { /* best-effort — the verdict is still returned */ }
+
+  if (json) {
+    write(JSON.stringify({ planesChecked, planesSkipped, findings: verdict.findings, handoff: verdict.handoff, artifact }, null, 2));
+  } else {
+    write(`dz delivery-check — ${slug}: ${verdict.handoff}`);
+    for (const c of verdict.criterion) {
+      const mark = c.status === 'PASS' ? '✓' : c.status === 'FAIL' ? '✗' : '○';
+      write(`  ${mark} ${c.label}: ${c.status}${c.detail ? ` — ${c.detail}` : ''}`);
+    }
+    write(artifact === 'written' ? `\n↳ wrote features/${slug}/10_delivery_review.md` : '\n↳ 10_delivery_review.md NOT written (verdict above is authoritative)');
+  }
+
+  if (flags.has('strict') && verdict.handoff === 'blocked') return 1;
+  return 0;
+}
+
 /**
  * `dz routing` — inspect the learned cost-optimal routing outcome store (feature learned-cost-routing). Shows
  * what `args.models[stage]='auto-cost'` currently believes per (stage, complexity-tier, model): gated
@@ -5732,6 +5967,8 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
         return cmdPublish(options, flags, cwd, write);
       case 'release':
         return cmdRelease(options, flags, cwd, write, io.releaseRunner);
+      case 'parity':
+        return cmdParity(options, flags, write);
       case 'registry':
         return cmdRegistry(options, cwd, write);
       case 'benchmark':
@@ -5764,6 +6001,8 @@ 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 'delivery-check':
+        return cmdDeliveryCheck(options, flags, cwd, write);
       case 'routing':
         return cmdRouting(options, flags, cwd, write);
       case 'bto-optimize':