@dzhechkov/harness-cli 0.7.8 → 0.8.1

package/src/cli.ts

@@ -302,6 +302,9 @@ import {
   renderContentProbe,
   findNonRegistrableSkillDirs,
   assembleCompoundingReport,
+  banditStats,
+  narrowBanditReport,
+  renderBanditHealth,
   // Cold-vs-warm EPOCH RUNNER (feature epoch-replay) — orchestrates + scores, never calls a model.
   replayableInstances,
   buildWorkOrder,
@@ -430,6 +433,8 @@ import {
   parseMutationRegistry,
   applyMutationToText,
   countFailingTests,
+  detectSuiteCompletionReceipt,
+  detectSuiteReceiptMismatch,
   classifyBaseline,
   classifyRunFailure,
   classifyMutationOutcome,
@@ -460,7 +465,33 @@ import {
   buildCadenceReport,
   tgVisibleSha256,
   CADENCE_WINDOW_DAYS,
+  readQeRounds,
+  QE_ROUNDS_DEFAULT_CEILING,
+  describeStoreLocation,
+  storeLocationLine,
+  resolveTeachTarget,
+  teachReasonPhrase,
+  readTeachToConfig,
+  TeachTargetError,
+  mergeStoreHits,
+  sameStore,
+  globalStoreRoot,
+  storeCountLabel,
+  // operator-profile (ADR-001): per-user 0600 store + marked block in ~/.claude/CLAUDE.md
+  renderProfileBlock,
+  readProfile,
+  writeProfile,
+  syncProfileBlock,
+  checkProfileDrift,
+  parseRegister,
+  registerOwnerWord,
+  profileAgeDays,
+  parseDomainList,
+  domainListText,
+  parseYesNo,
+  REGISTERS,
 } from '@dzhechkov/harness-core';
+import type { OperatorProfile, Domain as ProfileDomain, Register as ProfileRegister } from '@dzhechkov/harness-core';
 import type { RecordKind, RecordDecision } from '@dzhechkov/harness-core';
 import type { CadenceWindow } from '@dzhechkov/harness-core';
 import type { MutationEntryResult, MutationObservation, MutationRegistryEntry } from '@dzhechkov/harness-core';
@@ -515,12 +546,19 @@ Usage:
   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 recap [--day|--week|--month] [--at <ISO date>] [--project <dir>] [--json]   (what was done over a window, from records only: deliveries with the grade an independent review STATED — a report naming two grades is reported ambiguous, never guessed — registry publishes, gate verdicts, knowledge reuse. --quarter/--half-year/--year are RECOGNISED and REFUSED with the real span in days: there is one complete quarter and the longest record is 174 days. Every section carries its own data-start date, and "the source was not read" never prints as zero. Contaminated measures — commit count, lines, tokens, learning-event volume, inventory counts, lesson count — are not computed, and the report says so. exit 0 reported / 2 refused)
   dz cadence [--window day|week|month|quarter|halfyear|year] [--json]   (the WHAT-SHIPPED aggregator: graded-shipment cadence by ISO week + npm-publish cadence (recap cache) + guard repeat decay on the FIXED rule set + recall reuse; a window deeper than 2× the record is REFUSED with the depth named (ADR: a cadence from one point is scale forgery); exit 0 report / 2 refused-window / 1 usage)
+  dz qe-rounds (--slug <feature> | --feature-dir <abs>) [--ceiling <n>] [--project <dir>] [--json]   (how many Step-8 review rounds has this feature ALREADY had? Reads what dz qe-bridge already wrote — signoff-<runId>.json and failed-*.json under features/<slug>/.fa-state/qe-bridge — and writes nothing itself, so it can answer for runs already past. A round is a runId, not a file; an attempt with no verdict is counted SEPARATELY and never merged; an unreadable record is NAMED and the count is declared a LOWER BOUND. ONE directory, never a union across checkouts. exit 0 under the ceiling / 1 at-or-over — owner decides, the command does not judge whether the rounds were warranted / 2 NOT ESTABLISHED, which is never "zero rounds")
   dz tg-post --draft <file.html> [--manifest <sources.json>] [--channel <@name|id>] [--send --yes] [--night] [--preview] [--json]   (the sender for an APPROVED channel post, per the accepted genai-tweets-channel ADRs: HTML mode only — never MarkdownV2; link preview OFF by default (x.com previews in Telegram are broken); the 00:00-06:00 MSK quiet window refuses without an explicit --night. DEFAULT IS A DRY-RUN: it validates the draft (tag balance, allowed tags, bare &/<, the 4096 visible-character limit with the overshoot counted) and runs the provenance gate over --manifest IN-PROCESS — a draft with no manifest is refused as unchecked, and anything but ALLOWED refuses. A real send needs --send --yes, stating ADR-004's manual-publishing decision out loud each time. The token comes from TELEGRAM_BOT_TOKEN or telegram.tokenFile in .dz/config.json and is never printed. exit 0 sent or clean dry-run / 1 refused or Telegram error / 2 usage)
   dz name-check [--command <n>] [--module <basename>] [--export <a,b>] [--project <dir>] [--json]   (is this name free, BEFORE a line of code? Scans workspace SOURCE — never dist, because a stale build answers 'free' confidently. Checks a dz command name against the dispatcher AND the help block, a module basename against every package's src/, and exported identifiers against every declaration in the workspace. exit 0 all free / 1 at least one taken, naming where / 2 nothing asked or the scan did not run — an empty sweep is never a clean bill. Honest limit, printed on the passing path: it reads declarations, so a re-export under a different name stays the build's job)
   dz provenance-check --manifest <sources.json> [--project <dir>] [--json]   (nothing goes out citing a source that may not leave this machine. Checks PROVENANCE, not words: every claim names its source, and only a KNOWN kind that resolves safely is cleared. Repo paths go through 'git -C <root> check-ignore' over the RESOLVED path — a symlink into an ignored directory is REFUSED (git classifies the string and never dereferences, MEASURED), and the verdict does not change with your working directory. Store records must be named in the git-TRACKED provenance-public.json, so declaring one public is a reviewable commit rather than a field inside an ignored store. An undeclared kind is refused, never inferred from the path's shape. exit 0 allowed / 1 blocked / 3 NOT ESTABLISHED — an empty manifest, an unreadable one, or an oracle that did not run is never a pass. It proves what was CITED: it cannot see a paraphrase with no citation, nor confidential text pasted by hand into an allowed file)
+  dz project-skills [--project <dir>] [--json] [--stages-json]   (polymorphic feature-adr: resolve architecture/project-skills.json — fixed roles product-vision/critic/brand/impl-bar plus an open extra[] — into per-stage guidance. READ-ONLY. --project names the root explicitly, so it works from any cwd; without it the manifest is read from the current repo. No manifest ⇒ a byte-identical generic run)
+  dz discrimination-check --slug <slug> [--base <ref>] [--json]   (does the ADR's named test actually DISCRIMINATE? Re-runs it on a worktree at the pre-feature commit, where it MUST go red. A test that passes with the feature removed proves nothing; dz amendment-check proves the test exists, this proves it bites)
+  dz guard [check|promote|init] [--json] [--force]   (HARD/SOFT repo rules — readme-first, lockfile-in-sync, claim tagging — run automatically as a pre-flight inside dz publish. HARD blocks, SOFT warns)
+  dz architecture [--check --slug <s> --desc <text>] [--project <dir>] [--revise]   (the live product map + vision: --check is the soft Step-0 сверка of a new feature against them, reporting {signal,confidence} rather than blocking)
+  dz sbom [--pack <name>] [--out <file>]   (CycloneDX software bill of materials for the workspace, or for one pack with --pack)
   dz amendment-check --slug <slug> | --feature-dir <dir> | --all [--json]   (the deterministic Step-8 amendment gate: every AM-N row must resolve to a test found INSIDE the file the row names; the PLAN is authoritative when it carries rows, and an ideation amendment the plan drops is a failure. exit 0 pass/skip, 1 fail, 3 NOT-ESTABLISHED — a section that parsed ZERO rows is never a pass. --all is a CENSUS and always exits 0. Does NOT prove non-vacuity — that is dz discrimination-check)
   dz feature-adr-record --kind ledger|training-pair --stage <s> [--slug <s>] [--row|--pair <json>] [--mark <n>] [--once] [--json]   (the witnessed writer for the run-cost ledger and training pairs: the payload arrives as an ARGUMENT, never as shell; a malformed or wrong-kind payload is REFUSED before any write; the timestamp is stamped before serialising; the append is verified by re-reading the tail. exit 0 written|duplicate|skipped, 2 refused, 3 not-verified — a record failure is never blocking)
   dz feature-adr-checkpoint (--slug <feature> | --feature-dir <abs>) --stage <s> --input-hash <h> --result <json> [--artifact a,b] [--json]   (record a pipeline stage ONLY after measuring its artifacts on disk; refuses a null result, an absent artifact, or a stage that declares none — the subagent runs a COMMAND instead of hand-writing durable state)
+  dz profile [init|show|set|sync] [--json]   (WHO the assistant is talking to — per-user store at ~/.dz/profile.json (0600, NEVER in a project), delivered as a marked block in ~/.claude/CLAUDE.md so it loads in EVERY project, dz installed or not. init = five questions (language, register, deep/weak domains as comma lists — "networking (CCIE; NSX)" keeps the parenthetical as the note, Enter skips — teaches y/n with one re-ask, never a silent default); show ALWAYS prints the store path + age + drift verdict + the rendered block; set register|language|teaches <v> or set deep|weak add|rm <tag> [note] — register accepts the owner's own words (профи / профи лайт / просто), an unknown value is REFUSED naming the accepted set; sync re-writes the block (runs automatically after init/set; foreign content byte-for-byte, timestamped backup before every modifying write). The register changes FORM, never FACTS, and governs dialogue only — never ADRs/commits/QE reports; both rules are baked into the rendered block at every level. exit 0 done / 1 no profile or failed / 2 refused input)
   dz reqe [--slug <feature> [--done --report <f>]] [--json]   (the re-QE debt ledger: a usage-switched run whose Step-8 QE ran on the coder's OWN family records a debt; list debts, print the cross-family review brief, settle FAIL-CLOSED against a graded report — the settlement lands in 08_qe_report.md)
   dz qe-bridge --family claude --slug <feature> [--coder-family codex|claude] [--model <id>] [--files a,b] [--out <f>] [--timeout <s>] [--allow-same-family] [--json]   (the REVERSE QE bridge: run an INDEPENDENT Claude reviewer over a feature's Step-8 artifacts from ANY host — a Codex session included, plain shell, no Claude agent plane needed — and land a PARSED signoff. The reviewer runs ISOLATED: an EMPTY temp cwd plus --safe-mode --strict-mcp-config --tools '' --no-session-persistence, so no CLAUDE.md/skills/plugins/hooks/MCP load, and the verdict is read from the --output-format json RESULT ENVELOPE — text a session customization printed onto the same stdout can never become a signoff. Probes the model before trusting it; sends SCOPED extracts with a loud 200k-char ceiling (never silent truncation); the grade must AGREE across three LAST-anchored channels (terminal marker line, fenced qe-bridge-signoff JSON, the report's own GRADE line) AND the marker must be the FINAL content — empty, gradeless, self-contradicting or miscounted output is one of 18 NAMED failures with an audit record under features/<slug>/.fa-state/qe-bridge/ (runId, resolved executable + binOverride, prompt sha256, channel offsets, requestedOut, reportWritten, retained raw stdout; 0600 files in a 0700 dir), never a clean review. A --coder-family that contradicts the recorded reqe debt is refused. Writes features/<slug>/08b_reqe_report.md, which dz reqe --done settles unchanged. DISCLOSURE: the extracts you scope are sent to the Claude runtime; the bridge cannot classify secrets. DZ_QE_BRIDGE_CLAUDE_BIN is a TEST SEAM, not a flag. exit 0 signoff parsed (ANY grade — it reports, it does not gate) / 1 named failure / 2 usage)
   dz mutation-gate [--package <dir>] [--registry <file>] [--test-cmd "<cmd>"] [--only <id[,id]>] [--timeout <ms>] [--rebaseline per-entry|final] [--keep-scratch] [--json]   (prove each NAMED protection has a test that DISCRIMINATES: copy the package to a scratch dir, verify the baseline suite is green, apply each registry mutation, run the suite, REQUIRE red, restore. The red must be BEHAVIOURAL: a mutation that no longer parses is MUTATION_UNPARSEABLE; a red run whose OWN output reports a test FILE failing to load (node --test file-level not-ok with exitCode, vitest Failed Suites) is MUTATION_LOAD_FATAL — the signal comes from the same run as the failing count, never from a separate isolated import; red output whose shape matches no known runner is INCONCLUSIVE (a runner-coverage gap, loud, never PROVEN); a count far above the entry's bound is OVER_FAILING; a restored tree that does not reproduce green makes the entry INCONCLUSIVE (flaky). Mutation writes are realpath-contained to the scratch copy: a symlink escape or a node_modules/ target is refused (exit 2), the real tree is never written. A mutation that does not apply, a green suite, or an inconclusive run is a FAILURE — never a skip. exit 0 all proven / 1 gate failed / 2 setup error)
@@ -2633,6 +2671,76 @@ function cmdUsageByStage(
  * non-zero exit. `--project <dir>` scopes ONLY the `.dz/config.json` read/write; measurement is
  * account-wide (all projects).
  */
+/**
+ * dz qe-rounds — how many Step-8 review rounds has one feature already had?
+ *
+ * The stopping rule ("Max iterations: 3") lived ONLY as a sentence in a prose module, so every
+ * restart of the agent forgot it. MEASURED 2026-08-27: one real slug reached 38 graded rounds.
+ * This makes the rule answerable by a command instead of by memory — and the exit code ASKS the
+ * owner rather than concluding, because whether 38 rounds were warranted is not a thing a counter
+ * can know.
+ */
+function cmdQeRounds(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  const root = resolve(cwd, options.get('project') ?? '.');
+  const slug = (options.get('slug') ?? '').trim();
+  const dirOpt = (options.get('feature-dir') ?? '').trim();
+  if (!slug && !dirOpt) {
+    write('dz qe-rounds: need --slug <feature> or --feature-dir <abs path>');
+    return 2;
+  }
+  // One directory, never a union. MEASURED: the slug `package-story-page-hardening` exists in two
+  // checkouts holding 38 and 7 records; a tool that searched for the slug would report 45 for a run
+  // that had 38, and the output would look identical to a correct one.
+  const featureDir = dirOpt ? resolve(cwd, dirOpt) : join(root, 'features', slug);
+
+  const ceilingRaw = options.get('ceiling');
+  let ceiling = QE_ROUNDS_DEFAULT_CEILING;
+  if (ceilingRaw !== undefined) {
+    const n = Number(ceilingRaw);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+      write('dz qe-rounds: --ceiling must be a positive integer, got ' + JSON.stringify(ceilingRaw));
+      return 2;
+    }
+    ceiling = n;
+  }
+
+  const r = readQeRounds(featureDir, { ceiling });
+  if (flags.has('json')) {
+    write(JSON.stringify(r));
+    return r.status === 'not-established' ? 2 : r.status === 'at-or-over-ceiling' ? 1 : 0;
+  }
+
+  if (r.status === 'not-established') {
+    write('dz qe-rounds: NOT ESTABLISHED — ' + (r.notEstablishedReason ?? 'no readable records'));
+    write('  This is not "zero rounds". Nothing was measured, so nothing follows about continuing.');
+    if (r.unreadable.length) {
+      write('  unreadable record(s):');
+      for (const u of r.unreadable) write('    - ' + u.file + ' — ' + u.why);
+    }
+    return 2;
+  }
+
+  write('dz qe-rounds: ' + r.rounds + ' graded round(s), ceiling ' + r.ceiling
+    + (r.failedAttempts.length ? ', plus ' + r.failedAttempts.length + ' attempt(s) with no verdict' : ''));
+  write('  dir:    ' + r.dir);
+  if (r.firstAt && r.lastAt) write('  window: ' + r.firstAt + ' → ' + r.lastAt);
+  if (r.grades.length) write('  grades: ' + r.grades.join(' '));
+  if (r.unreadable.length) {
+    // Named, never silently skipped: a dropped record makes the count quietly too low, and in a
+    // counter whose job is to STOP a loop that fails open.
+    write('  ' + r.unreadable.length + ' unreadable record(s) — the count below is a LOWER BOUND:');
+    for (const u of r.unreadable) write('    - ' + u.file + ' — ' + u.why);
+  }
+  if (r.status === 'at-or-over-ceiling') {
+    write('  STOP: the ceiling is reached. The rule in 08-qe.md says the remaining gaps go to the');
+    write('  owner for a decision. This command does not judge whether the rounds were warranted —');
+    write('  it only makes sure the question gets asked.');
+    return 1;
+  }
+  write('  under the ceiling — another round is within the documented budget');
+  return 0;
+}
+
 function cmdCadence(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
   const root = resolve(cwd, options.get('project') ?? '.');
   const windowRaw = (options.get('window') ?? 'week').trim() as CadenceWindow;
@@ -2797,8 +2905,66 @@ function cmdUsage(
   }
 }
 
-async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): Promise<number> {
+/**
+ * Which store a learning WRITE belongs to, resolved once and shared.
+ *
+ * `dz retro` reads a recurrence ledger and then calls `cmdTeach` to append to it. Before this
+ * helper existed, a session mode split the two: the ledger was read from the project while the
+ * write went to the home store, so the recurrence count never advanced and the drill threshold
+ * could never be reached (cross-family QE, 2026-08-27). A read and its write must resolve the
+ * same way or the counter they share is a fiction.
+ */
+function resolveLearningStore(
+  options: Map<string, string>, cwd: string,
+): { projectRoot: string; storeRoot: string; target: ReturnType<typeof resolveTeachTarget> } {
   const projectRoot = resolve(cwd, options.get('project') ?? '.');
+  const target = resolveTeachTarget({
+    flag: options.get('to'),
+    env: process.env.DZ_LEARN,
+    config: readTeachToConfig(projectRoot),
+  });
+  return {
+    projectRoot,
+    storeRoot: target.store === 'global' ? globalStoreRoot() : projectRoot,
+    target,
+  };
+}
+
+/** The store line for a learning write, carrying the path AND what chose it. */
+function learningStoreLine(
+  storeRoot: string, projectOption: string | undefined,
+  target: ReturnType<typeof resolveTeachTarget>, verb: 'written' | 'read',
+): string {
+  const reason = teachReasonPhrase(target.reason);
+  return storeLocationLine(
+    describeStoreLocation(storeRoot, projectOption, target.store === 'global' ? 'global' : undefined),
+    verb,
+  ) + (reason ? '  [' + reason + ']' : '');
+}
+
+async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): Promise<number> {
+  // WHICH store this lesson belongs to, and WHO decided (teach-chooses-its-store).
+  // `--to` → `DZ_LEARN` → `.dz/config.json` learning.teachTo → project. The owner asked for a
+  // per-session choice; for a CLI every invocation is a fresh process, so the only honest session
+  // is the shell, and the only honest session state is an environment variable.
+  // An unknown value is REFUSED here rather than defaulted: `DZ_LEARN=globl` silently writing to
+  // the project store would be precisely the invisible mislabel this mode exists to prevent.
+  let resolved;
+  try {
+    resolved = resolveLearningStore(options, cwd);
+  } catch (e) {
+    if (e instanceof TeachTargetError) { write('dz teach: ' + e.message); return 1; }
+    throw e;
+  }
+  // The default keeps writing exactly where it wrote before this feature existed — MEASURED: this
+  // repo's own store holds 361 records written under that behaviour, and every other user's store
+  // is the same. Only an explicit choice moves it.
+  const { storeRoot, target: teachTarget } = resolved;
+  // The verb is per OUTCOME, not per command: a harmonize dry-run and a failed --reinforce READ
+  // the store and change nothing, so saying "written" there is a false claim about what happened
+  // (cross-family QE round 2, 2026-08-27).
+  const storeLine = (verb: 'written' | 'read'): string =>
+    learningStoreLine(storeRoot, options.get('project'), teachTarget, verb);
 
   // Vector tier (dz-rvf-vector-bridge FR-1): best-effort mirror AFTER the lexical write is
   // durable (I-3). Auto-gated on the agentdb memory backend / an explicit vector-engine config
@@ -2825,7 +2991,15 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
   // learned store. ONE implementation (harmonizeVectorStore), two entry points (QR-6). Routed
   // BEFORE the --from-json / single-teach paths. Dry-run by default; --apply after a backup.
   if (flags.has('harmonize')) {
-    return runHarmonize(projectRoot, options, flags, write);
+    // `--harmonize --apply` MUTATES this store. A forgotten session mode pointing it at ~/.dz
+    // and saying nothing was the exact hazard this feature exists to close (cross-family QE).
+    // Suppressed under --json: this line ahead of the report made stdout unparseable, which is a
+    // worse defect than the invisibility it was closing (measured live, cross-family QE round 2).
+    if (!flags.has('json')) write(storeLine(flags.has('apply') ? 'written' : 'read'));
+    return runHarmonize(storeRoot, options, flags, write, {
+      store: join(storeRoot, '.dz'),
+      storeChosenBy: teachTarget.reason,
+    });
   }
 
   // Bulk import: `dz teach --from-json <file>` ingests a `dz recall --all --json`
@@ -2852,7 +3026,7 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
       write('dz teach --from-json: expected a JSON array (produced by `dz recall --all --json`)');
       return 1;
     }
-    const existing = new Set(loadStorePatternsSync(projectRoot).map((p) => p.pattern));
+    const existing = new Set(loadStorePatternsSync(storeRoot).map((p) => p.pattern));
     let imported = 0;
     let skipped = 0;
     const importedRecs: PatternRecord[] = [];
@@ -2870,7 +3044,7 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
         ts: typeof p.ts === 'string' ? p.ts : new Date().toISOString(),
         source: 'dz-teach-import',
       };
-      await recordPattern(projectRoot, rec);
+      await recordPattern(storeRoot, rec);
       existing.add(p.pattern);
       importedRecs.push(rec);
       imported += 1;
@@ -2880,7 +3054,7 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
     // Carrying a brain to a new machine goes through this path, and the mirror gate is the SAME one
     // teach uses — so without a config the whole import lands unindexed while `vector status` still
     // prints `pending: 0`. Say it here, where the user can act on it (FR-6).
-    if (imported > 0 && !flags.has('no-mirror') && !vectorMirrorEnabled(projectRoot)) {
+    if (imported > 0 && !flags.has('no-mirror') && !vectorMirrorEnabled(storeRoot)) {
       write(`  ⚠ the vector mirror writer is OFF — these ${imported} pattern(s) are LEXICAL ONLY`);
       write(`     enable it in .dz/config.json (memory.backend=agentdb), then run: dz vector reindex`);
     }
@@ -2888,8 +3062,8 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
     // a shared store as silently as a hand-typed teach — and it returned before the
     // advice single-teach prints. The same advice, at the same point in the flow: after
     // the write, naming the choice, blocking nothing.
-    let resolvedImportRoot = projectRoot;
-    try { resolvedImportRoot = realpathSync(projectRoot); } catch { /* unresolvable is not the brain */ }
+    let resolvedImportRoot = storeRoot;
+    try { resolvedImportRoot = realpathSync(storeRoot); } catch { /* unresolvable is not the brain */ }
     const importedMedical = importedRecs.filter(
       (r) => DEFAULT_HELD_OUT_DOMAINS.map(canonicalDomainKey).includes(canonicalDomainKey(r.domain)),
     );
@@ -2900,11 +3074,12 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
         write(advice);
       }
     }
-    write(`  Backend: memory (@dzhechkov/memory)  Total now: ${loadStorePatternsSync(projectRoot).length}`);
+    write(`  Backend: memory (@dzhechkov/memory)  Total now: ${loadStorePatternsSync(storeRoot).length}`);
+    write(storeLine('written'));
     // ONE batched mirror call through the same seam as single-teach (QR-6 — no bespoke path).
-    await emitMirror(projectRoot, importedRecs, 'dz-teach-import');
+    await emitMirror(storeRoot, importedRecs, 'dz-teach-import');
     if (imported > 0) {
-      const report = await harmonizeVectorStore(projectRoot, {});
+      const report = await harmonizeVectorStore(storeRoot, {});
       write(`  ℹ ${imported} imported — ${report.clusters.length} near-duplicate cluster(s): review with dz vector harmonize (dry-run); merge with dz vector harmonize --apply after backup`);
     }
     return 0;
@@ -2912,7 +3087,7 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
 
   const reinforce = options.get('reinforce');
   if (reinforce !== undefined && reinforce.trim() !== '') {
-    const backend = resolveLearningBackend(projectRoot);
+    const backend = resolveLearningBackend(storeRoot);
     const sampleReward = options.has('reward') ? parseFloat(options.get('reward') ?? '0.8') : undefined;
     backend.addSample({
       dzId: reinforce,
@@ -2924,8 +3099,9 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
     if (trained.flushed > 0) {
       write(`↳ reinforced ${reinforce}`);
       // lesson-quarantine: reinforcement IS promotion — keep the hook daemon's mirror in step.
-      const clearedQ = clearAgentdbQuarantine(projectRoot, [reinforce]);
+      const clearedQ = clearAgentdbQuarantine(storeRoot, [reinforce]);
       if (clearedQ.cleared > 0) write(`  ↳ promoted out of quarantine (mirror updated)`);
+      write(storeLine('written'));
       return 0;
     }
     // HIGH-fix: a no-match must NOT auto-teach the raw argument — callers pass dzIds or truncated
@@ -2934,6 +3110,9 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
     write(`dz teach --reinforce: no existing pattern matched ${JSON.stringify(reinforce)} — nothing reinforced`);
     write('  If this is a genuinely NEW lesson, teach it explicitly:  dz teach "<full lesson text>" --reward <0-1> --domain <area>');
     write('  To find the exact pattern to reinforce:  dz recall "<terms>"  (match by its full text)');
+    // WHICH store was searched — otherwise "no existing pattern matched" reads as "this lesson is
+    // new" when it may simply be sitting in the other store. `read`, because nothing was written.
+    write(storeLine('read'));
     return 1;
   }
 
@@ -2943,6 +3122,8 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
     write('  Example:   dz teach "Used DataLoader to fix N+1 query" --reward 0.9 --domain performance');
     write('  Import:    dz teach --from-json patterns.json   (bulk-import a `dz recall --all --json` export)');
     write('  Harmonize: dz teach --harmonize [--apply]       (semantic dedup — alias of dz vector harmonize; dry-run default)');
+    write('  Store:     dz teach "<lesson>" --to project|global   (project = this repo; global = ~/.dz, shared across every project)');
+    write('             session default: export DZ_LEARN=global   ·  project default: .dz/config.json → learning.teachTo');
     return 1;
   }
 
@@ -2950,9 +3131,9 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
   const domain = options.get('domain') ?? 'general';
 
   if (flags.has('guard')) {
-    const verdict = await teachGuard(projectRoot, pattern, { reward: Math.max(0, Math.min(1, reward)) });
+    const verdict = await teachGuard(storeRoot, pattern, { reward: Math.max(0, Math.min(1, reward)) });
     if (verdict.action === 'reinforce') {
-      const backend = resolveLearningBackend(projectRoot);
+      const backend = resolveLearningBackend(storeRoot);
       backend.addSample({ dzId: verdict.dzId, kind: 'reinforce', reward: Math.max(0, Math.min(1, reward)), ts: new Date().toISOString() });
       const trained = await backend.train();
       // HIGH-fix: only claim success when the reinforce actually FLUSHED. With backend 'off'
@@ -2960,7 +3141,7 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
       // teach below so the lesson is NEVER silently discarded (the exact silent-drop the ADR forbids).
       if (trained.flushed > 0) {
         write(`↳ reinforced existing pattern ${verdict.dzId} (cos=${verdict.cosine.toFixed(2)}) — not re-added`);
-        const clearedQ = clearAgentdbQuarantine(projectRoot, [verdict.dzId]);
+        const clearedQ = clearAgentdbQuarantine(storeRoot, [verdict.dzId]);
         if (clearedQ.cleared > 0) write('  ↳ promoted out of quarantine (mirror updated)');
         return 0;
       }
@@ -2992,27 +3173,35 @@ async function cmdTeach(options: Map<string, string>, flags: Set<string>, cwd: s
   // folds any legacy .dz/patterns.jsonl into the backend (idempotent) and returns the
   // total count. The lossy `npx agentdb add` dual-write was removed in Tier-1 (audit #6).
   // lesson-quarantine (opt-in): a fresh lesson is a HYPOTHESIS until it earns promotion.
-  const quarantineOn = readMemoryLearningConfig(projectRoot).quarantine;
-  const count = await recordPattern(projectRoot, entry, quarantineOn ? { quarantine: true } : {});
+  const quarantineOn = readMemoryLearningConfig(storeRoot).quarantine;
+  const count = await recordPattern(storeRoot, entry, quarantineOn ? { quarantine: true } : {});
 
   write(`Learned: "${pattern.slice(0, 60)}${pattern.length > 60 ? '...' : ''}"`);
   write(`  Domain: ${domain}  Reward: ${reward}  Backend: memory (@dzhechkov/memory)`);
   write(`  Total patterns: ${count}`);
+  // WHERE the write landed. MEASURED before this line existed: teach printed the pattern, the
+  // domain, the reward and the backend — and not one word about the path, so a store written to
+  // the wrong directory was indistinguishable from one written to the right one. A user running
+  // this in eight project directories gets eight isolated stores and believes they accumulate.
+  // ...and WHY that store. Without this a user who exported DZ_LEARN three hours ago and forgot
+  // sees a path, cannot tell what chose it, and has no reason to question it. `default` adds
+  // nothing, so the line stays byte-identical for everyone who set nothing.
+  write(storeLine('written'));
   // ADVICE, not a gate. Someone putting medical lessons in a shared store owns both
   // directories and this binary; refusing would be defending a user against themselves,
   // which this design does not attempt. Making the choice INFORMED is the part that is
   // ours to do — the write has already happened when this prints.
   // RESOLVE before deciding. A symlink named `.health-brain` pointing at a shared project
   // silenced this advice in exactly the case it exists for.
-  let resolvedRoot = projectRoot;
-  try { resolvedRoot = realpathSync(projectRoot); } catch { /* a path we cannot resolve is not the brain */ }
+  let resolvedRoot = storeRoot;
+  try { resolvedRoot = realpathSync(storeRoot); } catch { /* a path we cannot resolve is not the brain */ }
   const sharedAdvice = renderSharedStoreAdvice(domain, resolvedRoot);
   if (sharedAdvice !== '') write(sharedAdvice);
   if (quarantineOn) {
     write('  ⚠ quarantined: excluded from auto-inject, damped in recall — promote by confirming it (dz teach --reinforce "<text>") or dz recall --promote <dzId> --apply');
   }
   // The lexical write above is durable — the vector mirror is strictly best-effort (I-3).
-  await emitMirrorQ(projectRoot, [entry], 'dz-teach', quarantineOn);
+  await emitMirrorQ(storeRoot, [entry], 'dz-teach', quarantineOn);
   return 0;
 }
 
@@ -3572,8 +3761,8 @@ async function cmdRecall(options: Map<string, string>, flags: Set<string>, cwd:
   // second occurrence. Foreign stdout is routed to stderr for the duration of the engine call — our
   // own output is written after it returns.
   const result = asJson
-    ? await withForeignStdoutOnStderr(() => recallHybrid(projectRoot, query, { limit: fetchLimit, mode }))
-    : await recallHybrid(projectRoot, query, { limit: fetchLimit, mode });
+    ? await withForeignStdoutOnStderr(() => recallHybrid(projectRoot, query, { limit: fetchLimit, mode, deferExposures: true, ...(wantedDomain !== undefined ? { domain: wantedDomain } : {}) }))
+    : await recallHybrid(projectRoot, query, { limit: fetchLimit, mode, deferExposures: true, ...(wantedDomain !== undefined ? { domain: wantedDomain } : {}) });
 
   if (mode === 'semantic' && result.vectorEngine === 'none') {
     // --semantic is an explicit ask — degrading it silently would be dishonest (FR-3).
@@ -3589,7 +3778,34 @@ async function cmdRecall(options: Map<string, string>, flags: Set<string>, cwd:
   // 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 cross-project store ────────────────────────────────────────────────────────────────
+  //
+  // Our own shipped precedent (learning_bridge.py:23): "the compounding objection was answered by
+  // making RECALL read both stores rather than by merging them" — and :880, "two stores are
+  // different stores". Writing needs a choice; reading almost never does, so there is no mode here.
+  //
+  // The global store is a project store rooted at the home directory: same code, same format.
+  // It is read ONLY when it exists AND is a different store — a user recalling FROM their home
+  // directory would otherwise read one file twice and see every hit doubled.
+  //
+  // ABSENT global store ⇒ this whole block is skipped and the output is byte-identical to before.
+  // That is the load-bearing property: every existing user must be unaffected by a feature they
+  // did not ask for.
+  const globalRoot = globalStoreRoot();
+  const readGlobal = !sameStore(projectRoot, globalRoot)
+    && existsSync(join(globalRoot, '.dz', 'memory'));
+  let globalHits: typeof result.hits = [];
+  if (readGlobal) {
+    const g = asJson
+      ? await withForeignStdoutOnStderr(() => recallHybrid(globalRoot, query, { limit: fetchLimit, mode, deferExposures: true, ...(wantedDomain !== undefined ? { domain: wantedDomain } : {}) }))
+      : await recallHybrid(globalRoot, query, { limit: fetchLimit, mode, deferExposures: true, ...(wantedDomain !== undefined ? { domain: wantedDomain } : {}) });
+    globalHits = g.hits;
+  }
+  const merged = readGlobal
+    ? mergeStoreHits(boost ? boost.hits : result.hits, globalHits, (h) => h.pattern.pattern)
+    : (boost ? boost.hits : result.hits);
+  const hits = merged.slice(0, limit);
   // Computed ONCE, honoured by EVERY return path. It used to live only on the text tail, so the two
   // paths that return earlier — `--json` and the zero-hits branch — still reported success. That
   // made the contract change invisible to exactly the caller the ADR justifies it by: a script
@@ -3605,6 +3821,23 @@ async function cmdRecall(options: Map<string, string>, flags: Set<string>, cwd:
   // "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;
+  // lesson-bandit-rerank FR-8/AC-11: the bandit block must describe the POST-cut list the reader
+  // actually sees. `dz recall` over-fetches under --domain and truncates AGAIN here, so reporting
+  // the core's own (already post-merge-cut) count would still describe a list one cut too early.
+  // ABSENT while disarmed — its presence is what tells a reader the feature ran.
+  const shownDzIds = hits.map((h) => patternRecordId(h.pattern));
+  const banditBlock = result.bandit === undefined
+    ? undefined
+    : narrowBanditReport(result.bandit, shownDzIds);
+  // Exposures were DEFERRED (`deferExposures: true`) precisely so this cut happens first: `dz recall`
+  // over-fetches under --domain and truncates again here, and counting an over-fetched hit as "seen"
+  // both inflates the health metrics and mislabels a candidate the reader never laid eyes on.
+  result.commitExposures?.(shownDzIds);
+  const renderBanditNote = (b: NonNullable<typeof banditBlock>): string =>
+    `  ℹ bandit payoff: ${b.moved} of ${b.armsConsidered} shown hit(s) moved (ctx ${b.contextKey}` +
+    `, ${b.unknownArms} with no measured payoff yet, ${b.quarantinedExcluded} quarantined excluded` +
+    `${b.exploration ? `, exploration ON — ${b.explored} trial impression(s)` : ''}` +
+    `${b.reason !== null ? `, state ${b.reason}` : ''})`;
   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.
@@ -3635,6 +3868,10 @@ async function cmdRecall(options: Map<string, string>, flags: Set<string>, cwd:
       const cutNoteJson = renderDomainCutNote(displaced, limit);
       if (cutNoteJson !== '') process.stderr.write(`${cutNoteJson}\n`);
     }
+    // STDERR, not stdout: `--json`'s stdout contract is a plain PatternRecord[] that round-trips
+    // through `dz teach --from-json`, and wrapping it in an object to make room for one report
+    // would break every existing consumer. The block travels beside the other honesty notes.
+    if (banditBlock !== undefined) process.stderr.write(`${JSON.stringify({ bandit: banditBlock })}\n`);
     return semanticUnserved ? 1 : 0;
   }
 
@@ -3668,7 +3905,17 @@ async function cmdRecall(options: Map<string, string>, flags: Set<string>, cwd:
         ? `${lexLabel} only (the semantic tier returned ${result.semanticCandidates} stale id(s) — run: dz consolidate)`
         : `${lexLabel} only (semantic tier empty — run: dz vector reindex)`
       : `${lexLabel} ranking (lexical)`;
-  write(`dz recall "${shownQuery}"  —  ${hits.length} hit(s), ${ranking}`);
+  // The store COUNT appears only when a second store actually contributed. Saying "1 store" where
+  // nothing was said before would break the byte-identity property for every existing user; with a
+  // single store the store-location line below already names WHICH one.
+  const storesRead = readGlobal ? `, ${storeCountLabel(2)}` : '';
+  write(`dz recall "${shownQuery}"  —  ${hits.length} hit(s), ${ranking}${storesRead}`);
+  write(storeLocationLine(describeStoreLocation(projectRoot, options.get('project')), 'read'));
+  if (readGlobal) {
+    // Naming only the project store while the header says "2 stores" would leave the reader
+    // guessing which second one answered.
+    write(`  store (read): ${join(globalRoot, '.dz')}  [cross-project]`);
+  }
   let sawQuarantined = false;
   for (const h of hits) {
     const backendTag = vectorOn ? ` ⟨${h.backend}⟩` : '';
@@ -3696,7 +3943,14 @@ async function cmdRecall(options: Map<string, string>, flags: Set<string>, cwd:
     const width = flags.has('full') ? Number.POSITIVE_INFINITY : 160;
     const oneLined = oneLine(h.pattern.pattern);
     const shown = width === Number.POSITIVE_INFINITY ? oneLined : oneLined.slice(0, width);
-    write(`  [${h.pattern.reward.toFixed(2)}] (${oneLine(h.pattern.domain)})${backendAndSim}${qTag} ${shown}`);
+    // WHICH store this hit came from. A merged list that does not say re-creates the fragmentation
+    // blindness the store-location line just removed, one level down: the reader would see more
+    // results and have no way to tell whether the global store is even connected.
+    // Empty when only one store was read, so a single-store run stays byte-identical.
+    const originTag = readGlobal && 'origin' in h
+      ? ` {${(h as { origin: string }).origin}}`
+      : '';
+    write(`  [${h.pattern.reward.toFixed(2)}] (${oneLine(h.pattern.domain)})${backendAndSim}${qTag}${originTag} ${shown}`);
   }
   // The apply leg records itself. `dz recall` wrote NOTHING to the usage log — MEASURED 2026-08-24,
   // 1106 rows before the call and 1106 after — so "how many lessons were recalled" was underivable,
@@ -3733,6 +3987,12 @@ async function cmdRecall(options: Map<string, string>, flags: Set<string>, cwd:
     // 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 (banditBlock !== undefined) {
+    // Say what the payoff term did — INCLUDING when it did nothing. `moved: 0` over many queries
+    // means the feature is armed and inert, which is precisely the outcome nobody would notice
+    // without this line.
+    write(renderBanditNote(banditBlock));
+  }
   if (boost !== null && shownDomain !== 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.
@@ -3807,7 +4067,17 @@ function renderHarmonize(report: HarmonizeReport, write: Write): void {
  * and `dz teach --harmonize` — ONE implementation, no bespoke second path (QR-6). Guards (AC-6):
  * `--apply` + `--dry-run` together is rejected; `--threshold` must be in `(0, 1]`; no flag ⇒ dry-run.
  */
-async function runHarmonize(projectRoot: string, options: Map<string, string>, flags: Set<string>, write: Write): Promise<number> {
+async function runHarmonize(
+  projectRoot: string, options: Map<string, string>, flags: Set<string>, write: Write,
+  /**
+   * Where this harmonize is pointed and what chose it. Under `--json` the human store line is
+   * suppressed to keep stdout ONE document, so the destination has to travel INSIDE that document
+   * or `--harmonize --apply --to global` mutates ~/.dz while revealing nothing (cross-family QE
+   * round 3, 2026-08-27 — the round-2 fix closed a parse break and reopened the silent-store
+   * hazard the whole feature exists to close).
+   */
+  storeAnnotation?: { store: string; storeChosenBy: string },
+): Promise<number> {
   const apply = flags.has('apply');
   if (apply && flags.has('dry-run')) {
     write('dz vector harmonize: --apply and --dry-run are mutually exclusive');
@@ -3823,7 +4093,7 @@ async function runHarmonize(projectRoot: string, options: Map<string, string>, f
   }
   const report = await harmonizeVectorStore(projectRoot, { apply, ...(threshold !== undefined ? { threshold } : {}) });
   if (flags.has('json')) {
-    write(JSON.stringify(report));
+    write(JSON.stringify(storeAnnotation !== undefined ? { ...report, ...storeAnnotation } : report));
     return report.error !== undefined ? 1 : 0;
   }
   renderHarmonize(report, write);
@@ -4702,7 +4972,7 @@ async function cmdSetup(options: Map<string, string>, flags: Set<string>, cwd: s
   // nothing writes to (audit code#3).
   const wiring = setupResult.steps.find((s) => s.name === 'agentdb wiring');
   const backendLabel = memoryOpt === 'agentdb'
-    ? (wiring?.status === 'done' ? 'agentdb (.dz/agentdb.db, shared hook+MCP store)' : `agentdb INCOMPLETE — see setup steps`)
+    ? (wiring?.status === 'done' ? 'agentdb (.dz/agentdb.db + .dz/agentdb-mcp.db, separate stores)' : `agentdb INCOMPLETE — see setup steps`)
     : 'sessions.jsonl + patterns.jsonl';
   write(`║  Learning: ${backendLabel.padEnd(41)}║`);
   write(`║  Hooks: ${flags.has('no-hooks') ? 'disabled' : 'session-start + session-end'}${' '.repeat(flags.has('no-hooks') ? 30 : 15)}║`);
@@ -4716,7 +4986,17 @@ async function cmdSetup(options: Map<string, string>, flags: Set<string>, cwd: s
   }
   // A hook that was written but never witnessed firing is NOT a completed setup (ADR-002 §5): the
   // step is reported failed, the process was not aborted.
-  return codexHooksOk ? 0 : 1;
+  //
+  // …and neither is a setup that PRINTED an error step. The first version returned on codexHooksOk
+  // alone, so `dz setup` could report `agentdb wiring: error` — the very invariant this feature
+  // defends — and still exit 0, which is what a CI job reads (cross-family QE, Codex gpt-5.6-sol).
+  // An exit code that disagrees with the report on screen is the same class of lie as a green run
+  // on a stale build.
+  const erroredSteps = setupResult.steps.filter((s) => s.status === 'error').map((s) => s.name);
+  if (erroredSteps.length > 0) {
+    write(`\n✗ setup reported ${erroredSteps.length} failed step(s): ${erroredSteps.join(', ')} — exit 1`);
+  }
+  return codexHooksOk && erroredSteps.length === 0 ? 0 : 1;
 }
 
 function cmdPretrain(options: Map<string, string>, cwd: string, write: Write): number {
@@ -5290,11 +5570,10 @@ function cmdVerifyPack(options: Map<string, string>, flags: Set<string>, cwd: st
   try { signed = JSON.parse(readFileSync(manifestPath, 'utf8')); }
   catch { write(`dz verify-pack: ${MANIFEST_NAME} is not valid JSON`); return 1; }
 
-  // Same rule as the signer: a working-tree file `files[]` excludes was never "added to the pack".
-  // Unscoped when npm cannot answer — an extracted tarball verifies exactly as before.
-  let shippedForVerify: string[] | undefined;
-  try { shippedForVerify = npmPackedPaths(packDir); } catch { shippedForVerify = undefined; }
-  const res = verifyManifest(packDir, signed as never, readFileSync(pubPath, 'utf8'), shippedForVerify);
+  // The verifier sweeps the directory it was handed. A caller-supplied shipment list could omit an
+  // unsigned file and turn the bidirectional check off, so verification has no narrowing option.
+  // Release/publish verifies an extracted tarball separately; `verify-pack` verifies this exact tree.
+  const res = verifyManifest(packDir, signed as never, readFileSync(pubPath, 'utf8'));
   if (res.ok) { write(`dz verify-pack: OK — ${packDir} matches its signed manifest`); return 0; }
   write(`dz verify-pack: FAILED — ${packDir}`);
   for (const f of res.failures) write(`  ${f.path}: ${f.reason}`);
@@ -8041,11 +8320,16 @@ async function cmdDownloads(cwd: string, write: Write): Promise<number> {
  * The pure engine lives in harness-core; this is the thin I/O shell (scan disk + git, render).
  */
 function cmdArchitecture(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
-  // Resolve repo root: prefer git toplevel, fall back to cwd (matches cmdRoam / cmdStats duality).
-  let repoRoot = cwd;
+  // Resolve repo root: an explicit --project wins, then git toplevel, then cwd (matches cmdRoam /
+  // cmdStats duality). The --project leg is the same fix as cmdProjectSkills got for field report
+  // doc-25b, applied to its neighbour before it costs a second report: this command also reads an
+  // `architecture/` tree, and on a feature-adr run against a target checkout the Step-0 product-vision
+  // сверка silently no-ops for exactly that reason.
+  const explicitRoot = (options.get('project') ?? '').trim();
+  let repoRoot = explicitRoot !== '' ? resolve(cwd, explicitRoot) : cwd;
   try {
-    repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd;
-  } catch { /* not a git repo — use cwd */ }
+    repoRoot = execSync('git rev-parse --show-toplevel', { cwd: repoRoot, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || repoRoot;
+  } catch { /* not a git repo — use the root as given */ }
 
   const manifest = loadSubsystemManifest(repoRoot);
   if (!manifest) {
@@ -8091,11 +8375,21 @@ function cmdArchitecture(options: Map<string, string>, flags: Set<string>, cwd:
  *   --stages-json   { hasManifest, design, code, qe, report } — ready to thread into prompts
  * No manifest ⇒ empty guidance strings ⇒ byte-identical run (FR-7).
  */
-function cmdProjectSkills(flags: Set<string>, cwd: string, write: Write): number {
-  let repoRoot = cwd;
+function cmdProjectSkills(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  // `--project <dir>` names the root EXPLICITLY. Until 2026-08-25 this command took only `cwd`, so
+  // the manifest was reachable exclusively from the workspace you happened to stand in — and because
+  // the known-flag list is deliberately FLAT, `--project` passed validation on a command that never
+  // read it: exit 0, no warning, no manifest. MEASURED that day: a feature-adr run against a target
+  // repo probed with `cd REPO`, found nothing, and fell open to a generic run — the honest
+  // `polymorphism:null` was recorded and not one project lens reached any stage.
+  const explicitRoot = (options.get('project') ?? '').trim();
+  let repoRoot = explicitRoot !== '' ? resolve(cwd, explicitRoot) : cwd;
   try {
-    repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd;
-  } catch { /* not a git repo — use cwd */ }
+    // stderr is SWALLOWED: a non-repo directory is an ordinary case here, and letting git print
+    // "fatal: not a git repository" onto the operator's terminal made a working command look broken.
+    // The sibling cmdFeatureAdrSetup already redirects; this one did not.
+    repoRoot = execSync('git rev-parse --show-toplevel', { cwd: repoRoot, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || repoRoot;
+  } catch { /* not a git repo — use the root as given */ }
 
   const plan = planProjectSkills(repoRoot);
   const hasManifest = plan.injections.length > 0 || plan.skipped.length > 0;
@@ -8184,6 +8478,7 @@ async function cmdMrRakes(options: Map<string, string>, flags: Set<string>, cwd:
         ['type', 'lesson-learned'],
       ]);
       if (options.has('project')) opts.set('project', options.get('project')!);
+      if (options.has('to')) opts.set('to', options.get('to')!);   // same reason as in cmdRetro
       await cmdTeach(opts, new Set<string>(['guard']), cwd, write);
     }
   }
@@ -8218,10 +8513,23 @@ async function cmdRetro(options: Map<string, string>, flags: Set<string>, cwd: s
   const hits = detectProcessRakes(events);
 
   // Ledger: count prior 'retro'-domain records per signature in the dz-teach store.
-  const projectRoot = resolve(cwd, options.get('project') ?? '.');
+  // It MUST be read from the store the co-learning write below will append to. A session mode
+  // (`DZ_LEARN=global`) once split the two — the count was read from the project while the record
+  // landed in the home store, so the recurrence never advanced and the drill threshold could never
+  // be reached (cross-family QE, 2026-08-27). A read and its write resolve the same way, or the
+  // counter they share is a fiction.
+  let ledgerRoot: string;
+  try {
+    ledgerRoot = resolveLearningStore(options, cwd).storeRoot;
+  } catch (e) {
+    // Refuse HERE rather than after the whole retro has been rendered — the same refusal the
+    // teach below would raise, but before any work is spent on it.
+    if (e instanceof TeachTargetError) { write('dz retro: ' + e.message); return 1; }
+    throw e;
+  }
   const ledger = new Map<string, number>();
   try {
-    const records = loadStorePatternsSync(projectRoot).filter((r) => r.domain === RETRO_DOMAIN);
+    const records = loadStorePatternsSync(ledgerRoot).filter((r) => r.domain === RETRO_DOMAIN);
     for (const sig of PROCESS_SIGNATURES) {
       const lesson = retroLessonText(sig.id);
       ledger.set(sig.id, records.filter((r) => r.pattern === lesson).length);
@@ -8246,6 +8554,11 @@ async function cmdRetro(options: Map<string, string>, flags: Set<string>, cwd: s
         ['type', 'lesson-learned'],
       ]);
       if (options.has('project')) opts.set('project', options.get('project')!);
+      // `--to` MUST travel with it. Without this the ledger above resolves with the flag and the
+      // write below resolves without it, so `dz retro --to global` counted a global ledger while
+      // recording into the project — the very split Decision 5 exists to close, reopened one level
+      // down (cross-family QE round 2, 2026-08-27).
+      if (options.has('to')) opts.set('to', options.get('to')!);
       await cmdTeach(opts, new Set<string>(['guard', 'no-mirror']), cwd, write);
     }
   }
@@ -8836,25 +9149,43 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
     // F-2 — rule-3 containment root: the scratch copy AS THE FILESYSTEM sees it. Every mutation
     // write below is asserted to RESOLVE inside this root before it happens.
     const realScratchRoot = realpathSync(copyDir);
-
-    const runSuite = (): { exitCode: number | null; output: string } => {
-      try {
-        const out = execSync(testCmd, { cwd: copyDir, stdio: 'pipe', encoding: 'utf-8', timeout, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, FORCE_COLOR: '0' } });
-        return { exitCode: 0, output: out };
-      } catch (e) {
-        const err = e as { status?: number | null; stdout?: string; stderr?: string };
-        return {
-          exitCode: typeof err.status === 'number' ? err.status : null,
-          output: `${String(err.stdout ?? '')}\n${String(err.stderr ?? '')}`,
-        };
+    const requireCompletionReceipt = parsed.registry.requireCompletionReceipt === true;
+
+    const runSuite = (): { exitCode: number | null; output: string; failureReason?: string } => {
+      const run = spawnSync(testCmd, {
+        cwd: copyDir,
+        shell: true,
+        encoding: 'utf-8',
+        timeout,
+        maxBuffer: 64 * 1024 * 1024,
+        env: { ...process.env, FORCE_COLOR: '0' },
+      });
+      const errorCode = run.error && 'code' in run.error && typeof run.error.code === 'string'
+        ? run.error.code
+        : undefined;
+      const signal = typeof run.signal === 'string' ? run.signal : undefined;
+      let failureReason: string | undefined;
+      if (typeof run.status !== 'number') {
+        if (errorCode === 'ETIMEDOUT') failureReason = `timeout after ${timeout}ms${signal === undefined ? '' : `; signal=${signal}`}`;
+        else if (errorCode === 'ENOBUFS') failureReason = 'maxBuffer exceeded (ENOBUFS; 67108864-byte output ceiling)';
+        else if (signal !== undefined) failureReason = `child killed by signal ${signal}`;
+        else if (errorCode !== undefined) failureReason = `spawn failure code ${errorCode}`;
+        else failureReason = 'spawn failure with no error code or signal';
       }
+      return {
+        exitCode: typeof run.status === 'number' ? run.status : null,
+        // Receipt markers may be on stderr. Preserve both streams even on exit 0; stdout-only
+        // collection would silently lose a green-run marker.
+        output: `${String(run.stdout ?? '')}\n${String(run.stderr ?? '')}`,
+        ...(failureReason !== undefined ? { failureReason } : {}),
+      };
     };
 
     // Baseline BEFORE any mutation: a red copy proves nothing, and reading it as a mutation
     // result would be this gate shipping the defect class it exists to catch.
     if (!json) write(`mutation-gate: baseline suite in scratch copy of ${pkgDir} …`);
     const base = runSuite();
-    baseline = classifyBaseline(base.exitCode);
+    baseline = classifyBaseline(base.exitCode, base.failureReason);
     if (!baseline.ok) {
       if (json) { write(JSON.stringify({ packageDir: pkgDir, registryPath, testCommand: testCmd, baseline, results: [], exitCode: 2 }, null, 2)); return 2; }
       write(renderMutationReport([], baseline, pkgDir));
@@ -8893,7 +9224,7 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
         return fail(`entry '${entry.id}': ${entry.file} resolves to ${realTarget ?? '<unresolvable>'} — OUTSIDE the scratch copy (${realScratchRoot}). A path component is a symlink escaping the scratch tree, so writing the mutation would mutate the REAL working tree (SPEC rule 3). Refused; nothing was written.`);
       }
       if (!json) write(`mutation-gate: ${entry.id} — mutating ${entry.file}, running suite …`);
-      let run: { exitCode: number | null; output: string } | null = null;
+      let run: { exitCode: number | null; output: string; failureReason?: string } | null = null;
       let parseError: string | undefined;
       try {
         writeFileSync(filePath, applied.text);
@@ -8919,6 +9250,12 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
       // 'file-load' ⇒ MUTATION_LOAD_FATAL (structural); 'unrecognised' ⇒ INCONCLUSIVE (a
       // runner-coverage gap of this tool, loud, never PROVEN); 'assertions' ⇒ behavioural, the
       // count-based verdicts apply.
+      const completionReceipt = run === null ? undefined : detectSuiteCompletionReceipt(run.output);
+      let receiptMismatch = run === null ? undefined : detectSuiteReceiptMismatch(run.output);
+      if (run !== null && requireCompletionReceipt
+        && completionReceipt === undefined && receiptMismatch === undefined) {
+        receiptMismatch = 'required mutation-suite-receipt-ok completion receipt missing';
+      }
       let fileLoadFailure: string | undefined;
       let outputUnrecognised: string | undefined;
       if (run !== null && run.exitCode !== null && run.exitCode !== 0) {
@@ -8931,13 +9268,16 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
       }
       // Route-b guard (per-entry mode): a red mutated run is attributable only if the RESTORED
       // tree reproduces green — otherwise a flaky neighbour may be what went red. Skipped when the
-      // classification already failed the entry structurally (file-load / unrecognised): those
-      // verdicts outrank the rebaseline check, so the extra suite run would buy nothing.
+      // classification already failed the entry (file-load / unrecognised / receipt mismatch):
+      // those verdicts outrank the rebaseline check, so the extra suite run would buy nothing.
       let rebaselineExitCode: number | null | undefined;
+      let rebaselineFailureReason: string | undefined;
       if (rebaselineMode === 'per-entry' && run !== null && run.exitCode !== null && run.exitCode !== 0
-        && fileLoadFailure === undefined && outputUnrecognised === undefined) {
+        && fileLoadFailure === undefined && outputUnrecognised === undefined && receiptMismatch === undefined) {
         if (!json) write(`mutation-gate: ${entry.id} — re-baselining the restored tree …`);
-        rebaselineExitCode = runSuite().exitCode;
+        const rebaselineRun = runSuite();
+        rebaselineExitCode = rebaselineRun.exitCode;
+        rebaselineFailureReason = rebaselineRun.failureReason;
       }
       const obs: MutationObservation = {
         entry,
@@ -8947,7 +9287,10 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
         ...(parseError !== undefined ? { parseError } : {}),
         ...(fileLoadFailure !== undefined ? { fileLoadFailure } : {}),
         ...(outputUnrecognised !== undefined ? { outputUnrecognised } : {}),
+        ...(receiptMismatch !== undefined ? { receiptMismatch } : {}),
+        ...(run?.failureReason !== undefined ? { runFailureReason: run.failureReason } : {}),
         ...(rebaselineExitCode !== undefined ? { rebaselineExitCode } : {}),
+        ...(rebaselineFailureReason !== undefined ? { rebaselineFailureReason } : {}),
       };
       observations.push(obs);
       results.push(classifyMutationOutcome(obs));
@@ -8957,15 +9300,20 @@ function cmdMutationGate(options: Map<string, string>, flags: Set<string>, cwd:
     // verdict of this run is downgraded (any of them may have been the flake, and there is no
     // per-entry evidence to say which) — re-classifying with the final exit turns them
     // INCONCLUSIVE while leaving NOT_APPLIED / UNDEFENDED / MUTATION_UNPARSEABLE /
-    // MUTATION_LOAD_FATAL untouched.
+    // MUTATION_LOAD_FATAL / RECEIPT_MISMATCH untouched.
     if (rebaselineMode === 'final') {
       if (!json) write('mutation-gate: final re-baseline of the restored tree …');
-      const finalExit = runSuite().exitCode;
+      const finalRun = runSuite();
+      const finalExit = finalRun.exitCode;
       if (finalExit !== 0) {
-        const what = finalExit === null ? 'no exit code' : `exit ${finalExit}`;
+        const what = finalExit === null ? `no exit code: ${finalRun.failureReason ?? 'unknown timeout / spawn failure'}` : `exit ${finalExit}`;
         warnings.push(`final re-baseline NOT green (${what}) — the suite is flaky; red-based verdicts downgraded to INCONCLUSIVE`);
         if (!json) write(`mutation-gate: final re-baseline NOT green (${what}) — red-based verdicts downgraded to INCONCLUSIVE`);
-        const reclassified = observations.map((obs) => classifyMutationOutcome({ ...obs, rebaselineExitCode: finalExit }));
+        const reclassified = observations.map((obs) => classifyMutationOutcome({
+          ...obs,
+          rebaselineExitCode: finalExit,
+          ...(finalRun.failureReason !== undefined ? { rebaselineFailureReason: finalRun.failureReason } : {}),
+        }));
         results.length = 0;
         results.push(...reclassified);
       }
@@ -12036,8 +12384,13 @@ function cmdCompounding(options: Map<string, string>, flags: Set<string>, cwd: s
   }
 
   const report = assembleCompoundingReport({ lessons, usage, guard, nowTs: new Date().toISOString(), evidenceLogs });
-  if (json) write(JSON.stringify({ ...report, exitCode: 0 }, null, 2));
-  else write(renderCompoundingReport(report));
+  // lesson-bandit-rerank §11: the payoff axis joins THIS report rather than growing a private
+  // dashboard — the `rewardEvents : exposureEvents` row asks exactly the question this command
+  // already asks of the reinforcement loop (is the apply leg alive, or is it a write-only log?).
+  // Read-only, and INSUFFICIENT_DATA on an absent state file — never a fake verdict.
+  const bandit = banditStats(root);
+  if (json) write(JSON.stringify({ ...report, bandit, exitCode: 0 }, null, 2));
+  else write(`${renderCompoundingReport(report)}\n\n${renderBanditHealth(bandit)}`);
   return 0;
 }
 
@@ -13518,6 +13871,285 @@ async function cmdImportEcc(options: Map<string, string>, flags: Set<string>, cw
   return report.skippedError > 0 && report.imported === 0 ? 1 : 0;
 }
 
+// ── dz profile (feature operator-profile, ADR-001) ─────────────────────────────────────────────
+//
+// WHO the assistant is talking to: a per-user store at ~/.dz/profile.json (0600, NEVER under a
+// project root) delivered as a marked block in ~/.claude/CLAUDE.md — loaded in every project on
+// the machine, dz installed or not. Four subcommands: init (five questions), show (path + age +
+// rendered block — the path ALWAYS prints, per the teach-target announce-the-store precedent),
+// set (register / language / teaches / deep|weak add|rm), sync (write the block; runs
+// automatically after init and set). An unknown register is REFUSED naming the accepted set —
+// never silently defaulted.
+
+/** The refusal line for a bad register — one place, so init/set refuse identically. */
+function profileRegisterRefusal(raw: string): string {
+  return `dz profile: unknown register ${JSON.stringify(raw)} — accepted: ${REGISTERS.join(' | ')} (или своими словами: профи | профи лайт | просто)`;
+}
+
+function profileRegisterEcho(register: ProfileRegister): string {
+  return `${register} (${registerOwnerWord(register)})`;
+}
+
+/** Shared epilogue of init/set/sync: push the block into ~/.claude/CLAUDE.md and say what happened. */
+function profileSyncAndReport(profile: OperatorProfile, write: Write, writeErr: WriteErr): number {
+  const res = syncProfileBlock(profile);
+  if (res.problem !== null) {
+    writeErr(`dz profile: sync failed: ${res.problem}`);
+    return 1;
+  }
+  if (res.changed) {
+    const backupNote = res.backup === null ? '' : ' (backup: ' + res.backup + ')';
+    write(`synced block into ${res.target}` + backupNote);
+  } else {
+    write(`block in ${res.target} already up to date`);
+  }
+  return 0;
+}
+
+async function cmdProfile(options: Map<string, string>, flags: Set<string>, write: Write, writeErr: WriteErr): Promise<number> {
+  const sub = options.get('_positional_0') ?? 'show';
+  const json = flags.has('json');
+  // --json contract (cross-family finding, 2026-08-28): stdout carries exactly ONE JSON document
+  // per invocation. Before this, `set --json` printed a human field echo BEFORE the JSON and the
+  // sync status line AFTER it, `sync --json` ignored json entirely and `init --json` emitted its
+  // prompts to stdout — none of the three parsed. Human lines now go through `say` (dropped in
+  // json mode) and every refusal in json mode IS the one document.
+  const say = (line: string): void => { if (!json) write(line); };
+  const fail = (code: number, error: string): number => {
+    if (json) write(JSON.stringify({ ok: false, error }));
+    else writeErr(error);
+    return code;
+  };
+
+  if (sub === 'show') {
+    const { profile, path, problem } = readProfile();
+    if (profile === null) {
+      // The path prints on EVERY exit — announcing the store is the point (ADR Decision 4).
+      if (json) { write(JSON.stringify({ path, profile: null, problem })); return 1; }
+      write(`store:   ${path}`);
+      writeErr(`dz profile: ${problem === 'missing' ? 'no profile yet — run `dz profile init`' : problem}`);
+      return 1;
+    }
+    const age = profileAgeDays(profile);
+    const drift = checkProfileDrift();
+    const block = renderProfileBlock(profile);
+    if (json) {
+      write(JSON.stringify({ path, ageDays: age, drift, profile, block }));
+      return 0;
+    }
+    write(`store:    ${path}`);
+    const ageNote = age === null ? '' : ' (' + age + (age === 1 ? ' day' : ' days') + ' ago)';
+    write(`updated:  ${profile.updatedAt}` + ageNote);
+    write(`register: ${profileRegisterEcho(profile.register)} · language: ${profile.language} · teaches: ${profile.teaches ? 'yes' : 'no'}`);
+    write(`block:    ${drift.verdict}` + (drift.verdict === 'in-sync' ? '' : ' — ' + drift.detail));
+    write('');
+    write(block);
+    return 0;
+  }
+
+  if (sub === 'init') {
+    // Five questions, node:readline, under two minutes. An existing profile pre-fills every
+    // default (domains included) — init is safe to re-run; Enter keeps what is stored.
+    const existing = readProfile().profile;
+    const { createInterface } = await import('node:readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    // Buffered ask, not rl.question(): with PIPED stdin the answer lines can all arrive while no
+    // question is pending, and readline DROPS a 'line' nobody listens for — the next question()
+    // then never settles and the process dies with an unsettled top-level await (MEASURED on the
+    // first smoke of this command, exit 13). Buffering every line makes piped `printf 'a\nb\nc' |
+    // dz profile init` and an interactive TTY behave identically. null = stdin closed early.
+    const buffered: string[] = [];
+    let pendingAsk: ((line: string | null) => void) | null = null;
+    let stdinClosed = false;
+    rl.on('line', (line) => {
+      if (pendingAsk !== null) { const resolve = pendingAsk; pendingAsk = null; resolve(line); }
+      else buffered.push(line);
+    });
+    rl.on('close', () => {
+      stdinClosed = true;
+      if (pendingAsk !== null) { const resolve = pendingAsk; pendingAsk = null; resolve(null); }
+    });
+    const ask = (prompt: string): Promise<string | null> => {
+      // In --json mode the prompts go to STDERR — stdout must stay exactly one JSON document.
+      (json ? process.stderr : process.stdout).write(prompt);
+      if (buffered.length > 0) return Promise.resolve(buffered.shift() as string);
+      if (stdinClosed) return Promise.resolve(null);
+      return new Promise((resolve) => { pendingAsk = resolve; });
+    };
+    const eofRefusal = (): number =>
+      fail(1, 'dz profile: stdin closed before the five questions were answered — nothing written');
+    // Domain question: an EXISTING list renders as the default an Enter keeps; on a fresh
+    // profile Enter honestly means "none" — onboarding never forces an answer.
+    const askDomains = async (prompt: string, current: readonly ProfileDomain[]): Promise<readonly ProfileDomain[] | null> => {
+      const hint = current.length > 0 ? ' [' + domainListText(current) + ']' : ' (Enter — пропустить)';
+      const answer = await ask(prompt + hint + ': ');
+      if (answer === null) return null;
+      if (answer.trim() === '') return current;
+      return parseDomainList(answer);
+    };
+    // y/n: an unrecognised answer RE-ASKS once; a second unrecognised answer takes the
+    // documented default and SAYS so. Measured defect this closes: a domains line fed to the
+    // old y/n question silently became `teaches: no`.
+    const askYesNo = async (prompt: string, dflt: boolean): Promise<boolean | null> => {
+      for (let attempt = 0; attempt < 2; attempt++) {
+        const answer = await ask(prompt + ' y/n [' + (dflt ? 'y' : 'n') + ']: ');
+        if (answer === null) return null;
+        if (answer.trim() === '') return dflt;
+        const parsed = parseYesNo(answer);
+        if (parsed !== null) return parsed;
+        if (attempt === 0) writeErr('dz profile: did not understand ' + JSON.stringify(answer.trim()) + ' — answer y or n (да/нет)');
+      }
+      (json ? writeErr : write)('unrecognised again — taking the default: ' + (dflt ? 'yes' : 'no'));
+      return dflt;
+    };
+    try {
+      const langDefault = existing?.language ?? 'ru';
+      const langAnswer = await ask(`1/5 Dialogue language (ru, en, …) [${langDefault}]: `);
+      if (langAnswer === null) return eofRefusal();
+      const language = langAnswer.trim() === '' ? langDefault : langAnswer.trim();
+
+      const regDefault: ProfileRegister = existing?.register ?? 'pro-lite';
+      let register: ProfileRegister | null = null;
+      while (register === null) {
+        const regAnswer = await ask(`2/5 Default register — pro / pro-lite / plain (профи / профи лайт / просто) [${profileRegisterEcho(regDefault)}]: `);
+        if (regAnswer === null) return eofRefusal();
+        const regRaw = regAnswer.trim();
+        if (regRaw === '') { register = regDefault; break; }
+        register = parseRegister(regRaw);
+        if (register === null) writeErr(profileRegisterRefusal(regRaw));
+      }
+
+      // ADR Decision 2: a single register dial cannot express the owner — the domain lists ARE
+      // the profile, and the weak list is the load-bearing one. So onboarding asks for BOTH,
+      // phrased so no self-assessment is needed (the design-report wording, tested with the owner).
+      const deepDomains = await askDomains(
+        '3/5 Назовите 2–4 области, где вам НЕ нужно пояснять термины (сертификации, чем занимались 5+ лет) — через запятую',
+        existing?.deepDomains ?? [],
+      );
+      if (deepDomains === null) return eofRefusal();
+      const weakDomains = await askDomains(
+        '4/5 Где наоборот — терминам нужна одна поясняющая фраза? — через запятую',
+        existing?.weakDomains ?? [],
+      );
+      if (weakDomains === null) return eofRefusal();
+
+      const teaches = await askYesNo('5/5 Do you teach — must explanations be re-tellable?', existing?.teaches ?? true);
+      if (teaches === null) return eofRefusal();
+
+      const profile: OperatorProfile = {
+        version: 1,
+        updatedAt: new Date().toISOString(),
+        language,
+        register,
+        deepDomains,
+        weakDomains,
+        teaches,
+      };
+      const initWrite = writeProfile(profile);
+      if (initWrite.problem !== undefined) return fail(2, `dz profile: ${initWrite.problem}`);
+      const { path } = initWrite;
+      say(`wrote ${path} (0600) — register ${profileRegisterEcho(register)}, language ${language}, teaches ${teaches ? 'yes' : 'no'}`);
+      say('deep: ' + (deepDomains.length > 0 ? domainListText(deepDomains) : '(none)') + ' · weak: ' + (weakDomains.length > 0 ? domainListText(weakDomains) : '(none)'));
+      if (deepDomains.length === 0 && weakDomains.length === 0) {
+        say('no domains yet — the profile is a single dial until you add them: `dz profile set deep add <tag> [note]` · `dz profile set weak add <tag>`');
+      }
+      if (json) {
+        const sync = syncProfileBlock(profile);
+        write(JSON.stringify({ ok: sync.problem === null, path, profile, sync }));
+        return sync.problem === null ? 0 : 1;
+      }
+      return profileSyncAndReport(profile, write, writeErr);
+    } finally {
+      rl.close();
+    }
+  }
+
+  if (sub === 'set') {
+    const read = readProfile();
+    if (read.profile === null) {
+      return fail(1, 'dz profile: ' + (read.problem === 'missing' ? 'no profile at ' + read.path + ' — run `dz profile init` first' : read.path + ': ' + read.problem));
+    }
+    const key = options.get('_positional_1') ?? '';
+    const val = options.get('_positional_2') ?? '';
+    let next: OperatorProfile;
+    // The field echo is DEFERRED until writeProfile succeeds (round-5 P2-3): `dz profile set
+    // language '<marker>'` used to print `language: <marker>` BEFORE the write check exited 2 —
+    // a success-looking confirmation of a mutation that was never applied. In --json mode nothing
+    // changes: echoes go through `say`, which json drops.
+    let echo: string;
+    if (key === 'register') {
+      const register = parseRegister(val);
+      if (register === null) { return fail(2, profileRegisterRefusal(val)); }
+      next = { ...read.profile, register };
+      echo = `register: ${profileRegisterEcho(register)}`;
+    } else if (key === 'language') {
+      if (val.trim() === '') { return fail(2, 'dz profile: usage: dz profile set language <code>'); }
+      next = { ...read.profile, language: val.trim() };
+      echo = `language: ${next.language}`;
+    } else if (key === 'teaches') {
+      const t = val.trim().toLowerCase();
+      if (!['on', 'off', 'true', 'false', 'yes', 'no', 'y', 'n', 'да', 'нет'].includes(t)) {
+        return fail(2, 'dz profile: usage: dz profile set teaches on|off');
+      }
+      next = { ...read.profile, teaches: ['on', 'true', 'yes', 'y', 'да'].includes(t) };
+      echo = `teaches: ${next.teaches ? 'yes' : 'no'}`;
+    } else if (key === 'deep' || key === 'weak') {
+      const op = val;
+      const tag = (options.get('_positional_3') ?? '').trim();
+      const note = options.get('_positional_4');
+      const listKey = key === 'deep' ? 'deepDomains' : 'weakDomains';
+      const list = read.profile[listKey];
+      if (op === 'add') {
+        if (tag === '') { return fail(2, `dz profile: usage: dz profile set ${key} add <tag> [note]`); }
+        const rest = list.filter((d) => d.tag !== tag);
+        const domain: ProfileDomain = note === undefined || note.trim() === '' ? { tag } : { tag, note: note.trim() };
+        next = { ...read.profile, [listKey]: [...rest, domain] };
+        echo = key + ': + ' + (domain.note ? tag + ' (' + domain.note + ')' : tag);
+      } else if (op === 'rm') {
+        if (tag === '') { return fail(2, `dz profile: usage: dz profile set ${key} rm <tag>`); }
+        if (!list.some((d) => d.tag === tag)) {
+          return fail(1, `dz profile: no ${key} domain ${JSON.stringify(tag)} — have: ${list.map((d) => d.tag).join(', ') || '(none)'}`);
+        }
+        next = { ...read.profile, [listKey]: list.filter((d) => d.tag !== tag) };
+        echo = `${key}: - ${tag}`;
+      } else {
+        return fail(2, `dz profile: usage: dz profile set ${key} add|rm <tag> [note]`);
+      }
+    } else {
+      return fail(2, 'dz profile: usage: dz profile set register|language|teaches|deep|weak …');
+    }
+    const stamped: OperatorProfile = { ...next, updatedAt: new Date().toISOString() };
+    const setWrite = writeProfile(stamped);
+    // A refused write must never fall through to sync: syncing an unwritten profile would put the
+    // poisoned value into CLAUDE.md while the store still holds the old one (round-4 fix). And it
+    // must never have echoed either — the echo below only runs on an APPLIED mutation.
+    if (setWrite.problem !== undefined) return fail(2, `dz profile: ${setWrite.problem}`);
+    say(echo);
+    const { path } = setWrite;
+    if (json) {
+      const sync = syncProfileBlock(stamped);
+      write(JSON.stringify({ ok: sync.problem === null, path, profile: stamped, sync }));
+      return sync.problem === null ? 0 : 1;
+    }
+    return profileSyncAndReport(stamped, write, writeErr);
+  }
+
+  if (sub === 'sync') {
+    const read = readProfile();
+    if (read.profile === null) {
+      return fail(1, 'dz profile: ' + (read.problem === 'missing' ? 'no profile at ' + read.path + ' — run `dz profile init` first' : read.path + ': ' + read.problem));
+    }
+    if (json) {
+      const res = syncProfileBlock(read.profile);
+      write(JSON.stringify({ ok: res.problem === null, target: res.target, changed: res.changed, backup: res.backup, problem: res.problem }));
+      return res.problem === null ? 0 : 1;
+    }
+    return profileSyncAndReport(read.profile, write, writeErr);
+  }
+
+  return fail(2, `dz profile: unknown subcommand ${JSON.stringify(sub)} — accepted: init | show | set | sync`);
+}
+
 export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
   const cwd = io.cwd ?? process.cwd();
   const write: Write = io.write ?? ((line) => { console.log(line); });
@@ -13674,7 +14306,7 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
       case 'architecture':
         return cmdArchitecture(options, flags, cwd, write);
       case 'project-skills':
-        return cmdProjectSkills(flags, cwd, write);
+        return cmdProjectSkills(options, flags, cwd, write);
       case 'mr-rakes':
         return await cmdMrRakes(options, flags, cwd, write);
       case 'retro':
@@ -13701,6 +14333,8 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
         return cmdRecap(options, flags, cwd, write);
       case 'cadence':
         return cmdCadence(options, flags, cwd, write);
+      case 'qe-rounds':
+        return cmdQeRounds(options, flags, cwd, write);
       case 'tg-post':
         return cmdTgPost(options, flags, cwd, write);
       case 'name-check':
@@ -13713,6 +14347,8 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
         return cmdAmendmentCheck(options, flags, cwd, write);
       case 'feature-adr-checkpoint':
         return cmdFeatureAdrCheckpoint(options, flags, cwd, write);
+      case 'profile':
+        return await cmdProfile(options, flags, write, writeErr);
       case 'reqe':
         return cmdReqe(options, flags, cwd, write);
       case 'qe-bridge':