@dzhechkov/harness-cli 0.3.258 → 0.3.260

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]
@@ -964,7 +999,7 @@ dz teach             "<pattern>" [--reward <0-1>] [--domain <name>] [--type rule
 dz teach --reinforce "<dzId-or-exact-text>" [--project <dir>] # bump an existing learned pattern instead of writing a near-duplicate
 dz teach --from-json <file> [--project <dir>] [--no-mirror] [--harmonize]   # bulk-import a `dz recall --all --json` export; prints a harmonize dry-run advisory
 dz consolidate       [--sessions-dir <dir>] [--project <dir>] [--no-mirror]
-dz recall            "<query>" [--limit <N>] [--semantic | --no-semantic] [--project <dir>]   # hybrid lexical+vector when the vector tier is enabled
+dz recall            "<query>" [--limit <N>] [--domain <name>] [--semantic | --no-semantic] [--project <dir>]   # hybrid lexical+vector when the vector tier is enabled; --domain BOOSTS same-domain lessons (never filters)
 dz recall --all      [--json] [--stats]             # export the WHOLE learned store, or inspect learning stats/top uses
 dz recall --books    "<query>" [--book <slug>]      # digitized-book KUs; --book narrows to one book
 dz vector status     [--project <dir>] [--json]     # semantic tier: engine availability, mirrored vs lexical counts, pending queue
@@ -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
@@ -2311,6 +2347,36 @@ guard, `--loc-cap <n>` tunes, default 700), **secret-scan** (the same high-signa
 edit caps/paths/waivers in `guards.config.json`; the project-critic role should then *not* re-flag these
 rules, only waivers without a reason.
 
+### Domain-scoped recall — `--domain <name>` (a boost, never a filter)
+
+**When to use it.** One brain store, more than one *kind* of work. `dz teach --domain` has always
+recorded a domain, but until now the ranking ignored it — so medical-research lessons and coding
+lessons came back interleaved, and the dilution grew with the store.
+
+```bash
+dz recall "signature" --limit 3 --domain security
+#   dz recall "signature"  —  3 hit(s), SQLite FTS5 + vector (agentdb) ranking
+#     [0.90] (security) ⟨both⟩ Crypto anti-hallucination anti-pattern: verifying a signature …
+#     [0.85] (publishing) ⟨both⟩ ⚠q 'Re-sign LAST' applies to EVERY signed pack a sweep touches …
+#     [0.80] (testing) ⟨vector⟩ A structural registry-coverage test that only checks key-SET …
+#     domain "security": 1 exact match(es); the order was already correct — nothing moved;
+#     foreign-domain lessons kept (a boost, not a filter)
+
+dz recall "signature" --limit 3 --domain health-research
+#     domain "health-research": no lesson in this result carries it — order unchanged, nothing was hidden
+```
+
+**Why a boost and not a filter.** Cross-domain transfer is the reason one shared store beats two
+separate ones: *"a reviewer's evidence needs the same execute-don't-describe discipline as your own
+claims"* was learned reviewing code and applies verbatim to medical sources. A filter would cut
+exactly those transfers. So matching hits move UP — at most **2 places** for an exact domain, **1**
+for a hierarchical relative (`health` ↔ `health-research`) — and nothing is ever dropped: the hit
+count with `--domain` equals the hit count without it.
+
+The bound matters: a domain tag is a hint about relevance, not evidence of it, so it breaks near-ties
+instead of overruling lexical ranking. And the note is honest in both directions — it says when
+nothing matched, and it distinguishes *matched* from *actually moved*.
+
 ### Semantic recall (vector tier)
 
 `dz recall` is **hybrid** when the vector tier is available and **exactly the old lexical command** when it is not — enabling it never changes behavior for projects that skip it.
@@ -2729,7 +2795,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;AA8XH,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;AAk3O9E,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, applyDomainBoost, countDisplacedByCut, renderDomainBoostNote, renderDomainCutNote, 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)
@@ -60,7 +61,7 @@ Usage:
   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)
   dz consolidate [--sessions-dir <dir>] [--project <dir>] [--no-mirror] [--prune-noise [--apply]] [--prune-quarantine [--apply]]   (both prunes: DRY-RUN by default; --apply snapshots then deletes; prune-quarantine = expired unproven lessons ONLY, never coupled to noise)
-  dz recall "<query>" [--limit <N>] [--semantic | --no-semantic] [--books [--book <slug>]] [--project <dir>] | dz recall --all [--json] | dz recall --usage [--json] | dz recall --forget <dzId>[,<dzId>] [--apply] | dz recall --promote <dzId>[,<dzId>] [--apply]   (forget/promote: dry-run default; forget snapshots before removing; promote lifts lesson-quarantine)
+  dz recall "<query>" [--limit <N>] [--domain <name>] [--semantic | --no-semantic] [--books [--book <slug>]] [--project <dir>] | dz recall --all [--json] | dz recall --usage [--json] | dz recall --forget <dzId>[,<dzId>] [--apply] | dz recall --promote <dzId>[,<dzId>] [--apply]   (--domain <name> BOOSTS lessons of that domain without dropping foreign ones — a shared store keeps its cross-domain transfers; forget/promote: dry-run default; forget snapshots before removing; promote lifts lesson-quarantine)
   dz vector status [--project <dir>] [--json]                          (semantic tier: engine, mirrored vs lexical counts, pending queue)
   dz vector reindex [--project <dir>] [--json]                         (snapshot, re-embed learned-pattern vectors, stamp current model)
   dz vector export <path> [--project <dir>]                            (portable VECTOR form (.rvf, opt-in RVF engine); patterns ship via recall --all --json)
@@ -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 {
@@ -1818,13 +1842,30 @@ async function cmdRecall(options, flags, cwd, write) {
         : flags.has('no-semantic') || flags.has('lexical')
             ? 'lexical'
             : 'hybrid';
-    const result = await recallHybrid(projectRoot, query, { limit, mode });
+    const wantedDomain = options.get('domain');
+    // OVER-FETCH before boosting (Codex QE #5): the boost used to run on hits ALREADY
+    // truncated to `limit`, so an exact-domain lesson sitting at rank limit+1 could
+    // never receive its promised lift — the feature was weakest in exactly the case it
+    // exists for (foreign-domain dilution pushing a relevant lesson just past the cut).
+    // Fetch a bounded surplus, re-rank, then trim to the limit the caller asked for.
+    const fetchLimit = wantedDomain !== undefined ? Math.min(limit * 3, limit + 20) : limit;
+    const result = await recallHybrid(projectRoot, query, { limit: fetchLimit, mode });
     if (mode === 'semantic' && result.vectorEngine === 'none') {
         // --semantic is an explicit ask — degrading it silently would be dishonest (FR-3).
         write(`dz recall --semantic: ${result.vectorReason ?? 'no vector engine available — run: dz setup --memory agentdb'}`);
         return 1;
     }
-    const hits = result.hits;
+    // Domain-aware re-ranking (health-advisor slice H): `--domain <name>` lifts lessons
+    // tagged with that domain WITHOUT dropping foreign ones — a boost, not a filter, so a
+    // shared store keeps the cross-domain transfers that make it worth more than two stores.
+    const boost = wantedDomain !== undefined ? applyDomainBoost(result.hits, wantedDomain) : null;
+    const hits = (boost ? boost.hits : result.hits).slice(0, limit);
+    // The boost never drops a hit, but the CUT still can: promoting a match into the top
+    // `limit` pushes the last one out, so a lesson visible WITHOUT --domain can vanish
+    // WITH it. Cross-model review called this out as a lie by omission — the note said
+    // "foreign-domain lessons kept" about the pre-cut list while the printed list was
+    // missing one. Count it and say so; the reader can act on it (raise --limit).
+    const displaced = boost !== null ? countDisplacedByCut(result.hits, boost.hits, limit) : 0;
     if (asJson) {
         // Portable contract UNCHANGED (I-7/AC-6): a plain PatternRecord[] — round-trips through
         // `dz teach --from-json` regardless of which backend ranked each hit.
@@ -1834,6 +1875,11 @@ async function cmdRecall(options, flags, cwd, write) {
     if (hits.length === 0) {
         write(`dz recall "${query}"`);
         write(`  No matching patterns (teach some with \`dz teach\`, or consolidate sessions).`);
+        // The domain note must print here too (Codex QE #10): a --domain run with zero hits
+        // silently said nothing about the domain, so the reader could not tell whether the
+        // boost had been applied and found nothing, or had not run at all.
+        if (boost !== null && wantedDomain !== undefined)
+            write(renderDomainBoostNote(boost, wantedDomain));
         return 0;
     }
     const vectorOn = result.vectorEngine !== 'none' && result.vectorError === undefined && mode !== 'lexical';
@@ -1846,12 +1892,26 @@ async function cmdRecall(options, flags, cwd, write) {
         const qTag = h.quarantined === true ? ' ⚠q' : '';
         if (h.quarantined === true)
             sawQuarantined = true;
-        write(`  [${h.pattern.reward.toFixed(2)}] (${h.pattern.domain})${backendTag}${qTag} ${h.pattern.pattern.slice(0, 80)}`);
+        // ONE line per hit, always. A lesson may contain newlines, and printing them raw
+        // let stored CONTENT forge lines that look like the tool's own output — including
+        // the domain-boost note that learning_bridge.py reads as a capability probe. Any
+        // consumer that parses this output line-wise has the same exposure, so the fix
+        // belongs at the point of rendering rather than in each reader.
+        const oneLine = h.pattern.pattern.replace(/[\r\n]+/g, ' ⏎ ').slice(0, 80);
+        write(`  [${h.pattern.reward.toFixed(2)}] (${h.pattern.domain})${backendTag}${qTag} ${oneLine}`);
     }
     if (sawQuarantined) {
         // The loop stays VISIBLE (ADR D2): a quarantined hit is shown, marked, and explained.
         write('  ⚠q = quarantined (unproven hypothesis, rank damped) — confirm with dz teach --reinforce, or dz recall --promote <dzId> --apply');
     }
+    if (boost !== null && wantedDomain !== undefined) {
+        // Say what the boost did — INCLUDING when it did nothing. A silent reorder would
+        // let the reader believe the ranking was domain-aware when it had no match to work with.
+        write(renderDomainBoostNote(boost, wantedDomain));
+        const cutNote = renderDomainCutNote(displaced, limit);
+        if (cutNote !== '')
+            write(cutNote);
+    }
     if (result.vectorError !== undefined && mode !== 'lexical') {
         // Engine present but the semantic leg failed/timed out — one honest line, exit 0 (05 §2.3).
         write(`  ℹ vector search degraded: ${result.vectorError} — showing lexical ranking`);
@@ -5926,6 +5986,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 +6270,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 +7885,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':