@dzhechkov/harness-cli 0.3.258 → 0.3.259

package/.dz-manifest.json

@@ -9,7 +9,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "a38e5ef6a741aec138af0de7bd3616d4356d613ba1616bd8b5417194c1ee5f03"
+        "sha256": "6b3bcc252253732b9703f1eb43ac1f0e9f0599979b09d0fea3208932fd0f33a8"
       },
       {
         "path": "coverage/coverage-final.json",
@@ -41,15 +41,15 @@
       },
       {
         "path": "dist/cli.d.ts.map",
-        "sha256": "f954d1e2e3d9f5941481a2b2ccbf553bab892dfa9ba1e7aefb4bf7d1800e9203"
+        "sha256": "4c5fa8c51cc350874413efceb0a2e4dce2f0c71f39914ddd8be425336a37ae2d"
       },
       {
         "path": "dist/cli.js",
-        "sha256": "5fb105be335591fb20401a3b23bac9829777e7ba96c2a2480c29970f4ffa2774"
+        "sha256": "a75034dfe70f0b57811dfad831366bd5c7995583a57db0f218621b026ac8d854"
       },
       {
         "path": "dist/cli.js.map",
-        "sha256": "a4be3aac6dadec03c1fc85fc5354d9a286ac0a21b4983349c4e511cae49dec79"
+        "sha256": "dbe8fa418aedcb77dead3a374bba7cbf0fb5e305dd9a06002946a19604279684"
       },
       {
         "path": "dist/index.d.ts",
@@ -73,7 +73,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "b502ba368d29e25413ce35e8853bc5650c06f686202e51f997f67db0fac03224"
+        "sha256": "72858a1f0199832c7ad781f892b7b117ec980af33ff9598587e1ed1544046a35"
       },
       {
         "path": "src/bin.ts",
@@ -81,7 +81,7 @@
       },
       {
         "path": "src/cli.ts",
-        "sha256": "a369561502f08d9dd4993a294adcb3a38349f543959fa8de31cd1580778062b0"
+        "sha256": "1481238a2fc3a60051f678dcf6b415f8052ce954a9e55ee7577d8c3b2261e062"
       },
       {
         "path": "src/index.ts",
@@ -89,7 +89,7 @@
       },
       {
         "path": "test/cli.test.ts",
-        "sha256": "555aed692218a73f23a343df2f2b38ce028e694dd9d4aff37e727096f88eb50e"
+        "sha256": "24f2feb4c5c4fa939beb79cd658b03fbc7ce4bd87f15da563240abcb252c472c"
       },
       {
         "path": "test/epoch-replay-cli.test.ts",
@@ -109,5 +109,5 @@
       }
     ]
   },
-  "signature": "CXaYCYQIKEVpAB29MZ5rG0/VUWtihZaeJh86r6x8uFpzKrgzHnrzmg/MmTUW3R/rqeA5w12hcfyfr4kl85ZxBA=="
+  "signature": "uYnxiEzDxjwdXlp1SGaC0Zv2x/MW39skbUKw3+xpvnLcoNsEV4pp8kFD5q7urBvC87fC+lRKsIpatoXCNGzwBA=="
 }

package/README.md

@@ -132,7 +132,7 @@ point any tool at (a skill is just Markdown). Dedicated targets are on the [road
 
 ## User Journey — from install to mastery
 
-All 62 commands mapped to a real workflow:
+All 63 commands mapped to a real workflow:
 
 ```
 DISCOVER → INSTALL → USE → CREATE → MAINTAIN → SHARE
@@ -604,6 +604,41 @@ ever enter a work order.
 **When to use:** after `dz compounding` reports the replay as READY; before claiming that recall
 "works"; and any time you want the claim re-checked as the corpus grows.
 
+### Пересмотр после аварийного само-ревью — `dz reqe`
+
+The feature-adr pipeline's cross-model guard says *the model that writes code must not review it*.
+Under limit pressure (usage-adaptive `>=70%` switch) that guard is CONSCIOUSLY suspended: coder AND
+Step-8 QE both run on Codex (FR-2.9 — a Claude reviewer is exactly the agent that dies at the
+limit). The rule used to say "re-review manually after limits reset" — an instruction nobody
+remembers. `dz reqe` turns it into a **debt with a lifecycle**: the run records
+`features/<slug>/.fa-state/reqe-due.json`, `dz usage` surfaces the count the moment you check your
+freed-up limits, and settlement is FAIL-CLOSED.
+
+```bash
+$ dz usage
+usage: session ~12% (resets 03:00) · week ~41% (resets 06:00) · estimated
+re-QE due: 1 usage-switched run(s) kept same-family QE — run `dz reqe` for the cross-family pass
+
+$ dz reqe                        # the ledger
+dz reqe — 1 unsettled re-QE debt(s):
+  add-x  coder=openai qe=openai grade=B  2026-07-30T10:00:00Z  → dz reqe --slug add-x
+
+$ dz reqe --slug add-x           # the ready cross-family review brief (the OTHER family than the coder)
+$ dz reqe --slug add-x --done --report features/add-x/08b_reqe_report.md
+dz reqe: debt settled: re-QE grade C (report …) — settlement appended to features/add-x/08_qe_report.md
+```
+
+**When to use:** any time `dz usage` prints a `re-QE due` line, or a feature-adr result carried
+`reqeDue: true`. **Fail-closed settlement:** the report must exist, be non-trivial, and name exactly
+one line-anchored `GRADE` (the boilerplate phrase `GRADE A-F` does not count); the run's own
+`08_qe_report.md` can never settle its own debt (real-path AND inode compared — a hard link doesn't
+fool it); the settlement epilogue lands in `08_qe_report.md` and the due-file rotates to
+`reqe-settled.json` (evidence kept, never deleted). **Honest scope** (printed by the command):
+nothing re-runs QE automatically, and the validator proves the settlement is procedurally sound —
+which model authored the report stays with the human running the brief. RU: гард «кодер не ревьюит
+сам себя» осознанно снимается под лимитом; `dz reqe` превращает инструкцию «перепроверь потом»
+в долг на диске — виден в `dz usage`, гасится только настоящим кросс-семейным отчётом с грейдом.
+
 ### Usage estimates you can act on — `dz usage`
 
 `dz usage` estimates how much of your Claude session (5h block) and week you have spent, from local
@@ -953,7 +988,7 @@ Get the whole set with `dz init --target claude-code --preset meta`, or pick one
 
 > **A skill and its npx toolkit are not duplicates — they're a graduation.** Several skills (e.g. `feature-adr`, `design-thinking`) exist BOTH as a skill inside a `dz` preset AND as a standalone `npx` package. The preset's SKILL.md is **fully functional on its own** (the whole methodology — modules + references — travels with it, and it auto-activates by description), and it's the only way to compile that capability to the **non-Claude platforms** (Codex/OpenCode/Hermes/OpenClaude) via `dz`. The npx package adds **project-level runtime governance** around the same skill: a slash command, governance rules, a context shard, and (for feature-adr) reward-learning + `/harvest`. So: pick the **skill/preset** for a working capability across platforms; pick the **npx toolkit** when you want it as a governed, command-driven fixture of one project.
 
-## All Commands (62)
+## All Commands (63)
 
 ```
 dz setup             --target <name> [--preset <name>] [--select id,id,...] [--skills-dir <dir>] [--memory agentdb] [--no-memory] [--no-hooks] [--install-driver] [--force]
@@ -1017,6 +1052,7 @@ dz epoch-replay --emit  [--project <dir>] [--limit <N>] [--seed <N>] [--margin <
 dz epoch-replay --judge <filled-work-order.json> [--out <file>] [--json]   # blind judge prompts from the filled plans — the file carries {id, prompt} ONLY (no assignment, no arm names); refuses an order whose digest or seed-derived assignment does not check out; half-pairs skipped WITH A REASON, on stdout
 dz epoch-replay --score <judgments.json> --work-order <file> [--slice <name>] [--json]   # un-blind against the VERIFIED pre-registered assignment; ONE paired binomial over DECISIVE pairs (ties excluded, reported) → SUPPORTED only when the lift interval (2p−1) lies entirely above zero; FALSIFIED only on harm or a passed non-superiority test (lift upper bound below the margin PRE-REGISTERED in the work order, default 0.05, at 10+ decisive pairs); else INCONCLUSIVE (min 5 decisive pairs). Refuses a forged work order, a --margin flag, or duplicate judgement ids; the verdict is data, not an exit code
 dz score             --slug <feature> [--project <dir>] [--json]   # process scorecard for ONE feature-adr run, from its artifacts: ADR confirmation, discrimination proof, cross-model QE grade, live verification, README-first, learning loop, amendments — DESCRIPTIVE-ONLY (a low score exits 0); evidence lines are shown so the reader judges the heuristics
+dz reqe              [--slug <feature> [--done --report <f>]] [--project <dir>] [--json]   # the re-QE debt ledger: a usage-switched feature-adr run whose Step-8 QE ran on the coder's OWN family (cross-model guard suspended, FR-2.9) records a debt; list debts (also surfaced by dz usage), print the cross-family review brief, settle FAIL-CLOSED against an existing GRADED report (the run's own 08_qe_report.md — even hard-linked — can never settle its own debt); settlement lands in 08_qe_report.md, evidence rotates to reqe-settled.json
 dz backlog <sub>     add "<idea>" | list | show <id> | goals [--validate] | roulette [--seed n] [--commit <id>] | enrich <id> | jira <id> | harmonize [--apply]   # brain-backed idea backlog: capture an idea → semantic dedup against past ideas/features via the REUSED agentdb vector engine (DUPLICATE≥0.92 / RELATED / NEW) + GoalMap alignment ("map+compass") → weighted seeded roulette picks one to work on → enrich STAGES an idea2prd hand-off → jira writes an auditable outbox via a configurable MCP adapter seam (jira-mcp|copilot-mcp|none). No 2nd vector store; without agentdb it degrades to exact-text dedup (honest)
 dz sign --init --out <path>  |  --pack <dir> --key <path>   # --init: generate the Ed25519 keypair (private OUTSIDE the repo, prints the public key for keys/dz.pub); else sign a pack's manifest + CycloneDX SBOM
 dz sbom --pack <dir> [--out <file>]   # emit the CycloneDX 1.5 SBOM for a pack standalone (file-level bill of materials); print to stdout or write to a file
@@ -2729,7 +2765,7 @@ npx @dzhechkov/p-replicator init
 
 ## Status
 
-`v0.3.236` — published on npm. Also available as [Claude Plugin](#claude-plugin). Part of [DZ Harness Hub](https://github.com/djd1m/dz-harness-hub).
+`v0.3.259` — published on npm. Also available as [Claude Plugin](#claude-plugin). Part of [DZ Harness Hub](https://github.com/djd1m/dz-harness-hub).
 
 ## Claude Plugin
 

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAmXH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;CAC5C;AAED,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KACvD;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAonO9E,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CA4J5E"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA0XH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;CAC5C;AAED,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KACvD;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AA+0O9E,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CA8J5E"}

package/dist/cli.js

@@ -3,7 +3,7 @@
  *
  * @packageDocumentation
  */
-import { chmodSync, closeSync, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { appendFileSync, chmodSync, closeSync, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync, execSync, spawn } from 'node:child_process';
@@ -15,7 +15,7 @@ assembleCandidates, renderPromotionReport, renderPromotionAdr, normalizePromotio
 // Cold-vs-warm EPOCH RUNNER (feature epoch-replay) — orchestrates + scores, never calls a model.
 replayableInstances, buildWorkOrder, buildJudgePrompts, unblindJudgments, verifyWorkOrder, isValidMargin, DIGEST_HONEST_SCOPE, scoreEpochReplay, generateMockOutcomes, renderEpochReplayResult, renderWorkOrderSummary, renderJudgePromptsSummary, WORK_ORDER_KIND, DEFAULT_MOCK_N, DEFAULT_MOCK_SEED, scoreRun, renderScorecard, renderCompoundingReport, readReinforcementState, readQuarantineState, registrationExitCode, renderRegistrationReport, 
 // Smart Backlog (feature smart-backlog) — goal-directed idea pipeline over the Brain vector engine.
-readBacklogConfig, readIdeas, writeIdeas, ideaId, dedupIdea, readGoalMap, readGoalMapDetailed, parseEffort, ensureBacklogGitignored, isSafeId, alignIdea, mirrorIdeaVector, snapshotIdeas, spinRoulette, rankRoulette, seededRng, eligibleIdeas, stageEnrichment, buildJiraDraft, resolveJiraAdapter, makeBacklogIO, harmonizeBacklog, BACKLOG_BACKENDS, } from '@dzhechkov/harness-core';
+readBacklogConfig, readIdeas, writeIdeas, ideaId, dedupIdea, readGoalMap, readGoalMapDetailed, parseEffort, ensureBacklogGitignored, isSafeId, alignIdea, mirrorIdeaVector, snapshotIdeas, spinRoulette, rankRoulette, seededRng, eligibleIdeas, stageEnrichment, buildJiraDraft, resolveJiraAdapter, makeBacklogIO, harmonizeBacklog, BACKLOG_BACKENDS, parseReqeDebt, buildReqeBrief, settleReqeDebt, renderReqeList, REQE_SCOPE, } from '@dzhechkov/harness-core';
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
 import { scanGitHub, analyzeRepo, generateReport, deepAnalyze, scanAllSources, ScoutMemory } from '@dzhechkov/scout';
 const USAGE = `dz - DZ cross-platform harness CLI
@@ -48,6 +48,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 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 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)
   dz backlog show <id> [--project <dir>] [--json]                          (full record for one idea)
@@ -1227,11 +1228,26 @@ function cmdUsage(options, optionLists, flags, cwd, write) {
             };
             if (hasModelLimits && u.weeklyByModel !== undefined)
                 payload.weeklyByModel = u.weeklyByModel;
+            // re-QE debt surfacing (backlog 6b40e667 — QE #9: the json contract must carry the debt too,
+            // a probe is exactly the consumer that needs it). The field appears ONLY when a debt exists,
+            // so the zero-debt contract stays byte-identical to the pinned legacy shape. Best-effort.
+            try {
+                const reqeCount = scanReqeDebts(resolve(cwd, options.get('project') ?? '.')).debts.length;
+                if (reqeCount > 0)
+                    payload.reqeDue = reqeCount;
+            }
+            catch { /* advisory only */ }
             write(JSON.stringify(payload));
             return 0;
         }
         if (u.sessionPct === null && u.weeklyPct === null) {
             write('usage: unconfigured — set memory.usage.sessionTokenLimit / weeklyTokenLimit in .dz/config.json (percentages are ESTIMATES calibrated from observed exhaustion)');
+            try {
+                const reqe = scanReqeDebts(resolve(cwd, options.get('project') ?? '.'));
+                if (reqe.debts.length > 0)
+                    write('re-QE due: ' + reqe.debts.length + ' usage-switched run(s) kept same-family QE — run `dz reqe` for the cross-family pass');
+            }
+            catch { /* advisory only */ }
             return 0;
         }
         // Compact human line — a short HH:MM / weekday hint on the resets, best-effort.
@@ -1249,6 +1265,14 @@ function cmdUsage(options, optionLists, flags, cwd, write) {
         const binding = hasModelLimits && u.weeklyBindingModel !== undefined ? ' ' + u.weeklyBindingModel + '-bound' : '';
         const w = u.weeklyPct === null ? 'n/a' : '~' + u.weeklyPct + '%' + binding;
         write('usage: session ' + s + ' (resets ' + clock(u.sessionResetsAt) + ') · week ' + w + ' (resets ' + clock(u.weeklyResetsAt) + ') · estimated');
+        // re-QE debt surfacing (backlog 6b40e667): the moment someone checks usage is the moment a
+        // usage-switched self-review debt should be visible. Best-effort — never breaks the contract.
+        try {
+            const reqe = scanReqeDebts(resolve(cwd, options.get('project') ?? '.'));
+            if (reqe.debts.length > 0)
+                write('re-QE due: ' + reqe.debts.length + ' usage-switched run(s) kept same-family QE — run `dz reqe` for the cross-family pass');
+        }
+        catch { /* advisory only */ }
         return 0;
     }
     catch {
@@ -5926,6 +5950,213 @@ function nameFor(t, outcome) {
  * `dz score --slug <feature>` — score a feature-adr RUN's process discipline from its artifacts
  * (feature dz-score, Reading C). Descriptive-only: exit 0 on any score; non-zero only on usage errors.
  */
+/** Scan features/<slug>/.fa-state/reqe-due.json under a project root. Symlinked ANCESTOR dirs are
+ * skipped too, not just the leaf (Codex QE #5 — a symlinked feature dir could smuggle an outside
+ * debt); an oversized or non-regular due-file counts as MALFORMED, never a silent skip (QE #8);
+ * a debt whose embedded slug differs from its directory is MALFORMED — identity is the directory,
+ * the JSON only confirms it (QE #4: an embedded foreign slug must not redirect settlement). */
+function scanReqeDebts(root) {
+    const out = [];
+    let malformed = 0;
+    const featuresDir = join(root, 'features');
+    let slugs = [];
+    try {
+        if (lstatSync(featuresDir).isSymbolicLink())
+            return { debts: [], malformed: 0 }; // r2 #4: features/ itself
+        slugs = readdirSync(featuresDir);
+    }
+    catch {
+        return { debts: [], malformed: 0 };
+    }
+    for (const slug of slugs.sort()) {
+        const dir = join(featuresDir, slug);
+        const stateDir = join(dir, '.fa-state');
+        const duePath = join(stateDir, 'reqe-due.json');
+        try {
+            if (lstatSync(dir).isSymbolicLink() || lstatSync(stateDir).isSymbolicLink())
+                continue;
+        }
+        catch {
+            continue; // no feature dir / no state dir — nothing to scan
+        }
+        let st;
+        try {
+            st = lstatSync(duePath);
+        }
+        catch {
+            continue; // no due-file — the common, silent case
+        }
+        if (!st.isFile() || st.size > 64 * 1024) {
+            malformed++; // exists but is not a plain small file — named, never silently dropped
+            continue;
+        }
+        try {
+            const debt = parseReqeDebt(readFileSync(duePath, 'utf-8'));
+            if (debt && debt.slug === slug)
+                out.push({ debt, duePath, dir });
+            else
+                malformed++;
+        }
+        catch {
+            malformed++;
+        }
+    }
+    return { debts: out, malformed };
+}
+/**
+ * `dz reqe` — the re-QE debt ledger (backlog 6b40e667): list usage-switched same-family QE debts,
+ * print the cross-family review brief, settle FAIL-CLOSED against a graded report.
+ */
+function cmdReqe(options, flags, cwd, write) {
+    const json = flags.has('json');
+    if (flags.has('help')) {
+        const usage = 'dz reqe [--slug <feature> [--done --report <file>]] [--project <dir>] [--json]';
+        if (json)
+            write(JSON.stringify({ help: usage, exitCode: 0 }));
+        else {
+            write(usage + ' — the re-QE debt ledger');
+            write('  (no args)              list unsettled debts (runs whose Step-8 QE ran on the coder’s own family under the usage override)');
+            write('  --slug <s>             print the ready cross-family review brief for one debt');
+            write('  --slug <s> --done --report <file>   settle the debt — FAIL-CLOSED: requires an existing, non-trivial, GRADED report; appends the settlement to 08_qe_report.md');
+            write('  ' + REQE_SCOPE);
+        }
+        return 0;
+    }
+    for (const flag of flags) {
+        if (!new Set(['json', 'help', 'done']).has(flag)) {
+            write(json ? JSON.stringify({ error: `unknown option --${flag}`, exitCode: 1 }) : `dz reqe: unknown option --${flag}\n  allowed: --slug <feature>, --done, --report <file>, --project <dir>, --json`);
+            return 1;
+        }
+    }
+    for (const key of options.keys()) {
+        if (key.startsWith('_positional_') || !new Set(['slug', 'report', 'project']).has(key)) {
+            const what = key.startsWith('_positional_') ? `unexpected argument "${options.get(key)}"` : `unknown option --${key}`;
+            write(json ? JSON.stringify({ error: what, exitCode: 1 }) : `dz reqe: ${what}`);
+            return 1;
+        }
+    }
+    const root = resolve(cwd, options.get('project') ?? '.');
+    const slug = options.get('slug') ?? '';
+    if (slug !== '' && (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(slug) || slug.includes('..'))) {
+        write(json ? JSON.stringify({ error: 'a plain --slug <feature> is required (no path separators)', exitCode: 1 }) : 'dz reqe: a plain --slug <feature> is required (no path separators)');
+        return 1;
+    }
+    const { debts, malformed } = scanReqeDebts(root);
+    if (slug === '') {
+        if (flags.has('done')) {
+            write(json ? JSON.stringify({ error: '--done requires --slug', exitCode: 1 }) : 'dz reqe: --done requires --slug <feature>');
+            return 1;
+        }
+        if (json)
+            write(JSON.stringify({ debts: debts.map((d) => d.debt), malformed, scope: REQE_SCOPE, exitCode: 0 }));
+        else
+            for (const line of renderReqeList(debts.map((d) => d.debt), malformed))
+                write(line);
+        return 0;
+    }
+    const hit = debts.find((d) => d.debt.slug === slug) ?? null;
+    if (!hit) {
+        // distinguish "no debt file" from "malformed debt file" — a corrupt debt must be named
+        const duePath = join(root, 'features', slug, '.fa-state', 'reqe-due.json');
+        const exists = existsSync(duePath);
+        const msg = exists
+            ? `debt file at features/${slug}/.fa-state/reqe-due.json is MALFORMED — inspect it manually (a corrupt debt is named, never auto-cleared)`
+            : `no re-QE debt recorded for "${slug}"`;
+        write(json ? JSON.stringify({ error: msg, exitCode: 1 }) : `dz reqe: ${msg}`);
+        return 1;
+    }
+    if (!flags.has('done')) {
+        const brief = buildReqeBrief(hit.debt, join('features', slug));
+        if (json)
+            write(JSON.stringify({ debt: hit.debt, brief, exitCode: 0 }));
+        else {
+            write(brief.header);
+            for (const line of brief.instructions)
+                write('  ' + line);
+            if (brief.codexCmdTemplate)
+                write('  codex template: ' + brief.codexCmdTemplate);
+            write('  ' + REQE_SCOPE);
+        }
+        return 0;
+    }
+    // --done: FAIL-CLOSED settlement
+    const reportOpt = options.get('report') ?? '';
+    if (reportOpt === '') {
+        write(json ? JSON.stringify({ error: '--done requires --report <file> (the cross-family re-QE report)', exitCode: 1 }) : 'dz reqe: --done requires --report <file>');
+        return 1;
+    }
+    const reportPath = resolve(root, reportOpt);
+    const qeReportPath = join(hit.dir, '08_qe_report.md');
+    // QE #1: the run's OWN same-family Step-8 report must never settle its own debt — the exact
+    // laundering this ledger exists to prevent. Compared by REAL path so a symlink cannot alias it.
+    try {
+        const sameReal = realpathSync(reportPath) === realpathSync(qeReportPath);
+        // r2 #1: a HARD LINK to the same report has a different path but the same inode — compare
+        // dev+ino, not just resolved paths
+        const rSt = statSync(reportPath);
+        const qSt = statSync(qeReportPath);
+        const sameInode = rSt.dev === qSt.dev && rSt.ino === qSt.ino;
+        if (sameReal || sameInode) {
+            write(json ? JSON.stringify({ error: 'the report IS this run’s own 08_qe_report.md (same file/inode) — the same-family review cannot settle its own debt; provide the independent cross-family report', exitCode: 1 }) : 'dz reqe: the report IS this run’s own 08_qe_report.md (same file/inode) — the same-family review cannot settle its own debt (fail-closed)');
+            return 1;
+        }
+    }
+    catch { /* one of the two does not resolve — the reads below decide */ }
+    let reportText = '';
+    try {
+        const st = lstatSync(reportPath);
+        if (!st.isFile())
+            throw new Error('not a regular file'); // symlinked report refused (QE #5)
+        reportText = readFileSync(reportPath, 'utf-8');
+    }
+    catch {
+        write(json ? JSON.stringify({ error: `report not readable at ${reportOpt} (must be a regular file, not a symlink) — refusing to settle`, exitCode: 1 }) : `dz reqe: report not readable at ${reportOpt} (must be a regular file, not a symlink) — refusing to settle (fail-closed)`);
+        return 1;
+    }
+    const settlement = settleReqeDebt(hit.debt, reportText, reportOpt);
+    if (!settlement.ok || settlement.epilogue === null) {
+        write(json ? JSON.stringify({ error: settlement.error, exitCode: 1 }) : `dz reqe: ${settlement.error}`);
+        return 1;
+    }
+    // QE #6 ordering: rotate the debt FIRST, append the human-readable epilogue LAST — a crash may
+    // leave a settled debt without its epilogue (recoverable from reqe-settled.json), never an
+    // epilogue claiming clearance while the debt is still live.
+    const settledBase = join(hit.dir, '.fa-state', 'reqe-settled');
+    let settledPath = settledBase + '.json';
+    for (let n = 2; existsSync(settledPath); n++)
+        settledPath = settledBase + '-' + n + '.json'; // never overwrite prior evidence
+    try {
+        const settled = { ...hit.debt, settledGrade: settlement.grade, settledReport: reportOpt };
+        writeFileSync(settledPath, JSON.stringify(settled) + '\n', { flag: 'wx' }); // wx: never through a planted symlink
+        try {
+            unlinkSync(hit.duePath);
+        }
+        catch (e) {
+            // r2 #5: a failed unlink must not leave a settled marker beside a live debt — roll back
+            try {
+                unlinkSync(settledPath);
+            }
+            catch { /* best-effort rollback */ }
+            throw e;
+        }
+    }
+    catch {
+        write(json ? JSON.stringify({ error: 'could not rotate the debt file — debt NOT cleared, nothing was appended', exitCode: 1 }) : 'dz reqe: could not rotate the debt file — debt NOT cleared, nothing was appended (fail-closed)');
+        return 1;
+    }
+    try {
+        if (lstatSync(qeReportPath).isSymbolicLink())
+            throw new Error('symlinked 08_qe_report.md');
+        appendFileSync(qeReportPath, settlement.epilogue);
+    }
+    catch {
+        write(json ? JSON.stringify({ settled: true, grade: settlement.grade, warning: 'debt cleared (see .fa-state/reqe-settled*.json) but the epilogue could NOT be appended to 08_qe_report.md — append it manually', exitCode: 0 }) : 'dz reqe: debt cleared (evidence in .fa-state/) but the epilogue could NOT be appended to 08_qe_report.md — append it manually');
+        return 0;
+    }
+    const okMsg = `debt settled: re-QE grade ${settlement.grade} (report ${reportOpt}) — settlement appended to features/${slug}/08_qe_report.md`;
+    write(json ? JSON.stringify({ settled: true, grade: settlement.grade, exitCode: 0 }) : `dz reqe: ${okMsg}`);
+    return 0;
+}
 function cmdScore(options, flags, cwd, write) {
     const json = flags.has('json');
     if (flags.has('help')) {
@@ -6003,10 +6234,25 @@ function cmdScore(options, flags, cwd, write) {
     };
     walk(dir, '', 0);
     const card = scoreRun(slug, artifacts);
+    // re-QE debt note (backlog 6b40e667): a scorecard that praised cross-model QE while an unsettled
+    // same-family debt sits on disk would be half the truth. PARSED, not existence-guessed (QE #9);
+    // a malformed debt file is named. Advisory in both modes — never moves the score or exit code.
+    let reqeNote = null;
+    {
+        const scan = scanReqeDebts(root);
+        const mine = scan.debts.find((d) => d.debt.slug === slug);
+        if (mine)
+            reqeNote = 'UNSETTLED re-QE debt — Step-8 ran same-family under the usage override; run `dz reqe --slug ' + slug + '`';
+        else if (existsSync(join(dir, '.fa-state', 'reqe-due.json')))
+            reqeNote = 'a reqe-due.json exists but is MALFORMED/mismatched — inspect features/' + slug + '/.fa-state/ manually';
+    }
     if (json)
-        write(JSON.stringify({ ...card, exitCode: 0 }, null, 2));
-    else
+        write(JSON.stringify({ ...card, reqeDebt: reqeNote, exitCode: 0 }, null, 2));
+    else {
         write(renderScorecard(card));
+        if (reqeNote)
+            write('note: ' + reqeNote);
+    }
     return 0;
 }
 /**
@@ -7603,6 +7849,8 @@ export async function runCli(argv, io = {}) {
                 return cmdEpochReplay(options, flags, cwd, write);
             case 'score':
                 return cmdScore(options, flags, cwd, write);
+            case 'reqe':
+                return cmdReqe(options, flags, cwd, write);
             case 'backlog':
                 return await cmdBacklog(options, flags, cwd, write);
             case 'routing':