@dzhechkov/harness-cli 0.8.10 → 0.8.15

package/src/cli.ts

@@ -11,6 +11,7 @@ import { request as httpsRequest } from 'node:https';
 import { KNOWN_CLI_FLAGS } from './known-flags.js';
 import { isBooleanFlag } from './boolean-flags.js';
 import { resolveInstallSpec } from './install-spec.js';
+import { dispatchedCommands, documentedCommands } from './command-inventory.js';
 import { execFile, execFileSync, execSync, spawn, spawnSync, type ChildProcess } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { homedir, hostname, tmpdir } from 'node:os';
@@ -146,8 +147,17 @@ import {
   reindexVectorStore,
   harmonizeVectorStore,
   importRvfCheckpoint,
+  renderFeatureAdrPhaseLine,
   statuslineData,
+  countLearningStoreRowsReadonly,
+  readStoreMark,
+  writeStoreMark,
+  resetStoreMark,
+  checkStoreHealth,
+  storeGuardPath,
+  storeSnapshotPath,
   writeFeatureAdrState,
+  writeFeatureAdrStateDetailed,
   CHECKPOINT_STAGES,
   estimateEta,
   extractStageSamples,
@@ -157,6 +167,9 @@ import {
   type CheckpointStage,
   type EtaEstimate,
   type FeatureAdrState,
+  type StoreHealth,
+  type StoreMark,
+  type StoreCountSnapshot,
   type RunSegment,
   type StageSample,
   computeUsage,
@@ -187,6 +200,9 @@ import {
   patternRecordId,
   patternIdentityOf,
   mergeLessonMatchedForms,
+  SWARM_BRIEF_CONTRACT,
+  checkSwarmBrief,
+  visibleText,
   loadStoreRecords,
   recordToPattern,
   bundleSkills,
@@ -219,6 +235,7 @@ import {
   resolveTrustRoot,
   decideVerifyPolicy,
   generateSigningKeypair,
+  appendTransition,
   evaluateGuard,
   resolveRules,
   auditRecord,
@@ -259,6 +276,7 @@ import {
   isInsideTree,
   signManifest,
   verifyManifest,
+  listPackFiles,
   listSignablePackFiles,
   assertKeyOutsideTree,
   decidePublishGate,
@@ -293,12 +311,14 @@ import {
   DEFAULT_RAKE_THRESHOLDS,
   streamSessionEvents,
   findLatestTranscript,
+  resolveScanTailTranscript,
   detectProcessRakes,
   buildRetro,
   renderRetro,
   retroLessonText,
   PROCESS_SIGNATURES,
   RETRO_DOMAIN,
+  runRetroTailScan,
   scanForSetup,
   buildSetupPlan,
   scaffoldFromSpec,
@@ -507,6 +527,8 @@ import {
   planImport,
   decideCheckpointWrite,
   amendmentSection,
+  amendmentSectionCount,
+  amendmentDeclarationAmbiguity,
   planSaysNoAmendments,
   parseAmendments,
   resolveAmendments,
@@ -569,11 +591,36 @@ import type { ProvenanceMode, PackVerdict, ClaudeUsageModel, PatternRecord, Reca
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
 import { scanGitHub, analyzeRepo, generateReport, deepAnalyze, scanAllSources, ScoutMemory } from '@dzhechkov/scout';
 
+/**
+ * Область, по которой гейт дрейфа собирает факты. ПОЛНАЯ, а не только корни установки.
+ *
+ * ПОЧЕМУ. Под областью `installs` сравниваются лишь корни установки (`.claude/skills`,
+ * `.agents/skills` и далее). Навык, чьи копии лежат в РАЗНЫХ корнях — канон в `packages/`, живая
+ * копия в `.claude/skills` — имеет там ОДНУ копию, а одну копию не с чем сравнивать: она
+ * отбрасывается как не дублированная. То есть главный класс расхождения был для гейта невидим.
+ *
+ * ИЗМЕРЕНО 2026-09-03: `brutal-honesty-review` разошёлся ровно так (канон в skills-qe, копия в
+ * бандле p-replicator, живая в .claude/skills), и гейт не мог увидеть это В ПРИНЦИПЕ. Я тогда
+ * написал в отчёте «гейт разблокирован» — он никогда не был на этом заблокирован.
+ *
+ * Узкая область давала 19 дублирующихся навыков, полная даёт 211. Безопасность расширения
+ * проверена ДО правки: с полной областью и списком исключений дрейфа сегодня НОЛЬ.
+ */
+const DRIFT_SWEEP_SCOPE = 'all' as const;
+
+/**
+ * Базовая дата правила `backlog-covers-features`. Каталоги фич, заведённые ДО неё, правило не
+ * трогает: они появились раньше самого правила. ИЗМЕРЕНО 2026-09-03 — без базы правило даёт 236
+ * нарушений из 336 каталогов, и проверка, изобретающая полсотни нарушений в первый день, учит
+ * людей себя игнорировать. Дата = день, когда правило принято владельцем.
+ */
+const BACKLOG_COVERAGE_BASELINE = '2026-09-03';
+
 /** Literal command inventory, pinned against the main dispatch switch by a layer-1 test. */
 export const DZ_COMMANDS: readonly string[] = [
   'init', 'verify', 'sync', 'update', 'list', 'create-skill', 'info', 'scout',
   'workflow', 'workflow-lint', 'workflow-trace', 'migrate', 'doctor', 'install',
-  'bundle', 'teach', 'consolidate', 'recall', 'vector', 'brain', 'statusline',
+  'bundle', 'teach', 'consolidate', 'recall', 'vector', 'brain', 'statusline', 'store-guard',
   'usage', 'claim-check', 'lint', 'sign', 'sbom', 'guard', 'verify-pack', 'setup',
   'pretrain', 'compose', 'diff', 'recommend', 'upgrade', 'auto-canonicalize',
   'publish', 'release', 'parity', 'registry', 'benchmark', 'mcp-scan',
@@ -582,7 +629,7 @@ export const DZ_COMMANDS: readonly string[] = [
   'retro', 'feature-adr-setup', 'challenge', 'discrimination-check',
   'mutation-gate', 'delivery-check', 'skills-verify', 'compounding', 'deadwood',
   'epoch-replay', 'score', 'recap', 'cadence', 'qe-rounds', 'restart-advisor', 'tg-post',
-  'name-check', 'provenance-check', 'feature-adr-record', 'amendment-check', 'contract-check',
+  'name-check', 'brief-check', 'provenance-check', 'feature-adr-record', 'amendment-check', 'contract-check',
   'feature-adr-checkpoint', 'profile', 'reqe', 'qe-bridge', 'backlog', 'routing',
   'bto-optimize', 'dashboard', 'roam', 'import-ecc', 'chain',
 ];
@@ -633,13 +680,14 @@ Usage:
   dz restart-advisor --slug <s> [--threshold C|D] [--rounds N] [--json]   (read-only advisory decision over features/<slug>/.fa-state/checkpoints.jsonl and .dz/fa-training/<slug>/qe.jsonl. Defaults: threshold D, rounds 2 — both origins are printed. Equal sources corroborate; conflicts, torn/unreadable evidence, gaps, and unsafe paths are NOT ESTABLISHED. RECOMMENDATION ONLY: autoAction=false; never invokes feature-adr, deletes a stage, or writes advisor state. exit 0 established recommendation/no-recommendation / 2 NOT ESTABLISHED or invalid input / 1 unexpected runtime failure)
   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 brief-check <file> [--json]   (does a swarm brief declare OUTPUT_DIR, UNITS and ASSEMBLY_UNIT? parsed as DATA, refused by name; verifies the brief DECLARED the contract, not that the agent follows it. exit 0 ok / 1 refused / 2 unreadable)
   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 amendment-check --slug <slug> | --feature-dir <dir> | --all [--json]   (the deterministic Step-8 amendment gate: every AM-N / AM-CP-N row must resolve to a test found INSIDE the file the row names (the challenge-panel prefix is part of the id: AM-CP-1 is never AM-1); 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, UNLESS the plan explicitly declares \"None\"/\"нет\", which is an answer and reports skip. --all is a CENSUS and always exits 0. Does NOT prove non-vacuity — that is dz discrimination-check)
   dz contract-check --slug <s> [--json]   (read-only retrospective feature contract gate: extracts canonical AC-N + ADR Confirmation items, requires one artifact-anchored met|unmet|not-testable verdict per CC-N, and rejects A/B with unmet. exit 0 pass / 1 readable contract or verdict violation / 2 invalid invocation or unreadable/not-established artifacts)
   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)
@@ -647,7 +695,7 @@ Usage:
   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 17 NAMED failures with an audit record under features/<slug>/.fa-state/qe-bridge/ (runId, resolved executable + binOverride, prompt sha256, channel offsets, requestedOut, reportWritten, retained raw stdout; 0600 files in a 0700 dir), never a clean review. A --coder-family that contradicts the recorded reqe debt is refused. Writes features/<slug>/08b_reqe_report.md, which dz reqe --done settles unchanged. DISCLOSURE: the extracts you scope are sent to the Claude runtime; the bridge cannot classify secrets. DZ_QE_BRIDGE_CLAUDE_BIN is a TEST SEAM, not a flag. exit 0 signoff parsed (ANY grade — it reports, it does not gate) / 1 named failure / 2 usage)
   dz mutation-gate [--package <dir>] [--registry <file>] [--test-cmd "<cmd>"] [--only <id[,id]>] [--timeout <ms>] [--rebaseline per-entry|final] [--keep-scratch] [--json]   (prove each NAMED protection has a test that DISCRIMINATES: copy the package to a scratch dir, verify the baseline suite is green, apply each registry mutation, run the suite, REQUIRE red, restore. The red must be BEHAVIOURAL: a mutation that no longer parses is MUTATION_UNPARSEABLE; a red run whose OWN output reports a test FILE failing to load (node --test file-level not-ok with exitCode, vitest Failed Suites) is MUTATION_LOAD_FATAL — the signal comes from the same run as the failing count, never from a separate isolated import; red output whose shape matches no known runner is INCONCLUSIVE (a runner-coverage gap, loud, never PROVEN); a count far above the entry's bound is OVER_FAILING; a restored tree that does not reproduce green makes the entry INCONCLUSIVE (flaky). Mutation writes are realpath-contained to the scratch copy: a symlink escape or a node_modules/ target is refused (exit 2), the real tree is never written. A mutation that does not apply, a green suite, or an inconclusive run is a FAILURE — never a skip. exit 0 all proven / 1 gate failed / 2 setup error)
-  dz backlog add "<idea>" [--effort 1-5] [--proposal <text>] [--dry-run] [--project <dir>] [--json]   (capture an idea: semantic dedup against existing ideas via the Brain vector engine (DUPLICATE>=0.92 merges, RELATED links, NEW creates) + GoalMap alignment; --dry-run classifies without writing)
+  dz backlog add "<idea>" [--effort 1-5] [--proposal <text>] [--dry-run] [--allow-cold-start] [--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)
   dz backlog goals [--validate] [--project <dir>] [--json]                 (list/validate the compass at .dz/backlog/goals.json)
@@ -661,7 +709,7 @@ Usage:
   dz backlog jira <id> [--project <dir>] [--json]                          (draft a Jira issue via the configurable adapter (backlog.jira.adapter: jira-mcp|copilot-mcp|none); none writes an auditable jira-outbox/<id>.json stub)
   dz backlog harmonize [--apply] [--threshold <0-1>] [--project <dir>] [--json]   (batch semantic dedup of the backlog ideas; --dry-run default, --apply snapshots first)
   dz setup --target <name> [--preset <name>] [--select id,id,...] [--skills-dir <dir>] [--project <dir>] [--memory agentdb] [--no-memory] [--no-hooks] [--no-verify] [--install-driver] [--force] [--enrich]   (--target codex ALSO installs + LIVE-verifies the codex hooks; an unverified hook exits non-zero WITHOUT aborting the rest of setup)
-  dz teach "<pattern>" [--class-form "<template with :slot>"] [--reward <0-1>] [--domain <name>] [--type rule|success-pattern|lesson-learned] [--project <dir>] [--no-mirror]   (class form is optional; rejection never blocks the specific write; --project pins the learned store to <dir>/.dz)
+  dz teach "<pattern>" [--class-form "<template with :slot>"] [--reward <0-1>] [--domain <name>] [--type rule|success-pattern|lesson-learned] [--project <dir>] [--no-mirror] [--allow-cold-start]   (class form is optional; rejection never blocks the specific write; --project pins the learned store to <dir>/.dz)
   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>] [--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)
@@ -681,7 +729,8 @@ Usage:
   dz brain expand <kuId> [--source <slug>] [--json]                    (full-content lookup for a citation kuId; --json emits the full KU object)
   dz brain init  [--project <dir>] [--k <N>]                           (wire the grounding hook into .claude/settings.json — opt-in)
   dz statusline [--json] [--install] [--project <dir>]                 (live self-learning panel for Claude Code's status bar; reads the CC JSON payload from STDIN)
-  dz statusline --fa-record --slug <s> --step "<label>" [--kind <feature-adr|loop>] [--recalled <n>] [--stored <n>] [--mode <m>]   (feature-adr: record live per-run learning state → 📐 panel segment)
+  dz store-guard [--status|--reset] [--yes] [--project <dir>]          (show the monotonic external high-water mark; --reset is the only lowering path and requires confirmation or --yes)
+  dz statusline --fa-record --slug <s> --step "<label>" [--kind <feature-adr|loop>] [--tier <S|M|L|XL>] [--recalled <n>] [--stored <n>] [--mode <m>]   (feature-adr: record live per-run learning state + phase → 📐 SECOND-LINE phase panel; a plain "Step <n>" label that goes BACKWARDS against a slot younger than 90 min is absorbed as a stale duplicate — prefix the label with ⛔ or ⏸ to record a legitimate regression)
   dz usage [--json] [--project <dir>] | dz usage --calibrate --session <pct> --weekly <pct> [--model fable=<pct>] [--project <dir>]  (ESTIMATE Claude usage from fixed reset windows; optional per-model weekly binding; exit 0 ALWAYS; pct=null when limits unconfigured)
   dz usage --by-stage [--run <runId> | --slug <slug>] [--epsilon <0..1>] [--write <file.jsonl>] [--json]   (per-stage cost ledger for ONE feature-adr run + the reconciliation invariant: accounted + unaccounted = run total; verdict BALANCED | DEFECT | INSUFFICIENT_DATA; local transcript ESTIMATES — catches ATTRIBUTION errors, not pricing errors)
   dz chain [--project <dir>] [--json]   (verify EVERY hash-chained journal in ONE command: coverage is DERIVED from the CHAINED_JOURNALS registry, never typed, so a journal cannot be given a chain and checked by nobody. An ABSENT journal is NAMED absent, never omitted — omission and cleanliness are indistinguishable in a report. Statuses: ok | healed (defects the current unbroken run has outlived — verdicts over present records are sound) | unchained (present, no chained record yet — legal) | absent | broken | unreadable. Exit 1 on broken/unreadable: a verifier that reports damage and exits 0 is one no automation can act on)
@@ -709,6 +758,10 @@ Usage:
   dz dashboard
   dz roam   [--apply] [--slug <slug>]
   dz import-ecc [--local-path <dir>] [--select id,id,...] [--limit N] [--output <dir>] [--force]
+  dz retro   [transcript-path] [--json] [--threshold N] [--no-teach] [--project <dir>] [--install-hook]   (per-session retrospective + co-learning: mines the session transcript for recurring PROCESS rakes, drills you, and teaches the same lesson to the store)
+  dz feature-adr-setup [--plan] [--from-spec <spec.json>] [--guards [--loc-cap <n>]] [--gates [--target <name>]] [--apply] [--json]   (scaffold the project-awareness files feature-adr reads — vision / map / testing / project-skills — plus the deterministic project guards and the portable delivery gates; --guards and --gates work STANDALONE or with --from-spec, and --apply writes for all three; without --apply everything is a preview)
+  dz mr-rakes [--json] [--candidate N] [--confirmed N] [--teach] [--gen-critic <path> [--apply]]   (experimental: mine the review corpus — features' QE reports + REVIEW files — for RECURRING mistakes and close them into self-learning)
+  dz bto-optimize --split | --plan | --select | --scope-check | --diff [--json]   (experimental: deterministic tune/holdout split, budget plan and holdout-no-regress winner selection behind the /bto-optimize skill)
   dz help
 
 Global: --version | -v [--json]   (prints this CLI's own semver on one line, exit 0; "unknown" + exit 1 when unresolvable)
@@ -1396,7 +1449,7 @@ async function cmdScout(options: Map<string, string>, flags: Set<string>, cwd: s
 
   try {
     const scanTopics = topicsArg ? topicsArg.split(',').map((t) => t.trim()) : undefined;
-    const { results: repos, totalBySource } = await scanAllSources({
+    const { results: repos, totalBySource, statusBySource } = await scanAllSources({
       token,
       topics: scanTopics,
       since,
@@ -1410,10 +1463,16 @@ async function cmdScout(options: Map<string, string>, flags: Set<string>, cwd: s
       .join(', ');
     write(`Sources: ${sourceLines}`);
 
-    // Memory: diff with previous scan
+    // Memory: diff with previous scan.
+    //
+    // СОСТОЯНИЕ ИСТОЧНИКОВ ПЕРЕДАЁТСЯ ОБЯЗАТЕЛЬНО. Без него разность не выводит исчезновений
+    // вообще — и это правильно: источник, ответивший кодом ошибки, раньше делал ВСЕ свои записи
+    // «пропавшими» на экране, то есть отчёт печатал факт о нашей сети как факт о мире.
     if (showDiff || memory.size > 0) {
-      const diff = memory.diff(repos);
-      if (diff.newRepos.length > 0 || diff.goneRepos.length > 0 || diff.changedScore.length > 0) {
+      const health: Record<string, string> = {};
+      for (const [source, status] of Object.entries(statusBySource)) health[source] = status.health;
+      const diff = memory.diff(repos, health);
+      if (diff.newRepos.length > 0 || diff.goneRepos.length > 0 || diff.changedScore.length > 0 || diff.goneOmittedReason !== undefined) {
         write(memory.diffMarkdown(diff));
       } else if (memory.size > 0) {
         write(`\nNo changes since last scan (${memory.size} repos tracked).\n`);
@@ -2216,6 +2275,49 @@ function cmdBundle(options: Map<string, string>, flags: Set<string>, cwd: string
   return 0;
 }
 
+/**
+ * Команда npm для установки пакета В ЦЕЛЕВОЙ КАТАЛОГ, а не куда решит npm.
+ *
+ * ЗАЧЕМ `--prefix`. Без него npm при отсутствии `package.json` в текущем каталоге поднимается по
+ * дереву до первого найденного и мутирует ЕГО — а `dz` потом ищет пакет в
+ * `<цель>/node_modules` и не находит. Место установки и место проверки были двумя независимыми
+ * предположениями, и совпадали они только по удаче.
+ *
+ * ИЗМЕРЕНО 2026-09-03 (полевой случай владельца): установка в каталог без `package.json`
+ * записала в `/home`, где лежит ЧУЖОЙ проект; ручной откат вернул `package.json`, а запись
+ * `extraneous` в `/home/package-lock.json` пережила откат.
+ *
+ * ПОЧЕМУ НЕ ОТКАЗ (ADR-001, вариант A отвергнут). Отказ запретил бы законный сценарий: проект
+ * внутри монорепо, намеренно не имеющий своего `package.json` и опирающийся на родительский
+ * воркспейс. `--prefix` согласует установку с проверкой ПО ПОСТРОЕНИЮ и сценарий сохраняет.
+ *
+ * ЧИСТАЯ: ни файловой системы, ни запуска npm — проверяется без обоих. Путь экранируется, потому
+ * что каталоги с пробелом в имени встречаются в наших же тестах.
+ */
+export function buildInstallArgs(npmSpec: string, projectRoot: string): readonly string[] {
+  return ['install', npmSpec, '--prefix', projectRoot, '--save-dev', '--no-fund', '--no-audit'];
+}
+
+/**
+ * Та же команда СТРОКОЙ — только для показа человеку и для тестового шва.
+ *
+ * НЕ ДЛЯ ИСПОЛНЕНИЯ, и это не стилистическая оговорка. `JSON.stringify` НЕ является экранированием
+ * для оболочки: внутри двойных кавычек оболочка по-прежнему выполняет `$(...)` и обратные кавычки.
+ * ИЗМЕРЕНО 2026-09-03 — `execSync('echo ' + JSON.stringify('pkg$(touch ФАЙЛ)'))` создал файл.
+ * Прежняя редакция этого комментария утверждала «путь экранируется»; это было неверно, и находку
+ * предъявило кросс-семейное ревью (gpt-5.6-sol), а я подтвердил её пробой.
+ *
+ * Боевой путь исполняется через `execFileSync` массивом аргументов — оболочки в цепочке нет вовсе,
+ * поэтому подставлять некуда. Это структурное лечение, а не более хитрое экранирование.
+ */
+export function buildInstallCommand(npmSpec: string, projectRoot: string): string {
+  // ЗНАЧЕНИЯ в кавычках, ФЛАГИ без — та же форма, что печаталась до этой фичи, чтобы читатель
+  // (и закреплённые тесты) видели знакомую строку. Кавычки здесь — ЧИТАЕМОСТЬ, а не безопасность:
+  // безопасность даёт отсутствие оболочки на боевом пути.
+  return `npm install ${JSON.stringify(npmSpec)} --prefix ${JSON.stringify(projectRoot)}`
+    + ' --save-dev --no-fund --no-audit';
+}
+
 async function cmdInstall(
   options: Map<string, string>,
   flags: Set<string>,
@@ -2267,14 +2369,36 @@ async function cmdInstall(
 
   const projectRoot = resolve(cwd, options.get('project') ?? '.');
 
+  // ПРЕДПОСЫЛКА НАЗЫВАЕТСЯ ДО ПОБОЧНОГО ЭФФЕКТА, А НЕ ПОСЛЕ (ADR-001, FR-2).
+  //
+  // Проверка стоит ЗДЕСЬ, до развилки installRunner/execSync, и это не стилистика. Поставить её
+  // внутрь ветки execSync значило бы оставить боевой путь непокрытым при зелёных тестах — ровно
+  // то состояние, из которого фича и родилась.
+  const hasOwnManifest = existsSync(join(projectRoot, 'package.json'));
+  if (!hasOwnManifest) {
+    write(`dz install: ${projectRoot} — не npm-проект (нет своего package.json).`);
+    write(`  Ставлю ЛОКАЛЬНО в него: npm получит --prefix, package.json и node_modules появятся здесь.`);
+    write(`  Без --prefix npm поднялся бы по дереву и записал в ЧУЖОЙ проект выше — измерено 2026-09-03.`);
+  }
+
   // Step 1: npm install the package (installRunner is the CliIo test seam — unset in production)
   write(`Installing ${specResolution.npmSpec}${specResolution.kind === 'name' ? '' : ` (${specResolution.kind} → node_modules/${specResolution.dirName})`}...`);
-  const installCmd = `npm install ${JSON.stringify(specResolution.npmSpec)} --save-dev --no-fund --no-audit`;
+  const installCmd = buildInstallCommand(specResolution.npmSpec, projectRoot);
   try {
     if (installRunner) installRunner(installCmd, projectRoot);
-    else execSync(installCmd, { cwd: projectRoot, stdio: 'pipe', encoding: 'utf-8' });
+    // БЕЗ ОБОЛОЧКИ. execFileSync с массивом аргументов не запускает shell, поэтому имя пакета или
+    // путь с `$(...)` подставить нечему. Строка выше — для показа и для тестового шва, не для
+    // исполнения (см. докстринг buildInstallCommand).
+    else execFileSync('npm', [...buildInstallArgs(specResolution.npmSpec, projectRoot)], { cwd: projectRoot, stdio: 'pipe', encoding: 'utf-8' });
   } catch (err) {
     write(`dz install: npm install failed — ${err instanceof Error ? err.message : String(err)}`);
+    // НЕАТОМАРНЫЙ ОТКАЗ НАЗЫВАЕТСЯ ВСЛУХ (ADR-001, FR-4). Названо кросс-семейной проверкой
+    // 2026-09-03: npm мог успеть изменить package.json, файл замков и node_modules и упасть уже
+    // после этого. Отката у нас нет — и молчать об этом хуже, чем не откатывать: пользователь
+    // считает каталог нетронутым. Полевой случай: ручной откат вернул package.json, а запись
+    // extraneous в файле замков пережила его.
+    write(`  npm мог успеть изменить файлы ДО падения — проверьте ${join(projectRoot, 'package.json')},`);
+    write(`  ${join(projectRoot, 'package-lock.json')} и ${join(projectRoot, 'node_modules')}: отката dz не делает.`);
     return 1;
   }
 
@@ -2535,7 +2659,7 @@ function cmdStatuslineInstall(options: Map<string, string>, cwd: string, write:
  * `--kind <feature-adr|loop>` identifies the producer, defaults to `feature-adr`, and rejects any
  * other value rather than silently weakening panel arbitration.
  */
-function cmdStatuslineFaRecord(options: Map<string, string>, cwd: string, write: Write): number {
+function cmdStatuslineFaRecord(options: Map<string, string>, cwd: string, write: Write, writeErr: WriteErr): number {
   const slug = (options.get('slug') ?? '').trim();
   const step = (options.get('step') ?? '').trim();
 
@@ -2595,19 +2719,42 @@ function cmdStatuslineFaRecord(options: Map<string, string>, cwd: string, write:
     return 1;
   }
 
+  // fa-phase-statusline (acid A1): --tier drives done/total on the phase line — an invalid tier is
+  // REJECTED before anything is written (nothing slotted, nothing ledgered), never silently dropped.
+  const tierRaw = options.get('tier');
+  const tier = tierRaw?.trim();
+  if (tier !== undefined && tier !== 'S' && tier !== 'M' && tier !== 'L' && tier !== 'XL') {
+    write(`dz statusline --fa-record: --tier must be S, M, L or XL (got "${tierRaw}")`);
+    write('  Example: dz statusline --fa-record --slug add-user-auth --step "Step 7 Code" --tier M');
+    return 1;
+  }
+
   const mode = options.get('mode');
   const projectRoot = resolve(cwd, options.get('project') ?? '.');
-  const state = writeFeatureAdrState(projectRoot, {
+  const outcome = writeFeatureAdrStateDetailed(projectRoot, {
     kind: kindRaw, slug, step, recalled, stored,
     ...(reinforced > 0 ? { reinforced } : {}),
     ...(mode !== undefined && mode.trim() !== '' ? { mode: mode.trim() } : {}),
+    ...(tier !== undefined ? { tier } : {}),
   });
+  const state = outcome.state;
 
   if (state === undefined) {
+    // [AM-5] A REFUSED slot write is LOUD. A held `fa-phase-slot` lock or an unwritable `.dz` used
+    // to return a bare `undefined`, and a caller reading silence as success is exactly the
+    // "absence of a receipt is not success" class. The reason goes to stderr — diagnosis, not
+    // data — and the EXIT CODE is unchanged for a refusal, because the panel must never break the
+    // pipeline that is only reporting to it.
+    if (outcome.refused !== undefined) {
+      writeErr(`fa-record: slot write refused (${slug}): ${outcome.refused}`);
+      return 0;
+    }
     write(`dz statusline --fa-record: could not write learning state under ${projectRoot}/.dz/feature-adr/`);
     return 1;
   }
-  write(`dz statusline: recorded /feature-adr learning state for "${slug}" (${step}) — 🎓 ${state.pool} pool · ↑${state.recalled} used · +${state.stored} new · ↻${state.reinforced ?? 0} reinforced`);
+  // state.step, not the flag: the monotonic guard may have kept a LATER step against a stale
+  // duplicate record (fa-phase-statusline P1) — print what actually stands in the slot.
+  write(`dz statusline: recorded /feature-adr learning state for "${slug}" (${state.step}) — 🎓 ${state.pool} pool · ↑${state.recalled} used · +${state.stored} new · ↻${state.reinforced ?? 0} reinforced`);
   return 0;
 }
 
@@ -2759,8 +2906,12 @@ function statuslineEta(projectRoot: string, state: FeatureAdrState, nowMs: numbe
  * least a minimal `dz` even on total failure.
  *
  * Flags: `--install` wires it into settings.json; `--fa-record` records a live `/feature-adr`
- * learning state (WRITES — see {@link cmdStatuslineFaRecord}); `--json` prints the raw data object;
- * default prints the status line (with a 📐 pipeline segment prepended when a fresh run is in flight).
+ * learning state (WRITES — see {@link cmdStatuslineFaRecord}); `--json` prints the raw data object
+ * (plus `featureAdrLine`, the rendered phase line, when a fresh /feature-adr run is in flight);
+ * default prints the status line, with the 📐 phase panel as its OWN SECOND LINE (format B —
+ * fa-phase-statusline ADR-001 D1; Claude Code renders every stdout line of a statusline command).
+ * The ETA fragment main shipped for that panel rides the SECOND line with it (fa-phase-statusline ADR-001 D1) — the panel
+ * moved, the estimate was not dropped.
  */
 function cmdStatusline(
   options: Map<string, string>,
@@ -2768,12 +2919,14 @@ function cmdStatusline(
   cwd: string,
   write: Write,
   readStdin: () => string,
+  writeErr: WriteErr,
 ): number {
   if (flags.has('install')) return cmdStatuslineInstall(options, cwd, write);
-  if (flags.has('fa-record')) return cmdStatuslineFaRecord(options, cwd, write);
+  if (flags.has('fa-record')) return cmdStatuslineFaRecord(options, cwd, write, writeErr);
 
   try {
     const projectRoot = statuslineProjectRoot(readStdin(), options, cwd);
+    warnLearningStoreRead(projectRoot, writeErr, 'dz statusline');
     const data = statuslineData(projectRoot);
     const fa = data.featureAdr;
     let eta: EtaEstimate | undefined;
@@ -2789,27 +2942,55 @@ function cmdStatusline(
       }
     }
 
+    // fa-phase-statusline (ADR-001 D1): the phase line renders from the slot ALONE — a pure
+    // function over data.featureAdr, computed once here for both the plain and --json surfaces.
+    const phaseLine = fa !== undefined ? renderFeatureAdrPhaseLine(fa) : undefined;
+
     if (flags.has('json')) {
-      write(JSON.stringify({ ...data, ...(eta !== undefined ? { eta } : {}) }));
+      write(JSON.stringify({
+        ...data,
+        ...(eta !== undefined ? { eta } : {}),
+        ...(phaseLine !== undefined ? { featureAdrLine: phaseLine } : {}),
+      }));
       return 0;
     }
 
-    let line = `🎓 dz: ${data.patterns} patterns${data.usedPatterns !== undefined ? ` · ${data.usedPatterns} used` : ''} · 🧠 ${data.brainSources} sources`;
+    const breakdown = data.patternBreakdown;
+    let line = breakdown === undefined
+      ? `🎓 dz: ${data.patterns} patterns`
+      : `🎓 dz: ${data.patterns} (${breakdown.active} актив${breakdown.quarantined > 0
+        ? ` · ${breakdown.quarantined} карантин${breakdown.attention ? ' ⚠' : ''}`
+        : ''})${breakdown.tierDelta !== undefined ? ` ⚠ тиры Δ${breakdown.tierDelta}` : ''}`;
+    if (data.storeHealth?.verdict === 'collapsed') {
+      line += ` ⛔ ОБВАЛ: было ${data.storeHealth.previousMax ?? '?'} · dz store-guard --reset`;
+    } else if (data.storeHealth?.verdict === 'cold-start-over-existing') {
+      line += ` ⛔ СТОР ПУСТ: было ${data.storeHealth.previousMax ?? '?'} · восстановить из снимков ${data.storeHealth.snapshotPath ?? ''}`.trimEnd();
+    } else if (data.storeHealth?.verdict === 'unreadable') {
+      line += ` ⛔ СТОР НЕЧИТАЕМ${data.storeHealth.unreadableFiles !== undefined && data.storeHealth.unreadableFiles.length > 0
+        ? `: ${data.storeHealth.unreadableFiles.join(', ')}` : ''}`;
+    } else if (data.storeHealth?.verdict === 'source-changed') {
+      line += ' ⚠ смена источника хранения';
+    }
+    line += `${data.usedPatterns !== undefined ? ` · ${data.usedPatterns} used` : ''} · 🧠 ${data.brainSources} sources`;
     const branch = statuslineGitBranch(projectRoot);
     if (branch !== undefined) line += ` · ⎇ ${branch}`;
     if (data.consolidatedAgeH !== undefined) line += ` · ⟳ ${data.consolidatedAgeH}h`;
 
-    // Live /feature-adr run in flight → PREPEND the pipeline learning segment to the base dz line.
-    if (fa !== undefined) {
-      // The producer marker reached data and arbitration in a previous round but not this label, so the bar asserted a pipeline that was not running.
-      if (fa.kind === 'loop') {
-        line = `🔁 loop ${fa.step} · ${line}`;
-      } else {
-        line = `📐 feature-adr ${fa.step} · ${etaFragment !== undefined ? `${etaFragment} · ` : ''}🎓 ${fa.pool} pool · ↑${fa.recalled} used · +${fa.stored} new · ↻${fa.reinforced ?? 0} reinforced · ${line}`;
-      }
+    // Live loop run in flight → PREPEND its segment to the base dz line (unchanged). A live
+    // /feature-adr run no longer glues into line 1: its 📐 segment IS the second line (format B) —
+    // Claude Code renders every stdout line of a statusline command (fa-phase-statusline ADR-001 D1).
+    if (fa !== undefined && fa.kind === 'loop') {
+      line = `🔁 loop ${fa.step} · ${line}`;
     }
 
     write(line);
+    // fa-phase-statusline ADR-001 D1: the phase panel moved to line 2 and TOOK main's ETA fragment with it. The move is
+    // the point of format B (ADR-001 D1); dropping the estimate would have been a silent
+    // regression of a feature `main` shipped while this branch was stranded, so it rides here
+    // instead. A phase line that renders (fresh, non-terminal, non-loop slot) is the only gate.
+    if (phaseLine !== undefined) {
+      write(`${phaseLine}${etaFragment !== undefined ? ` · ${etaFragment}` : ''}`);
+    }
     return 0;
   } catch {
     // A garbled status bar is worse than a terse one — print SOMETHING minimal, never throw.
@@ -3432,6 +3613,282 @@ function learningStoreLine(
   ) + (reason ? '  [' + reason + ']' : '');
 }
 
+function inspectLearningStore(projectRoot: string): {
+  mark: StoreMark | undefined;
+  health: StoreHealth;
+  rows: ReturnType<typeof countLearningStoreRowsReadonly>;
+} {
+  const mark = readStoreMark(projectRoot);
+  const rows = countLearningStoreRowsReadonly(projectRoot);
+  return { mark, rows, health: checkStoreHealth({ projectRoot, ...rows, mark }) };
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+function storeGuardResetCommand(projectRoot: string): string {
+  return `dz store-guard --reset --project ${shellQuote(projectRoot)}`;
+}
+
+function lexicalSourceLines(rows: ReturnType<typeof countLearningStoreRowsReadonly>): string[] {
+  return [
+    `  lexical selected: ${rows.lexicalSourcePath} (${rows.lexicalSource}, ${rows.lexicalRows} rows)`,
+    ...(rows.lexicalIgnoredSourcePath === undefined ? [] : [
+      `  lexical ignored: ${rows.lexicalIgnoredSourcePath} (${rows.lexicalIgnoredRows} rows)`,
+    ]),
+  ];
+}
+
+function storeGuardRecoveryLines(
+  projectRoot: string,
+  mark: StoreMark | undefined,
+  health: StoreHealth,
+  rows?: ReturnType<typeof countLearningStoreRowsReadonly>,
+): string[] {
+  const snapshots = storeSnapshotPath(projectRoot);
+  const markPath = storeGuardPath(projectRoot);
+  let lexicalSnapshot: 'sqlite' | 'jsonl' | undefined;
+  let vectorSnapshot = false;
+  try {
+    const names = existsSync(snapshots) ? readdirSync(snapshots) : [];
+    const hasSqlite = names.some((name) => /^lexical\..+\.sqlite$/.test(name));
+    const hasJsonl = names.some((name) => /^lexical\..+\.jsonl$/.test(name));
+    const preferred = mark?.lexicalSource === 'sqlite' || mark?.lexicalSource === 'jsonl'
+      ? mark.lexicalSource
+      : rows?.lexicalSource;
+    if (preferred === 'jsonl' && hasJsonl) lexicalSnapshot = 'jsonl';
+    else if (preferred === 'sqlite' && hasSqlite) lexicalSnapshot = 'sqlite';
+    else if (hasSqlite) lexicalSnapshot = 'sqlite';
+    else if (hasJsonl) lexicalSnapshot = 'jsonl';
+    vectorSnapshot = names.some((name) => /^vector\..+\.sqlite$/.test(name));
+  } catch {
+    lexicalSnapshot = undefined;
+    vectorSnapshot = false;
+  }
+  const lines = [
+    `dz store guard: REFUSED — ${health.reason}`,
+    `  mark: ${markPath}`,
+    ...(mark === undefined ? [] : [`  recorded rows: lexical=${mark.lexicalMax} (${mark.lexicalSource}), vector=${mark.vectorMax}`]),
+    ...(rows === undefined ? [] : lexicalSourceLines(rows)),
+  ];
+  if (lexicalSnapshot !== undefined && vectorSnapshot) {
+    const lexicalDestination = lexicalSnapshot === 'sqlite'
+      ? join(projectRoot, '.dz', 'memory', 'patterns.sqlite')
+      : join(projectRoot, '.dz', 'patterns.jsonl');
+    lines.push(
+      `  snapshots: ${snapshots}/`,
+      `  restore: mkdir -p ${shellQuote(dirname(lexicalDestination))} && cp ${shellQuote(join(snapshots, `lexical.<timestamp>.${lexicalSnapshot}`))} ${shellQuote(lexicalDestination)} && cp ${shellQuote(join(snapshots, 'vector.<timestamp>.sqlite'))} ${shellQuote(join(projectRoot, '.dz', 'agentdb.db'))}`,
+    );
+  } else {
+    lines.push(
+      `  snapshots: none found in ${snapshots}/`,
+      `  create one manually: scripts/dz-store-snapshot.sh --project ${shellQuote(projectRoot)}`,
+    );
+  }
+  lines.push(
+    `  accept current counts: ${storeGuardResetCommand(projectRoot)}`,
+    '  continue intentionally: set DZ_ALLOW_COLD_START=1 or pass --allow-cold-start',
+  );
+  return lines;
+}
+
+function observedRows(
+  rows: ReturnType<typeof countLearningStoreRowsReadonly>,
+): StoreCountSnapshot | undefined {
+  return typeof rows.lexicalRows === 'number' && typeof rows.vectorRows === 'number'
+    ? { lexicalRows: rows.lexicalRows, vectorRows: rows.vectorRows, lexicalSource: rows.lexicalSource }
+    : undefined;
+}
+
+interface MarkRefreshOptions {
+  readonly reader?: boolean;
+}
+
+/** Mark maintenance is diagnostic: the store operation already completed and must keep its exit code. */
+function refreshLearningStoreMark(
+  projectRoot: string,
+  writeErr: WriteErr,
+  command: string,
+  options: MarkRefreshOptions = {},
+): void {
+  try {
+    const rows = countLearningStoreRowsReadonly(projectRoot);
+    const counts = observedRows(rows);
+    if (counts === undefined) {
+      writeErr(`⚠ dz store guard: ${options.reader ? 'reader observation' : 'store operation'} completed but the external mark was not updated — a store tier is unreadable`);
+      return;
+    }
+    writeStoreMark(projectRoot, {
+      ...counts,
+      observedAt: new Date().toISOString(),
+      command,
+    }, options.reader ? { timeoutMs: 0 } : {});
+  } catch (error) {
+    if (options.reader && error instanceof NamedLockTimeoutError) return;
+    writeErr(`⚠ dz store guard: ${options.reader ? 'reader observation' : 'store operation'} completed but the external mark could not be updated — ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function storeGuardResetReminder(projectRoot: string, writeErr: WriteErr, command: string): void {
+  try {
+    const rows = countLearningStoreRowsReadonly(projectRoot);
+    const mark = readStoreMark(projectRoot);
+    writeErr(`⚠ DZ STORE GUARD — ${command}: store now lexical=${rows.lexicalRows}, vector=${rows.vectorRows}; maximum remains lexical=${mark?.lexicalMax ?? 'none'}, vector=${mark?.vectorMax ?? 'none'}; reconcile explicitly: ${storeGuardResetCommand(projectRoot)}`);
+    for (const line of lexicalSourceLines(rows)) writeErr(line);
+  } catch (error) {
+    writeErr(`⚠ DZ STORE GUARD — ${command}: store changed; inspect it and reconcile explicitly with ${storeGuardResetCommand(projectRoot)} (${error instanceof Error ? error.message : String(error)})`);
+  }
+}
+
+/** Fail closed for store writers, except for an explicit per-process/per-command override. */
+function allowLearningStoreWrite(
+  projectRoot: string,
+  flags: Set<string>,
+  writeErr: WriteErr,
+  command: string,
+): boolean {
+  let inspection: ReturnType<typeof inspectLearningStore>;
+  try {
+    inspection = inspectLearningStore(projectRoot);
+  } catch (error) {
+    const health: StoreHealth = {
+      verdict: 'unreadable',
+      reason: `cannot read the external mark (${error instanceof Error ? error.message : String(error)})`,
+    };
+    for (const line of storeGuardRecoveryLines(projectRoot, undefined, health)) writeErr(line);
+    return false;
+  }
+  if (inspection.health.verdict === 'no-mark' || inspection.health.verdict === 'ok') {
+    // The successful write path records the resulting counts. Refreshing here as
+    // well would emit the same telemetry failure twice when the external mark is
+    // unavailable, and would receipt a source transition before the command's
+    // own row had landed.
+    return true;
+  }
+  if (inspection.health.verdict === 'source-changed') {
+    const counts = observedRows(inspection.rows);
+    if (counts === undefined) return false;
+    writeErr(`⚠ DZ STORE GUARD WARNING — SOURCE CHANGED: ${inspection.health.reason}; ${storeGuardResetCommand(projectRoot)}`);
+    for (const line of lexicalSourceLines(inspection.rows)) writeErr(line);
+    try {
+      // Consume the single migration allowance BEFORE the store write. If the
+      // following command fails, the safe result is a consumed allowance that
+      // requires an explicit reset, never a silently reusable permission.
+      writeStoreMark(projectRoot, { ...counts, observedAt: new Date().toISOString(), command }, {
+        expectedPreviousLexicalSource: inspection.mark?.lexicalSource ?? 'unknown',
+      });
+      return true;
+    } catch (error) {
+      writeErr(`dz store guard: REFUSED — source-change allowance could not be recorded: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+
+  const allowed = process.env.DZ_ALLOW_COLD_START === '1' || flags.has('allow-cold-start');
+  if (allowed) {
+    const label = inspection.health.verdict.replaceAll('-', ' ').toUpperCase();
+    writeErr(`⚠ DZ STORE GUARD WARNING — ${label}: ${inspection.health.reason}; explicit cold-start override accepted`);
+    return true;
+  }
+  for (const line of storeGuardRecoveryLines(projectRoot, inspection.mark, inspection.health, inspection.rows)) writeErr(line);
+  return false;
+}
+
+/** Readers warn on damage and bootstrap/refresh a healthy non-empty store mark. */
+function warnLearningStoreRead(projectRoot: string, writeErr: WriteErr, command: string): void {
+  try {
+    const { health, rows, mark } = inspectLearningStore(projectRoot);
+    if (health.verdict === 'collapsed' || health.verdict === 'cold-start-over-existing' || health.verdict === 'unreadable'
+      || health.verdict === 'source-changed') {
+      writeErr(`⚠ DZ STORE GUARD WARNING — ${health.verdict.replaceAll('-', ' ').toUpperCase()}: ${health.reason}`);
+      for (const line of lexicalSourceLines(rows)) writeErr(line);
+      return;
+    }
+    const counts = observedRows(rows);
+    if (counts !== undefined && counts.lexicalRows + counts.vectorRows > 0
+      && (mark === undefined || mark.lexicalLast !== counts.lexicalRows || mark.vectorLast !== counts.vectorRows
+        || mark.lexicalSource !== counts.lexicalSource
+        || mark.lexicalMax < counts.lexicalRows || mark.vectorMax < counts.vectorRows)) {
+      refreshLearningStoreMark(projectRoot, writeErr, command, { reader: true });
+    }
+  } catch (error) {
+    writeErr(`⚠ DZ STORE GUARD WARNING — external mark unreadable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+async function cmdStoreGuard(
+  options: Map<string, string>, flags: Set<string>, cwd: string, write: Write, writeErr: WriteErr,
+  stdinText: string | undefined, interactive: boolean,
+): Promise<number> {
+  const projectRoot = resolve(cwd, options.get('project') ?? '.');
+  const path = storeGuardPath(projectRoot);
+  const reset = flags.has('reset');
+  const status = flags.has('status') || options.has('status');
+  if (reset && status) {
+    writeErr('dz store-guard: --status and --reset are mutually exclusive');
+    return 2;
+  }
+  if (reset) {
+    const rows = countLearningStoreRowsReadonly(projectRoot);
+    const counts = observedRows(rows);
+    if (counts === undefined) {
+      writeErr(`dz store-guard: REFUSED — cannot reset from an unreadable store; mark: ${path}`);
+      return 1;
+    }
+    try {
+      const previous = readStoreMark(projectRoot);
+      const beforeLexical = previous?.lexicalMax ?? counts.lexicalRows;
+      const beforeVector = previous?.vectorMax ?? counts.vectorRows;
+      writeErr('⚠ dz store-guard --reset: manual operator decision required; this lowers the recorded high-water evidence');
+      writeErr(`  old maximum: lexical=${beforeLexical}, vector=${beforeVector}`);
+      writeErr(`  new observed: lexical=${counts.lexicalRows} (${counts.lexicalSource}), vector=${counts.vectorRows}`);
+      for (const line of lexicalSourceLines(rows)) writeErr(line);
+      let answer = stdinText?.trim().split(/\r?\n/, 1)[0]?.trim().toLowerCase() ?? '';
+      if (!flags.has('yes') && answer === '' && interactive && process.stdin.isTTY) {
+        const { createInterface } = await import('node:readline/promises');
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        try { answer = (await rl.question('  type yes to continue: ')).trim().toLowerCase(); }
+        finally { rl.close(); }
+      }
+      if (!flags.has('yes') && !['y', 'yes', 'да'].includes(answer)) {
+        writeErr(`dz store-guard: REFUSED — reset was not confirmed; re-run with --yes or answer yes`);
+        return 1;
+      }
+      const current = countLearningStoreRowsReadonly(projectRoot);
+      const currentCounts = observedRows(current);
+      if (currentCounts === undefined || !isDeepStrictEqual(currentCounts, counts)) {
+        writeErr('dz store-guard: REFUSED — store counts changed after confirmation; inspect and confirm again');
+        return 1;
+      }
+      const mark = resetStoreMark(projectRoot, {
+        ...counts,
+        observedAt: new Date().toISOString(),
+        command: 'dz store-guard --reset',
+      });
+      write(`dz store-guard: RESET — accepted lexical=${mark.lexicalMax}, vector=${mark.vectorMax}`);
+      write(`  mark: ${path}`);
+      write(`  receipt: ${mark.resetAt?.at} — ${mark.resetAt?.reason}`);
+      return 0;
+    } catch (error) {
+      writeErr(`dz store-guard: reset failed — ${error instanceof Error ? error.message : String(error)}; mark: ${path}`);
+      return 1;
+    }
+  }
+  try {
+    const inspection = inspectLearningStore(projectRoot);
+    write(`dz store-guard: ${inspection.health.verdict.toUpperCase()} — ${inspection.health.reason}`);
+    write(`  mark: ${path}`);
+    write(`  current rows: lexical=${inspection.rows.lexicalRows}, vector=${inspection.rows.vectorRows}`);
+    for (const line of lexicalSourceLines(inspection.rows)) write(line);
+    write(`  recorded: ${inspection.mark === undefined ? 'none' : JSON.stringify(inspection.mark)}`);
+    return 0;
+  } catch (error) {
+    writeErr(`dz store-guard: mark unreadable — ${error instanceof Error ? error.message : String(error)}; mark: ${path}`);
+    return 1;
+  }
+}
+
 async function runTeachGuardReinforcement(
   projectRoot: string,
   dzId: string,
@@ -3465,6 +3922,12 @@ async function cmdTeach(
   // 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;
+  const teachWillWrite = flags.has('harmonize')
+    ? false
+    : options.has('from-json')
+      || (options.get('reinforce') ?? '').trim() !== ''
+      || (options.get('_positional_0') ?? '').trim() !== '';
+  if (teachWillWrite && !allowLearningStoreWrite(storeRoot, flags, writeErr, 'dz teach')) return 1;
   // 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).
@@ -3501,10 +3964,11 @@ async function cmdTeach(
     // 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, {
+    const code = await runHarmonize(storeRoot, options, flags, write, writeErr, {
       store: join(storeRoot, '.dz'),
       storeChosenBy: teachTarget.reason,
     });
+    return code;
   }
 
   // Bulk import: `dz teach --from-json <file>` ingests a `dz recall --all --json`
@@ -3600,6 +4064,7 @@ async function cmdTeach(
       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`);
     }
+    if (imported > 0) refreshLearningStoreMark(storeRoot, writeErr, 'dz teach --from-json');
     return 0;
   }
 
@@ -3620,6 +4085,7 @@ async function cmdTeach(
       const clearedQ = clearAgentdbQuarantine(storeRoot, [reinforce]);
       if (clearedQ.cleared > 0) write(`  ↳ promoted out of quarantine (mirror updated)`);
       write(storeLine('written'));
+      refreshLearningStoreMark(storeRoot, writeErr, 'dz teach --reinforce');
       return 0;
     }
     // HIGH-fix: a no-match must NOT auto-teach the raw argument — callers pass dzIds or truncated
@@ -3667,6 +4133,7 @@ async function cmdTeach(
           write(`↳ reinforced existing pattern ${verdict.dzId} (cos=${verdict.cosine.toFixed(2)}) — not re-added`);
           const clearedQ = clearAgentdbQuarantine(storeRoot, [verdict.dzId]);
           if (clearedQ.cleared > 0) write('  ↳ promoted out of quarantine (mirror updated)');
+          refreshLearningStoreMark(storeRoot, writeErr, 'dz teach --guard');
           return 0;
         }
         write(`dz teach --guard: reinforce of ${verdict.dzId} did not flush (backend off or write failure) — teaching the lesson normally instead`);
@@ -3780,10 +4247,16 @@ async function cmdTeach(
   }
   // The lexical write above is durable — the vector mirror is strictly best-effort (I-3).
   await emitMirrorQ(storeRoot, recordsToMirror, 'dz-teach', quarantineOn);
+  if (stored.records.length > 0) {
+    write(`  ID: ${stored.records.map((record) => patternRecordId(record)).join(', ')}`);
+    refreshLearningStoreMark(storeRoot, writeErr, 'dz teach');
+  }
   return commandFailed ? 1 : 0;
 }
 
-async function cmdConsolidate(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): Promise<number> {
+async function cmdConsolidate(
+  options: Map<string, string>, flags: Set<string>, cwd: string, write: Write, writeErr: WriteErr,
+): Promise<number> {
   const projectRoot = resolve(cwd, options.get('project') ?? '.');
   const sessionsDirOpt = options.get('sessions-dir');
   const pruneNoise = flags.has('prune-noise');
@@ -3802,6 +4275,8 @@ async function cmdConsolidate(options: Map<string, string>, flags: Set<string>,
     if (res.error !== undefined) { write(`dz consolidate --prune-quarantine: ${res.error}`); return 1; }
     write(`dz consolidate --prune-quarantine: removed ${res.removed} expired quarantined lesson(s)`);
     if (res.snapshot !== undefined) write(`  snapshot: ${res.snapshot}`);
+    refreshLearningStoreMark(projectRoot, writeErr, 'dz consolidate --prune-quarantine --apply');
+    storeGuardResetReminder(projectRoot, writeErr, 'dz consolidate --prune-quarantine --apply');
     return 0;
   }
 
@@ -3899,6 +4374,10 @@ async function cmdConsolidate(options: Map<string, string>, flags: Set<string>,
     }
   } catch { /* best-effort — the ranking is advisory, never fails the consolidate */ }
 
+  refreshLearningStoreMark(projectRoot, writeErr, 'dz consolidate');
+  if (pruneNoise && applyPrune) {
+    storeGuardResetReminder(projectRoot, writeErr, 'dz consolidate --prune-noise --apply');
+  }
   return 0;
 }
 
@@ -4011,6 +4490,7 @@ async function cmdRecallForget(
   flags: Set<string>,
   projectRoot: string,
   write: Write,
+  writeErr: WriteErr,
 ): Promise<number> {
   const raw = options.get('forget') ?? '';
   const ids = new Set(raw.split(',').map((s) => s.trim()).filter((s) => s !== ''));
@@ -4039,7 +4519,7 @@ async function cmdRecallForget(
     return 0;
   }
 
-  const dest = join(projectRoot, '.dz', `patterns-pre-forget-${Date.now()}.json`);
+  const dest = join(storeSnapshotPath(projectRoot), `forget-${Date.now()}.json`);
   const snap = snapshotStore(projectRoot, dest);
   if (snap.error !== undefined) {
     write(`dz recall --forget: snapshot failed (${snap.error}) — nothing removed; the store is not versioned`);
@@ -4050,6 +4530,8 @@ async function cmdRecallForget(
   write(`  snapshot: ${snap.path} (${snap.count} record(s))`);
   if (result.error !== undefined) write(`  ⚠ ${result.error}`);
   write('  the vector mirror still holds them — run `dz vector reindex` to resync');
+  refreshLearningStoreMark(projectRoot, writeErr, 'dz recall --forget --apply');
+  storeGuardResetReminder(projectRoot, writeErr, 'dz recall --forget --apply');
   return 0;
 }
 
@@ -4141,10 +4623,15 @@ async function cmdRecall(
   classMatcher?: RecallPatternsOptions['classMatcher'],
 ): Promise<number> {
   const projectRoot = resolve(cwd, options.get('project') ?? '.');
+  warnLearningStoreRead(projectRoot, writeErr, 'dz recall');
+  const globalRootForGuard = globalStoreRoot();
+  if (!sameStore(projectRoot, globalRootForGuard) && existsSync(join(globalRootForGuard, '.dz', 'memory'))) {
+    warnLearningStoreRead(globalRootForGuard, writeErr, 'dz recall');
+  }
   const asJson = flags.has('json');
   const all = flags.has('all');
   if (flags.has('usage')) return cmdRecallUsage(options, flags, projectRoot, write);
-  if (options.has('forget')) return cmdRecallForget(options, flags, projectRoot, write);
+  if (options.has('forget')) return cmdRecallForget(options, flags, projectRoot, write, writeErr);
   if (options.has('promote')) return cmdRecallPromote(options, flags, projectRoot, write);
 
   // --all: dump the entire learned store (backend-agnostic, via loadStorePatternsSync).
@@ -4706,7 +5193,7 @@ function renderHarmonize(report: HarmonizeReport, write: Write): void {
  * `--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,
+  projectRoot: string, options: Map<string, string>, flags: Set<string>, write: Write, writeErr: WriteErr,
   /**
    * 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
@@ -4730,6 +5217,10 @@ async function runHarmonize(
     }
   }
   const report = await harmonizeVectorStore(projectRoot, { apply, ...(threshold !== undefined ? { threshold } : {}) });
+  if (apply && report.error === undefined) {
+    refreshLearningStoreMark(projectRoot, writeErr, 'dz vector harmonize --apply');
+    storeGuardResetReminder(projectRoot, writeErr, 'dz vector harmonize --apply');
+  }
   if (flags.has('json')) {
     write(JSON.stringify(storeAnnotation !== undefined ? { ...report, ...storeAnnotation } : report));
     return report.error !== undefined ? 1 : 0;
@@ -4738,7 +5229,9 @@ async function runHarmonize(
   return report.error !== undefined ? 1 : 0;
 }
 
-async function cmdVector(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): Promise<number> {
+async function cmdVector(
+  options: Map<string, string>, flags: Set<string>, cwd: string, write: Write, writeErr: WriteErr,
+): Promise<number> {
   const projectRoot = resolve(cwd, options.get('project') ?? '.');
   const sub = options.get('_positional_0');
 
@@ -4793,6 +5286,10 @@ async function cmdVector(options: Map<string, string>, flags: Set<string>, cwd:
   if (sub === 'reindex') {
     const report = await reindexVectorStore(projectRoot);
     if (flags.has('json')) {
+      if (report.error === undefined) {
+        refreshLearningStoreMark(projectRoot, writeErr, 'dz vector reindex');
+        storeGuardResetReminder(projectRoot, writeErr, 'dz vector reindex');
+      }
       write(JSON.stringify(report));
       return report.error !== undefined ? 1 : 0;
     }
@@ -4810,6 +5307,8 @@ async function cmdVector(options: Map<string, string>, flags: Set<string>, cwd:
       write(`  ⚠ still in the previous embedding space: ${report.staleTaskTypes.join(', ')}`);
       if (report.staleTaskTypes.includes('book-knowledge')) write('    run \`dz brain reindex\` to rebuild the brain\'s book vectors');
     }
+    refreshLearningStoreMark(projectRoot, writeErr, 'dz vector reindex');
+    storeGuardResetReminder(projectRoot, writeErr, 'dz vector reindex');
     return 0;
   }
 
@@ -4866,7 +5365,7 @@ async function cmdVector(options: Map<string, string>, flags: Set<string>, cwd:
   // harmonize (alias: dz teach --harmonize) — SEMANTIC dedup of the learned store, NON-DESTRUCTIVE:
   // dry-run by default (previews clusters, writes nothing); --apply drops after a restorable backup.
   if (sub === 'harmonize') {
-    return runHarmonize(projectRoot, options, flags, write);
+    return runHarmonize(projectRoot, options, flags, write, writeErr);
   }
 
   // import <file.rvf> — the missing HALF of the RVF cycle: UPSERT-BY-dzId, never overwrites.
@@ -4878,6 +5377,7 @@ async function cmdVector(options: Map<string, string>, flags: Set<string>, cwd:
     }
     const report = await importRvfCheckpoint(projectRoot, resolve(cwd, src), {});
     if (flags.has('json')) {
+      if (report.error === undefined) refreshLearningStoreMark(projectRoot, writeErr, 'dz vector import');
       write(JSON.stringify(report));
       return report.error !== undefined ? 1 : 0;
     }
@@ -4890,6 +5390,7 @@ async function cmdVector(options: Map<string, string>, flags: Set<string>, cwd:
     if (report.skippedOrphans > 0) {
       write('  ↳ orphan vectors have no local pattern — import the text first: dz teach --from-json <recall-export.json>, then re-run dz vector import');
     }
+    refreshLearningStoreMark(projectRoot, writeErr, 'dz vector import');
     return 0;
   }
 
@@ -6339,6 +6840,19 @@ function cmdPublish(options: Map<string, string>, flags: Set<string>, cwd: strin
     }
   }
 
+  const filterStr = options.get('filter');
+  // SAFETY: trim + drop empty segments (mirrors --select at the top of cmdInit).
+  // Parse before the guard pre-flight so its packed-secret scan uses the SAME scoped package set
+  // that publishPackages receives below; an empty resulting list remains an explicit error.
+  let filter: string[] | undefined;
+  if (filterStr !== undefined) {
+    filter = filterStr.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+    if (filter.length === 0) {
+      write('dz publish: --filter requires a non-empty comma-separated list of package-name substrings');
+      return 1;
+    }
+  }
+
   // dz guard pre-flight (ADR-002 option A): publish is the most dangerous, least-reversible self-mutation, so
   // it ALWAYS runs the declarative guard first. A HARD violation refuses the publish; `--no-guard "<reason>"`
   // is the logged escape hatch (the override lands in .dz/guard-audit.jsonl — visible, never silent).
@@ -6350,7 +6864,7 @@ function cmdPublish(options: Map<string, string>, flags: Set<string>, cwd: strin
       write('dz publish: --no-guard requires a reason (it is logged): --no-guard "hotfix, guard re-run after"');
       return 1;
     }
-    const guardResult = runGuardEvaluation(guardRoot, 'publish', undefined, noGuard);
+    const guardResult = runGuardEvaluation(guardRoot, 'publish', undefined, noGuard, filter);
     if (guardResult.verdict === 'block' && noGuard === undefined) {
       write('dz publish: ✗ BLOCKED by dz guard (HARD invariant violated):');
       for (const v of guardResult.violations.filter((x) => x.severity === 'hard')) write(`  [BLOCK] ${v.rule}: ${v.detail}`);
@@ -6391,21 +6905,6 @@ function cmdPublish(options: Map<string, string>, flags: Set<string>, cwd: strin
   const claimCheckOpt = (claimCheckRaw as 'off' | 'warn' | 'error' | undefined) ?? 'warn';
 
   const bumpOnly = flags.has('bump-only');
-  const filterStr = options.get('filter');
-  // SAFETY: trim + drop empty segments (mirrors --select at the top of cmdInit).
-  // Without this, `--filter ""` (e.g. an unset shell var) or a stray comma yields
-  // [''] / ['', 'core'], and publishPackages matches with name.includes(''), which
-  // is true for EVERY package — silently turning a scoped publish into a
-  // whole-monorepo publish. An empty resulting list is an explicit error, never
-  // "match all".
-  let filter: string[] | undefined;
-  if (filterStr !== undefined) {
-    filter = filterStr.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
-    if (filter.length === 0) {
-      write('dz publish: --filter requires a non-empty comma-separated list of package-name substrings');
-      return 1;
-    }
-  }
 
   // SAFETY: dry-run is the DEFAULT. A real publish requires an EXPLICIT opt-in
   // via --yes, --confirm, or --no-dry-run. Without one, we never bump or publish.
@@ -6599,6 +7098,13 @@ function cmdPublish(options: Map<string, string>, flags: Set<string>, cwd: strin
     if (pkg.claimCheck && pkg.claimCheck.findings > 0 && pkg.status !== 'error') {
       write(`      ⚠ claim-check: ${pkg.claimCheck.findings} finding(s) (${pkg.claimCheck.high} high) in README.md`);
     }
+    // A dry run stops before build/sign/pack, so it says NOTHING about the gates below that line.
+    // Printing what it did not check is what keeps a clean preview from reading as a clean publish
+    // (measured 2026-09-02: a clean dry run preceded a RED real gate).
+    if (pkg.notVerified && pkg.notVerified.length > 0) {
+      write(`      ⓘ холостой прогон НЕ проверял (${pkg.notVerified.length}):`);
+      for (const item of pkg.notVerified) write(`         · ${item}`);
+    }
   }
   return report.errors > 0 ? 1 : 0;
 }
@@ -8357,7 +8863,18 @@ function cmdAgentsSync(
       const effect = flags.has('check') ? 'AGENTS.md would change' : 'AGENTS.md was not rewritten';
       writeErr(`dz agents-sync: DRIFT — ${drifted.length} stale/missing section(s); ${effect}`);
       for (const finding of drifted) writeErr(`  ${finding.id}: ${finding.file} (${finding.status})`);
-      if (drifted.some((finding) => finding.id === 'dz:policies')) {
+      const unregistered = drifted.filter((finding) => finding.status === 'unregistered-section');
+      if (unregistered.length > 0) {
+        // ПОДСКАЗКА, ВЕДУЩАЯ НЕ ТУДА, ХУЖЕ ОТСУТСТВУЮЩЕЙ. Повторный `dz agents-sync` эту находку
+        // НЕ лечит: реестр POLICY_SOURCES ведётся руками, и секция, не вписанная в него, не
+        // попадёт в проекцию сколько ни синхронизируй. Раньше здесь печаталась общая подсказка —
+        // читатель прогнал бы её и снова увидел ту же ошибку.
+        writeErr('→ heal with: объяви секцию в POLICY_SOURCES (packages/@dzhechkov/harness-core/src/agents-policy.ts):');
+        for (const finding of unregistered) {
+          writeErr(`     { id: '${finding.id}', file: '${finding.file}', heading: '…', why: '…', operativeClause: '…' }`);
+        }
+        writeErr('   затем: dz agents-sync');
+      } else if (drifted.some((finding) => finding.id === 'dz:policies')) {
         writeErr('→ heal with: repair duplicate/unmatched dz:policies markers, then run dz agents-sync');
       } else {
         writeErr('→ heal with: dz agents-sync');
@@ -8448,8 +8965,11 @@ const DEFAULT_STORE_CAP = 5000;
  */
 const MAX_STUB_SCAN_FILES = 400;
 
-/** Read the optional `.dz/guard.json` — `{ rules?: [...], storeCap?: number, stubWaivers?: [...] }`. Missing/broken ⇒ defaults. */
-function loadGuardConfig(root: string): { rules?: unknown[]; storeCap?: number; stubWaivers?: unknown[]; reviewRound?: { minGrade?: unknown } } {
+/** Maximum packed-file size read by the publish secret scan. */
+const SECRET_SCAN_MAX_BYTES = 512 * 1024;
+
+/** Read the optional `.dz/guard.json` — `{ rules?, storeCap?, stubWaivers?, secretWaivers? }`. Missing/broken ⇒ defaults. */
+function loadGuardConfig(root: string): { rules?: unknown[]; storeCap?: number; stubWaivers?: unknown[]; secretWaivers?: unknown[]; reviewRound?: { minGrade?: unknown } } {
   const p = join(root, '.dz', 'guard.json');
   if (!existsSync(p)) return {};
   try {
@@ -8475,6 +8995,51 @@ function gatherReadmeCounts(root: string): { label: string; a: number; b: number
   // (target repo without sitedoc — missing-evidence contract). But a file that EXISTS and no longer
   // matches its anchored pattern emits a MISMATCH pair (a: -1) — silent non-extraction is the exact
   // disease this contour cures (AM-1 applies to the guard path too, not only the CI test).
+  // ЗНАЧКИ ПРОТИВ ДЕРЕВА, а не только README против README (бэклог 9cb30764).
+  //
+  // Прежде правило сверяло только числа МЕЖДУ документами: два согласованных документа могли
+  // хором утверждать одно и то же неверное число, и правило молчало. Значок «пакетов: 52» стоял
+  // при 55 публикуемых на диске — ИЗМЕРЕНО 2026-09-03. Меню обещает 32 блюда, официант
+  // перечисляет 30, кухня готовит 38, и никто в ресторане не знает правду.
+  //
+  // Сверяются только числа, ВЫЧИСЛИМЫЕ ИЗ ДЕРЕВА. Значок «опубликовано в npm» сюда НЕ входит и
+  // это сказано вслух: его источник — реестр, а не рабочая копия, и пара, которая делает вид, что
+  // проверила его, была бы хуже отсутствующей.
+  const badge = (s: string, name: string): number | null => {
+    const m = s.match(new RegExp(`img\\.shields\\.io/badge/${name}-(\\d+)`));
+    return m && m[1] ? Number(m[1]) : null;
+  };
+  const publishablePackages = ((): number | null => {
+    const dir = join(root, 'packages', '@dzhechkov');
+    if (!existsSync(dir)) return null;
+    let n = 0;
+    for (const name of readdirSync(dir)) {
+      const pj = join(dir, name, 'package.json');
+      if (!existsSync(pj)) continue;
+      try {
+        const j = JSON.parse(readFileSync(pj, 'utf8')) as { private?: unknown };
+        if (j.private !== true) n += 1;
+      } catch { /* нечитаемый манифест — не считается ни в одну сторону */ }
+    }
+    return n;
+  })();
+  const pkgBadge = badge(rootMd, 'packages');
+  if (pkgBadge !== null && publishablePackages !== null) {
+    pairs.push({ label: 'packages (root badge vs publishable package.json on disk)', a: pkgBadge, b: publishablePackages });
+  }
+  const presetBadge = badge(rootMd, 'presets');
+  if (presetBadge !== null) {
+    pairs.push({ label: 'presets (root badge vs PRESET_NAMES in the build)', a: presetBadge, b: PRESET_NAMES.length });
+  }
+  const targetBadge = badge(rootMd, 'targets');
+  if (targetBadge !== null) {
+    pairs.push({ label: 'targets (root badge vs TARGET_NAMES in the build)', a: targetBadge, b: TARGET_NAMES.length });
+  }
+  const cmdBadge = badge(rootMd, 'CLI%20commands');
+  if (cmdBadge !== null && cliAll !== null) {
+    pairs.push({ label: 'commands (root badge vs cli All Commands)', a: cmdBadge, b: cliAll });
+  }
+
   const sitePair = (rel: string, re: RegExp, label: string): void => {
     if (cliAll === null || !existsSync(join(root, rel))) return;
     const found = num(read(rel), re);
@@ -8880,8 +9445,9 @@ function gatherVolumeShadowFacts(
 }
 
 /** Gather the facts one op needs. All I/O is best-effort — a missing signal skips its rule, never crashes. */
-function gatherGuardFacts(op: string, root: string, text: string | undefined, storeCap: number): Record<string, unknown> {
+function gatherGuardFacts(op: string, root: string, text: string | undefined, storeCap: number, publishFilter?: readonly string[]): Record<string, unknown> {
   const facts: Record<string, unknown> = { op };
+  const publishPackageRoots: string[] = [];
   if (op === 'publish') {
     // Advisory I/O: unreadable telemetry or fed state is absence of evidence, never a fabricated
     // stale finding and never a publish blocker.
@@ -9013,6 +9579,13 @@ function gatherGuardFacts(op: string, root: string, text: string | undefined, st
     } catch { /* not a git repo */ }
     const versionByName = new Map<string, string>();
     for (const m of manifests) if (m.name && typeof m.version === 'string') versionByName.set(m.name, m.version);
+    publishPackageRoots.push(...located
+      .filter(({ dir, m }) => m.private !== true && (
+        publishFilter === undefined
+        || publishFilter.length === 0
+        || publishFilter.some((filter) => (m.name ?? '').includes(filter) || dir.includes(filter))
+      ))
+      .map(({ dir }) => dir));
     const pnpmWorkspace = existsSync(join(root, 'pnpm-workspace.yaml'));
     const packages: { name: string; deps: Record<string, string> }[] = [];
     for (const m of manifests) {
@@ -9026,6 +9599,82 @@ function gatherGuardFacts(op: string, root: string, text: string | undefined, st
       packages.push({ name: m.name ?? '(unnamed)', deps });
     }
     facts['packages'] = packages;
+    // sibling-dep-protocol: сырые спеки, БЕЗ подстановки версии. Подставленная версия выглядела бы
+    // как обычный диапазон, и правило потеряло бы ровно то, что проверяет.
+    const siblingDeps: { name: string; field: string; dep: string; spec: string }[] = [];
+    for (const m of manifests) {
+      if (m.private === true) continue;
+      const fields = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'] as const;
+      for (const field of fields) {
+        const table = (m as unknown as Record<string, unknown>)[field];
+        if (typeof table !== 'object' || table === null) continue;
+        for (const [dep, spec] of Object.entries(table as Record<string, unknown>)) {
+          if (!dep.startsWith('@dzhechkov/') || typeof spec !== 'string') continue;
+          siblingDeps.push({ name: m.name ?? '(unnamed)', field, dep, spec });
+        }
+      }
+    }
+    facts['siblingDeps'] = siblingDeps;
+    // plugin-manifest-audit: каждый `.claude-plugin/plugin.json` в дереве. Обход ограничен по
+    // глубине и не заходит в node_modules/dist — чужие манифесты не наши, и краснеть на них
+    // значило бы отчитываться о том, чего мы не публикуем.
+    const pluginManifests: { path: string; parseError?: string; name?: string; version?: string; description?: string }[] = [];
+    const walkPlugins = (dir: string, depth: number): void => {
+      if (depth > 4) return;
+      let entries: Dirent[];
+      try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+      for (const e of entries) {
+        // `out/` — СГЕНЕРИРОВАННОЕ публичное зеркало: те же манифесты, скопированные. Дефект в нём
+        // есть дефект генератора, и он уже сообщается по источнику; вторая копия только удвоила бы
+        // одну и ту же находку.
+        if (!e.isDirectory() || e.name === 'node_modules' || e.name === 'dist' || e.name === 'out') continue;
+        const full = join(dir, e.name);
+        if (e.name === '.claude-plugin') {
+          const manifest = join(full, 'plugin.json');
+          if (!existsSync(manifest)) continue;
+          try {
+            const j = JSON.parse(readFileSync(manifest, 'utf8')) as Record<string, unknown>;
+            const pick = (k: string): string | undefined => (typeof j[k] === 'string' ? j[k] as string : undefined);
+            // Состав навыков — ОБЕ стороны инвентаризации, и ТОЛЬКО для коробки ОДНОГО ПАКЕТА.
+            //
+            // Корневая витрина сюда НЕ входит, и это не упрощение: её состав собирается из всего
+            // монорепозитория через реестр, «что лежит на складе» для неё — не обход одного дерева,
+            // а весь реестр, и ровно это уже проверяет `marketplace-parity` регенерацией. Первая
+            // редакция этой проверки обошла корень с ограничением глубины и выдала 27 ЛОЖНЫХ
+            // «объявлено, но не найдено» — навыки лежали глубже границы обхода (ИЗМЕРЕНО 2026-09-04,
+            // поймано до коммита прогоном стража на этом же дереве).
+            //
+            // Сравниваются ПУТИ, как их объявил манифест, а не имена: два навыка с одинаковым
+            // именем в разных подкаталогах — законная вещь, и сведение к имени их бы склеило.
+            const boxRoot = dirname(full);
+            const isRepoRoot = resolve(boxRoot) === resolve(root);
+            const declaredSkills = Array.isArray(j['skills']) && !isRepoRoot
+              ? (j['skills'] as unknown[]).filter((x): x is string => typeof x === 'string')
+                  .map((rel) => rel.replace(/^\.\//, '').replace(/\/+$/, '')).filter(Boolean)
+              : undefined;
+            const skillsOnDisk = declaredSkills === undefined ? undefined : findSkillDirs(boxRoot);
+            pluginManifests.push({
+              path: relative(root, manifest),
+              ...(pick('name') !== undefined ? { name: pick('name')! } : {}),
+              ...(pick('version') !== undefined ? { version: pick('version')! } : {}),
+              ...(pick('description') !== undefined ? { description: pick('description')! } : {}),
+              ...(declaredSkills !== undefined ? { declaredSkills } : {}),
+              ...(skillsOnDisk !== undefined ? { skillsOnDisk } : {}),
+            });
+          } catch (error) {
+            pluginManifests.push({
+              path: relative(root, manifest),
+              parseError: (error instanceof Error ? error.message : String(error)).replace(/\s+/g, ' ').slice(0, 200),
+            });
+          }
+          continue;
+        }
+        if (e.name.startsWith('.')) continue;
+        walkPlugins(full, depth + 1);
+      }
+    };
+    walkPlugins(root, 0);
+    facts['pluginManifests'] = pluginManifests;
     facts['volume'] = gatherVolumeShadowFacts(root, located.map(({ dir, m }) => ({
       dir,
       name: m.name ?? dir,
@@ -9053,7 +9702,43 @@ function gatherGuardFacts(op: string, root: string, text: string | undefined, st
       }
       facts['licenceHold'] = holds;
     } catch { /* unreadable tree — the rule reports nothing rather than inventing a violation */ }
-    try { facts['drift'] = sweepSkillDrift(root, { scope: 'installs', allowlist: readDriftAllowlist(root) }).drifted.map((d) => d.name); } catch { /* skip */ }
+    try { facts['drift'] = sweepSkillDrift(root, { scope: DRIFT_SWEEP_SCOPE, allowlist: readDriftAllowlist(root) }).drifted.map((d) => d.name); } catch { /* skip */ }
+    // backlog-covers-features: каталоги фич, дата их ПОЯВЛЕНИЯ В ИСТОРИИ (не mtime — его двигает
+    // любой посторонний процесс), оговорки из README фичи и тексты записей бэклога. Базовая дата
+    // делает правило зелёным на приходе: 336 существующих каталогов заведены до правила.
+    // Нечитаемое дерево ⇒ факт НЕ выставляется ⇒ правило молчит, а не выдумывает вердикт.
+    try {
+      const featDir = join(root, 'features');
+      if (existsSync(featDir)) {
+        const slugs = readdirSync(featDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+        const features = slugs.map((slug) => {
+          let createdIso = '';
+          try {
+            createdIso = execSync(`git log --diff-filter=A --format=%aI -1 -- ${JSON.stringify('features/' + slug)}`,
+              { cwd: root, encoding: 'utf-8' }).trim().split('\n').filter(Boolean).pop() ?? '';
+          } catch { /* нет в истории — функция засчитает как новый, это верный дефолт */ }
+          let waiver: string | undefined;
+          for (const f of ['README.md', '07_code_changes/change_manifest.md']) {
+            try {
+              const m = readFileSync(join(featDir, slug, f), 'utf-8')
+                .match(/^\s*Backlog:\s*не заведено\s*[—-]\s*(.+)$/m);
+              if (m && m[1] && m[1].trim() !== '') { waiver = m[1].trim(); break; }
+            } catch { /* нет файла — не оговорка */ }
+          }
+          return { slug, createdIso, waiver };
+        });
+        const backlogTexts: string[] = [];
+        try {
+          for (const line of readFileSync(join(root, '.dz', 'backlog', 'ideas.jsonl'), 'utf-8').split('\n')) {
+            if (line.trim() === '') continue;
+            try { const o = JSON.parse(line) as { text?: unknown }; if (typeof o.text === 'string') backlogTexts.push(o.text); } catch { /* рваная строка */ }
+          }
+        } catch { /* стора нет */ }
+        if (backlogTexts.length > 0) {
+          facts['featureBacklog'] = { baseline: BACKLOG_COVERAGE_BASELINE, features, backlogTexts };
+        }
+      }
+    } catch { /* нечитаемо — правило молчит */ }
     facts['counts'] = gatherReadmeCounts(root);
     // readme-first: from the WORKING-TREE diff (publishes happen pre-commit here), per package: does the
     // change set contain its package.json (the version-bump signal) without its README.md?
@@ -9213,11 +9898,39 @@ function gatherGuardFacts(op: string, root: string, text: string | undefined, st
 
     // no-stubs config waivers: `.dz/guard.json` `stubWaivers: [{path, reason}]` — path-keyed, reason
     // MANDATORY (the feature-adr-setup --guards shape; the pure checker refuses a reasonless entry).
-    const stubWaivers = loadGuardConfig(root).stubWaivers;
+    const guardConfig = loadGuardConfig(root);
+    const stubWaivers = guardConfig.stubWaivers;
     if (Array.isArray(stubWaivers)) facts['stubWaivers'] = stubWaivers;
+    const secretWaivers = guardConfig.secretWaivers;
+    if (Array.isArray(secretWaivers)) facts['secretWaivers'] = secretWaivers;
   }
   if (op === 'consolidate') {
-    try { facts['drift'] = sweepSkillDrift(root, { scope: 'installs', allowlist: readDriftAllowlist(root) }).drifted.map((d) => d.name); } catch { /* skip */ }
+    try { facts['drift'] = sweepSkillDrift(root, { scope: DRIFT_SWEEP_SCOPE, allowlist: readDriftAllowlist(root) }).drifted.map((d) => d.name); } catch { /* skip */ }
+  }
+  if (op === 'publish') {
+    const secretTargets: { label: string; text: string }[] = [];
+    let skipped = 0;
+    for (const dir of publishPackageRoots) {
+      const packageRoot = join(root, dir);
+      let packed: string[];
+      try { packed = listPackFiles(packageRoot); }
+      catch { skipped++; continue; }
+      for (const rel of packed) {
+        const absolute = join(packageRoot, rel);
+        try {
+          const stat = lstatSync(absolute);
+          if (!stat.isFile() || stat.size > SECRET_SCAN_MAX_BYTES) { skipped++; continue; }
+          const content = readFileSync(absolute);
+          if (content.subarray(0, 8 * 1024).includes(0)) { skipped++; continue; }
+          secretTargets.push({
+            label: relative(root, absolute).split(sep).join('/'),
+            text: content.toString('utf8'),
+          });
+        } catch { skipped++; }
+      }
+    }
+    if (secretTargets.length > 0) facts['secretTargets'] = secretTargets;
+    if (skipped > 0) facts['secretScan'] = { skipped };
   }
   if (op === 'teach' || op === 'consolidate') {
     if (op === 'teach' && text) facts['secretTargets'] = [{ label: 'lesson', text }];
@@ -9233,13 +9946,13 @@ function gatherGuardFacts(op: string, root: string, text: string | undefined, st
  * shared by `dz guard check` and the `dz publish` pre-flight (ADR-002 option A) so they can never disagree.
  * `overrideReason` (when the caller forces through a block) is logged, never silent.
  */
-function runGuardEvaluation(root: string, op: string, text: string | undefined, overrideReason: string | undefined): ReturnType<typeof evaluateGuard> {
+function runGuardEvaluation(root: string, op: string, text: string | undefined, overrideReason: string | undefined, publishFilter?: readonly string[]): ReturnType<typeof evaluateGuard> {
   const cfg = loadGuardConfig(root);
   // Number.isFinite, not just > 0: a config `storeCap: 1e400` parses to Infinity, passes `> 0`, and would
   // silently DISABLE the cap (count <= Infinity always). Non-finite ⇒ fall back to the default.
   const storeCap = typeof cfg.storeCap === 'number' && Number.isFinite(cfg.storeCap) && cfg.storeCap > 0 ? cfg.storeCap : DEFAULT_STORE_CAP;
   const rules = resolveRules(Array.isArray(cfg.rules) ? (cfg.rules as never[]) : undefined);
-  const facts = gatherGuardFacts(op, root, text, storeCap);
+  const facts = gatherGuardFacts(op, root, text, storeCap, publishFilter);
   const result = evaluateGuard(facts as never, rules);
   // audit (append-only). ts is real time here (a CLI, not the sandboxed workflow).
   try {
@@ -10038,15 +10751,52 @@ async function cmdMrRakes(options: Map<string, string>, flags: Set<string>, cwd:
  *   --threshold N       drill threshold (default 2 — anti-noise: a first-seen rake accrues, never drills)
  *   --no-teach          drill only; do NOT write the store (skip the agent side)
  *   --project <dir>     pin the teach ledger
- *   --install-hook      print the opt-in SessionEnd hook to add (non-destructive)
+ *   --install-hook      print the opt-in hook set to add (non-destructive): Stop scan-tail +
+ *                       PreCompact/SessionEnd full retro (feature narrated-error-must-be-taught)
+ *   --scan-tail         per-turn Stop-hook mode: incremental admission-debt scan, O(new bytes) —
+ *                       writes/clears .dz/retro-pending.json; no ledger, no teach, no git subprocess
+ *   --transcript <p>    the transcript --scan-tail must read. Without it the Stop hook's own stdin
+ *                       payload (`transcript_path`) is used; with neither, the scan REFUSES
+ *                       (NOT-ESTABLISHED) rather than guessing the newest file on disk
  */
-async function cmdRetro(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): Promise<number> {
+async function cmdRetro(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write, readStdin: () => string = () => ''): Promise<number> {
+  if (flags.has('scan-tail')) {
+    // Per-turn primary detector (ADR-001 D2). Cost budget IS the design: no `git rev-parse`
+    // subprocess (hooks run with cwd = project root; CLAUDE_PROJECT_DIR pins it), no store open,
+    // O(new bytes) via the persisted offset. Always exit 0 — a Stop hook must never fail a turn.
+    const root = process.env['CLAUDE_PROJECT_DIR'] ?? cwd;
+    // WHICH transcript. Round 3, P1-3: this used to fall back to `findLatestTranscript(root)`, so with
+    // several sessions and their subagents alive at once it scanned whichever file had the newest
+    // mtime — routinely another session's, advancing that session's offset and never seeing this
+    // turn's admission. The Stop hook hands the exact path on stdin; with no path from any source the
+    // answer is a stated refusal, never a guess. Still exit 0: a Stop hook must never fail a turn.
+    const picked = resolveScanTailTranscript({
+      flag: options.get('transcript'),
+      positional: options.get('_positional_0'),
+      stdin: readStdin(),
+    });
+    if (picked.path === null) {
+      const reason = picked.reason ?? 'no transcript path';
+      if (flags.has('json')) write(JSON.stringify({ status: 'not-established', source: 'none', reason, scannedBytes: 0, offset: 0 }));
+      else write(`retro scan-tail: NOT-ESTABLISHED — ${reason}. Wire the hook as \`dz retro --scan-tail\` (Claude Code pipes the payload on stdin) or pass \`--transcript <path>\`.`);
+      return 0;
+    }
+    const outcome = runRetroTailScan(join(root, '.dz'), picked.path);
+    if (flags.has('json')) write(JSON.stringify({ ...outcome, source: picked.source }));
+    else if (outcome.status === 'pending') write(`retro scan-tail: unpaid admission — .dz/retro-pending.json armed («${(outcome.snippet ?? '').slice(0, 60)}…»)`);
+    return 0;
+  }
+
   let repoRoot = cwd;
   try { repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd; } catch { /* not git */ }
 
   if (flags.has('install-hook')) {
-    write('Add this opt-in SessionEnd hook to .claude/settings.json (runs a retro when a session ends):');
-    write(JSON.stringify({ hooks: { SessionEnd: [{ hooks: [{ type: 'command', command: 'dz retro' }] }] } }, null, 2));
+    write('Add these opt-in hooks to .claude/settings.json (per-turn debt scan + retro at compaction AND session end — PreCompact covers the crash/disconnect sessions SessionEnd never sees):');
+    write(JSON.stringify({ hooks: {
+      Stop: [{ hooks: [{ type: 'command', command: 'dz retro --scan-tail', timeout: 10000, continueOnError: true }] }],
+      PreCompact: [{ hooks: [{ type: 'command', command: 'dz retro', timeout: 60000, continueOnError: true }] }],
+      SessionEnd: [{ hooks: [{ type: 'command', command: 'dz retro', timeout: 60000, continueOnError: true }] }],
+    } }, null, 2));
     return 0;
   }
 
@@ -10283,6 +11033,43 @@ function cmdChallenge(options: Map<string, string>, flags: Set<string>, cwd: str
  * decide (dz's rule — a false gate kills trust). Exit code is 0 on a clean run regardless of verdict; 2 only on
  * a usage/setup error, so a caller distinguishes "gate ran" from "gate could not run".
  */
+/**
+ * Есть ли в этом каталоге НЕЗАКОММИЧЕННЫЕ правки. Это и отличает «фича ещё в рабочем дереве»
+ * (тогда `HEAD` — законная предфичевая база) от «фича уже закоммичена» (тогда `HEAD` её содержит).
+ *
+ * Не удалось спросить git — возвращается null, и вызывающий обязан считать положение НЕ
+ * УСТАНОВЛЕННЫМ, а не выбрать удобный ответ.
+ */
+/**
+ * Каталоги с `SKILL.md` внутри коробки ОДНОГО пакета — то, что РЕАЛЬНО лежит на складе.
+ * Возвращаются ПУТИ относительно коробки, как их объявляет манифест, а не имена.
+ */
+function findSkillDirs(boxRoot: string): string[] {
+  const found = new Set<string>();
+  const walk = (dir: string, depth: number): void => {
+    if (depth > 4) return;
+    let entries: Dirent[];
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.name === 'node_modules' || e.name === 'dist' || e.name.startsWith('.')) continue;
+      const full = join(dir, e.name);
+      if (existsSync(join(full, 'SKILL.md'))) found.add(relative(boxRoot, full));
+      walk(full, depth + 1);
+    }
+  };
+  walk(boxRoot, 0);
+  return [...found];
+}
+
+function hasUncommittedChangesIn(repoRoot: string, dir: string): boolean | null {
+  try {
+    const out = execSync(`git status --porcelain -- ${JSON.stringify(dir)}`, { cwd: repoRoot, encoding: 'utf-8' });
+    return out.split('\n').some((line) => line.trim() !== '');
+  } catch {
+    return null;
+  }
+}
+
 function cmdDiscriminationCheck(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
   let repoRoot = cwd;
   try { repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd; } catch { /* not git */ }
@@ -10295,7 +11082,22 @@ function cmdDiscriminationCheck(options: Map<string, string>, flags: Set<string>
   const nameFilter = options.get('name');
   const propertyTests = testArg.split(',').map((s) => s.trim()).filter(Boolean).map((file) =>
     nameFilter !== undefined && nameFilter.trim() !== '' ? { file, name: nameFilter.trim() } : { file });
-  const baseRef = options.get('base') ?? 'HEAD';
+  /**
+   * УМОЛЧАНИЕ БАЗЫ РАЗЛИЧАЕТ ДВА РАЗНЫХ ПОЛОЖЕНИЯ, потому что они и правда разные.
+   *
+   * В штатном ходе конвейера правка Шага 7 ЕЩЁ НЕ ЗАКОММИЧЕНА, и тогда `HEAD` — настоящая
+   * предфичевая база; так конвейер и зовёт гейт (`--base HEAD`, причина записана в его тексте).
+   *
+   * Но если фича УЖЕ ЗАКОММИЧЕНА, `HEAD` её содержит, и гейт сравнивает фичу С САМОЙ СОБОЙ.
+   * ИЗМЕРЕНО 2026-09-04: такой прогон дал уверенное `NON_DISCRIMINATING` с советом «усилить тест»
+   * на тестах, которые дискриминируют; тот же прогон с верной базой дал `DISCRIMINATES_VIA_ERROR`.
+   * Находка выглядела как утверждение О ТЕСТАХ, и автор пошёл бы чинить исправное.
+   *
+   * Различить эти положения можно ДЕТЕРМИНИРОВАННО: есть ли незакоммиченные правки в пакете, чьи
+   * тесты названы. Есть — `HEAD` законен и используется как раньше. Нет — база не установлена, и
+   * гейт ОТКАЗЫВАЕТСЯ (exit 3), вместо того чтобы измерять относительно самого себя.
+   */
+  const explicitBase = options.get('base');
   const runnerOpt = options.get('runner');
   // R11: a hung runner is a loud non-answer, never a pass. Same default + parse shape as mutation-gate.
   const timeoutOpt = Number(options.get('timeout') ?? '300000');
@@ -10338,9 +11140,35 @@ function cmdDiscriminationCheck(options: Map<string, string>, flags: Set<string>
   // The pure half's path sanitation expects a REPO-RELATIVE package dir ('.'-rooted), not an
   // absolute one — an absolute path is refused as unsafe-package-dir by design.
   const packageDirRel = relative(repoRoot, packageDir) || '.';
+
+  // Умолчание базы решается ЗДЕСЬ, потому что только здесь известен пакет, чьи тесты названы.
+  let baseRef: string;
+  if (explicitBase !== undefined && explicitBase.trim() !== '') {
+    baseRef = explicitBase.trim();
+  } else {
+    const dirty = hasUncommittedChangesIn(repoRoot, packageDirRel);
+    if (dirty !== true) {
+      write('dz discrimination-check: NOT-ESTABLISHED — предфичевая база не установлена.');
+      write(dirty === null
+        ? `  Не удалось спросить git о состоянии ${packageDirRel}; выбирать удобный ответ вместо этого нельзя.`
+        : `  В ${packageDirRel} нет незакоммиченных правок, значит фича УЖЕ в HEAD, и сравнение шло бы с самой собой.`);
+      write('  Гейт сравнивает поведение ДО и ПОСЛЕ фичи; без базы сравнивать не с чем, а HEAD здесь');
+      write('  дал бы уверенное NON_DISCRIMINATING на исправных тестах (ИЗМЕРЕНО 2026-09-04).');
+      write('  Передайте --base <коммит перед фичей>, например `<sha коммита фичи>^`.');
+      return 3;
+    }
+    // Штатный ход конвейера: правка Шага 7 ещё в рабочем дереве, HEAD — настоящая предфичевая база.
+    baseRef = 'HEAD';
+    write(`dz discrimination-check: база не задана; в ${packageDirRel} есть незакоммиченные правки, беру HEAD как предфичевую базу.`);
+  }
+
+  // Провенанс базы едет в квитанцию вместе с самой базой: «явно указано» — утверждение о действии
+  // человека, и писать его для HEAD, выбранного инструментом, значит подделывать происхождение
+  // доказательства, на которое сошлются позже.
+  const baseRefSupplied = explicitBase !== undefined && explicitBase.trim() !== '';
   const planInput = runnerOpt !== undefined
-    ? { baseRef, propertyTests, runner: runnerOpt, packageTestScript, packageDevDependencies, packageDir: packageDirRel }
-    : { baseRef, propertyTests, packageTestScript, packageDevDependencies, packageDir: packageDirRel };
+    ? { baseRef, baseRefSupplied, propertyTests, runner: runnerOpt, packageTestScript, packageDevDependencies, packageDir: packageDirRel }
+    : { baseRef, baseRefSupplied, propertyTests, packageTestScript, packageDevDependencies, packageDir: packageDirRel };
   const plan = planDiscriminationCheck(planInput);
 
   if (!plan.runnable) {
@@ -12242,9 +13070,24 @@ function nameCheckScan(repoRoot: string): NameFacts {
         // Command names come from the dispatcher AND from the help block: a name that dispatches but
         // is undocumented is still taken, and so is the reverse.
         if (f.name === 'cli.ts') {
-          for (const c of dispatchedCommandsIn(text)) commands.add(c);
-          const help = /^\s{2}dz ([a-z][a-z0-9-]*)/gm;
-          for (let m = help.exec(text); m !== null; m = help.exec(text)) if (m[1] !== undefined) commands.add(m[1]);
+          // ONE enumeration, every consumer derives (ADR-001, feature command-count-triad). This
+          // scan's question is "is the name TAKEN?", so taken = dispatched ∪ documented, which is
+          // legitimately LARGER than the canonical command count — but it must be the SAME parse
+          // the layer-1 parity test uses, not a second private regex that agrees by coincidence.
+          // The any-indent `dispatchedCommandsIn` fallback stays for a cli.ts WITHOUT a main
+          // `switch (command)` (none in this workspace today): a partial sweep would answer "free"
+          // about a taken name, and that is the one answer this command may never give.
+          let mainSwitchParsed = false;
+          try {
+            for (const c of dispatchedCommands(text)) commands.add(c);
+            for (const c of documentedCommands(text)) commands.add(c);
+            mainSwitchParsed = true;
+          } catch { /* no main switch here — fall back to the broad regexes below */ }
+          if (!mainSwitchParsed) {
+            for (const c of dispatchedCommandsIn(text)) commands.add(c);
+            const help = /^\s{2}dz ([a-z][a-z0-9-]*)/gm;
+            for (let m = help.exec(text); m !== null; m = help.exec(text)) if (m[1] !== undefined) commands.add(m[1]);
+          }
         }
       }
     }
@@ -12258,6 +13101,71 @@ function nameCheckScan(repoRoot: string): NameFacts {
   return { commands, modules, exports: exportsFound, scanned: { packages, files, exports: exportsFound.size, commands: commands.size } };
 }
 
+/**
+ * `dz brief-check <файл>` — проверить бриф роя на контракт вывода (ADR-001 swarm-brief-output-contract).
+ *
+ * Разбирает объявления брифа как ДАННЫЕ и отказывает поимённо: «бриф неверен» не говорит автору,
+ * что чинить, поэтому каждое нарушение называет ключ и причину.
+ *
+ * ЧЕСТНЫЙ ПРЕДЕЛ печатается ВМЕСТЕ С ЗЕЛЁНЫМ ответом: проверено, что бриф ОБЪЯВИЛ каталог и
+ * единицы, а не что агент им последует. Зелёная проверка, читаемая как гарантия поведения, хуже
+ * её отсутствия.
+ */
+function cmdBriefCheck(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  const json = flags.has('json');
+  /**
+   * ВЕТКА «ПРОВЕРИТЬ НЕ УДАЛОСЬ» ТОЖЕ ОБЯЗАНА ОТВЕТИТЬ JSON-ом (находка 11).
+   *
+   * `--json` печатал человеческую строку на несуществующем файле, и потребитель, читающий вывод как
+   * JSON, получал ошибку разбора вместо структурного «не проверено». Признак `checked` — тот же
+   * трихотомический вердикт, что и коды выхода, только для машины: не «бриф плох», а «мы про него
+   * ничего не установили».
+   */
+  const unchecked = (reason: string, detail: string): number => {
+    if (json) write(JSON.stringify({ ok: false, checked: false, reason, detail }));
+    else write(detail);
+    return 2;
+  };
+  // Только позиционный аргумент: `--file` был необъявленным псевдонимом, и страж дрейфа флагов
+  // справедливо на него указал — лишняя поверхность, которой нет в справке.
+  const file = options.get('_positional_0');
+  if (file === undefined || file.trim() === '') {
+    const code = unchecked('no-file', 'dz brief-check: name the brief file — dz brief-check <file> [--json]');
+    if (!json) write('  A brief must declare: ' + SWARM_BRIEF_CONTRACT.map((c: { key: string }) => c.key).join(', '));
+    return code;
+  }
+  let text: string;
+  try {
+    text = readFileSync(resolve(cwd, file), 'utf-8');
+  } catch {
+    // Нечитаемый файл — НЕ «бриф плох»: мы про него ничего не установили. Отдельный код выхода,
+    // чтобы отказ прибора не смешивался с отказом брифа.
+    return unchecked('unreadable', `dz brief-check: cannot read ${visibleText(file)}`);
+  }
+  const result = checkSwarmBrief(text);
+  if (json) {
+    // `checked: true` — вторая половина того же различителя: потребитель отличает «проверено и
+    // отвергнуто» от «проверить не удалось» полем, а не отсутствием поля.
+    write(JSON.stringify({ ...result, checked: true }));
+    return result.ok ? 0 : 1;
+  }
+  if (result.ok) {
+    // ЗНАЧЕНИЯ ИЗ БРИФА ОБЕЗВРЕЖИВАЮТСЯ И В ЗЕЛЁНОЙ СТРОКЕ (находка 10). Отказ их уже обезвредил,
+    // но подделывается ровно эта строка: управляющая последовательность в имени каталога стирает
+    // предыдущий вывод и печатает поверх него подделку.
+    write(`dz brief-check: OK — dir ${visibleText(result.outputDir ?? '')}, ${result.units.length} unit(s), assembly "${visibleText(result.assemblyUnit ?? '')}"`);
+    write('  LIMIT: this verifies the brief DECLARED the contract, not that the agent will follow it —');
+    write('  only comparing the directory against the unit list on an orchestrator tick can show that.');
+    write('  A filled-in template and an unedited one both pass: the parse cannot tell them apart.');
+    return 0;
+  }
+  write(`dz brief-check: REFUSED — ${result.violations.length} violation(s)`);
+  // Ядро уже обезвредило значения в причинах; повтор на слое печати — не суеверие, а граница:
+  // печатающий слой не обязан знать, кто именно из его источников уже почистил текст.
+  for (const v of result.violations) write(`  ${v.rule}: ${visibleText(v.detail)}`);
+  return 1;
+}
+
 function cmdNameCheck(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
   const repoRoot = resolve(options.get('project') ?? cwd);
   const json = flags.has('json');
@@ -13141,12 +14049,24 @@ function cmdAmendmentCheck(options: Map<string, string>, flags: Set<string>, cwd
     // Paths in an amendment row are repo-relative, so they resolve against the repo root — not
     // against the feature directory, and not against wherever the caller happened to stand.
     const resolutions = resolveAmendments(rows, { readFile: (rel) => readOr(resolve(cwd, rel)) });
+    // A document that opens `## Amendments` twice cannot have its first heading answer for the
+    // rest (Codex round 6, P2). Counted per document and taken at its worst — one contradictory
+    // input is enough to make the run inconclusive.
+    const sectionCount = Math.max(
+      ideation === null ? 0 : amendmentSectionCount(ideation),
+      plan === null ? 0 : amendmentSectionCount(plan),
+    );
     const decision = decideAmendmentOutcome({
       sectionPresent,
       rows,
       resolutions,
       planSaysNone: plan !== null && planSaysNoAmendments(plan),
       missingFromPlan,
+      sectionCount,
+      // Fail-closed: measured on the document the rows would have come from (the plan when it has
+      // a section, otherwise the ideation report).
+      ambiguity: (plan !== null ? amendmentDeclarationAmbiguity(plan) : null)
+        ?? (ideation !== null ? amendmentDeclarationAmbiguity(ideation) : null),
     });
     return { slug, decision, resolutions };
   };
@@ -15459,7 +16379,9 @@ function cmdDeliveryCheck(options: Map<string, string>, flags: Set<string>, cwd:
 /* ------------------------------------------------------------------ */
 
 /** Thin dispatcher — ALL logic lives in harness-core/src/backlog.ts (05 architecture: handlers stay dumb). */
-async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): Promise<number> {
+async function cmdBacklog(
+  options: Map<string, string>, flags: Set<string>, cwd: string, write: Write, writeErr: WriteErr,
+): Promise<number> {
   const projectRoot = resolve(cwd, options.get('project') ?? '.');
   const json = flags.has('json');
   const sub = options.get('_positional_0');
@@ -15477,6 +16399,7 @@ async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd:
     const eff = parseEffort(options.get('effort'), cfg.roulette.defaultEffort);
     if (eff.adjusted && !json && eff.note !== undefined) write(`dz backlog: ${eff.note}`);
     const dryRun = flags.has('dry-run');
+    if (!dryRun && !allowLearningStoreWrite(projectRoot, flags, writeErr, 'dz backlog add')) return 1;
     // Embed-form migration (register-inflation fix): v1 vectors are FULL-TEXT embeds, v2 queries are
     // bounded excerpts — comparing across the forms is a query-vs-row space split. Re-mirror once
     // (idempotent upsert), before the dedup search. Dry-run writes nothing, so it only WARNS.
@@ -15505,6 +16428,7 @@ async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd:
       const ideas = readIdeas(projectRoot);
       const match = ideas.find((i) => i.id === verdict.matchedId);
       let absorbErr: string | undefined;
+      let didWrite = false;
       if (!dryRun && match !== undefined) {
         const snap = snapshotIdeas(projectRoot, join(projectRoot, '.dz', 'backlog', `ideas.pre-merge-${Date.now()}.jsonl`));
         if (snap.error !== undefined) return emitErr(snap.error);
@@ -15520,7 +16444,9 @@ async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd:
         }).error;
         match.uses += 1;
         writeIdeas(projectRoot, ideas);
+        didWrite = true;
       }
+      if (didWrite) refreshLearningStoreMark(projectRoot, writeErr, 'dz backlog add');
       if (json) write(JSON.stringify({ action: 'duplicate', matchedId: verdict.matchedId, cosine: verdict.cosine, ...(verdict.containment !== undefined ? { containment: verdict.containment } : {}), ...(verdict.subsetMatch === true ? { subsetMatch: true } : {}), ...(topMatch !== undefined ? { topMatch } : {}), ...(eff.note !== undefined ? { effortNote: eff.note } : {}), ...(dryRun ? {} : { absorbedLogged: absorbErr === undefined, ...(absorbErr !== undefined ? { absorbedLogError: absorbErr } : {}) }), exitCode: 0 }, null, 2));
       else {
         const via = verdict.subsetMatch === true
@@ -15576,6 +16502,7 @@ async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd:
     ideas.push(rec);
     writeIdeas(projectRoot, ideas);
     const mirror = await mirrorIdeaVector(projectRoot, rec); // best-effort — never blocks capture
+    refreshLearningStoreMark(projectRoot, writeErr, 'dz backlog add');
     if (json) write(JSON.stringify({ action: verdict.action, idea: rec, related: verdict.relatedIds, ...(verdict.demoted !== undefined ? { demoted: verdict.demoted } : {}), ...(topMatch !== undefined ? { topMatch } : {}), ...(eff.note !== undefined ? { effortNote: eff.note } : {}), gitignore: ignore, exitCode: 0 }, null, 2));
     else {
       write(`dz backlog: ${verdict.action.toUpperCase()} — captured ${rec.id}`);
@@ -15742,8 +16669,18 @@ async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd:
     if (commitId !== undefined) {
       // Validated above (safe id + known id) BEFORE any early return.
       const idx = ideas.findIndex((i) => i.id === commitId);
+      // ОТМЕТКА ВРЕМЕНИ И ЖУРНАЛ ставятся ЗДЕСЬ, а не «где-нибудь потом».
+      // Измерено 2026-09-02: `grep -c statusTs cli.ts` давал НОЛЬ — оба пути смены статуса в этом
+      // файле меняли поле и не отмечали, когда. Отсюда 22 терминальные записи без отметки и
+      // невычислимое «сколько идея пробыла в работе».
+      const spinFrom = ideas[idx]!.status;
+      const spinTs = new Date().toISOString();
       ideas[idx]!.status = 'in-progress';
+      ideas[idx]!.statusTs = spinTs;
       writeIdeas(projectRoot, ideas);
+      if (!appendTransition(projectRoot, { id: commitId, from: spinFrom, to: 'in-progress', ts: spinTs, by: 'backlog roulette --commit' })) {
+        write('dz backlog: переход НЕ записан в журнал — наблюдение потеряно (сам статус изменён)');
+      }
       pick = ideas[idx]!;
       committed = true;
     }
@@ -15807,6 +16744,7 @@ async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd:
         if (mirror.mirrored > 0 && mirror.error === undefined && clearEmbedStale(projectRoot, report.id)) embed = 'ok';
         else embed = 'stale';
       } else embed = 'stale';
+      refreshLearningStoreMark(projectRoot, writeErr, 'dz backlog edit');
     }
     if (json) {
       write(JSON.stringify({ verb: 'edit', ...report, embed, exitCode: report.ok ? (embed === 'stale' ? 1 : 0) : 1 }, null, 2));
@@ -15834,9 +16772,15 @@ async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd:
     const goalMap = readGoalMap(projectRoot);
     const related = ideas.filter((i) => rec.relatedIds.includes(i.id));
     const staging = stageEnrichment(projectRoot, rec, related, goalMap);
+    const enrichFrom = rec.status;
+    const enrichTs = new Date().toISOString();
     rec.status = 'enriched';
+    rec.statusTs = enrichTs;
     rec.enrichedPath = `features/${staging.slug}`;
     writeIdeas(projectRoot, ideas);
+    if (!appendTransition(projectRoot, { id: rec.id, from: enrichFrom, to: 'enriched', ts: enrichTs, by: 'backlog enrich' })) {
+      write('dz backlog: переход НЕ записан в журнал — наблюдение потеряно (сам статус изменён)');
+    }
     if (json) write(JSON.stringify({ slug: staging.slug, scaffoldPath: staging.scaffoldPath, handoff: 'idea2prd-manual', exitCode: 0 }, null, 2));
     else {
       write(`dz backlog enrich: staged ${rec.id} → ${staging.scaffoldPath}`);
@@ -15876,6 +16820,10 @@ async function cmdBacklog(options: Map<string, string>, flags: Set<string>, cwd:
     if (form.action === 'migrated' && !json) write(`dz backlog: re-embedded ${form.remirrored} idea vector(s) into the bounded dedup embed form (v${form.version})`);
     else if (form.action === 'deferred' && !json) write(`dz backlog: ⚠ embed-form migration deferred (${form.error ?? 'unknown error'})`);
     const report = await harmonizeBacklog(projectRoot, { apply, ...(thr !== undefined ? { threshold: Number(thr) } : {}) });
+    if (apply) {
+      refreshLearningStoreMark(projectRoot, writeErr, 'dz backlog harmonize --apply');
+      storeGuardResetReminder(projectRoot, writeErr, 'dz backlog harmonize --apply');
+    }
     if (json) {
       write(JSON.stringify({ ...report, exitCode: 0 }, null, 2));
       return 0;
@@ -16693,15 +17641,25 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
           io.teachReinforceRunner ?? runTeachGuardReinforcement,
         );
       case 'consolidate':
-        return await cmdConsolidate(options, flags, cwd, write);
+        return await cmdConsolidate(options, flags, cwd, write, writeErr);
       case 'recall':
         return await cmdRecall(options, flags, cwd, write, writeErr, io.classMatcher);
       case 'vector':
-        return await cmdVector(options, flags, cwd, write);
+        return await cmdVector(options, flags, cwd, write, writeErr);
       case 'brain':
         return await cmdBrain(options, flags, cwd, write, readStdin);
       case 'statusline':
-        return cmdStatusline(options, flags, cwd, write, readStdin);
+        return cmdStatusline(options, flags, cwd, write, readStdin, writeErr);
+      case 'store-guard':
+        return await cmdStoreGuard(
+          options,
+          flags,
+          cwd,
+          write,
+          writeErr,
+          io.stdin,
+          io.interactive ?? process.stdin.isTTY === true,
+        );
       case 'usage':
         return cmdUsage(options, optionLists, flags, cwd, write);
       case 'chain':
@@ -16769,7 +17727,7 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
       case 'mr-rakes':
         return await cmdMrRakes(options, flags, cwd, write);
       case 'retro':
-        return await cmdRetro(options, flags, cwd, write);
+        return await cmdRetro(options, flags, cwd, write, readStdin);
       case 'feature-adr-setup':
         return cmdFeatureAdrSetup(options, flags, cwd, write, writeErr);
       case 'challenge':
@@ -16814,6 +17772,8 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
         return cmdTgPost(options, flags, cwd, write);
       case 'name-check':
         return cmdNameCheck(options, flags, cwd, write);
+      case 'brief-check':
+        return cmdBriefCheck(options, flags, cwd, write);
       case 'provenance-check':
         return cmdProvenanceCheck(options, flags, cwd, write);
       case 'feature-adr-record':
@@ -16831,7 +17791,7 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
       case 'qe-bridge':
         return await cmdQeBridge(options, flags, cwd, write);
       case 'backlog':
-        return await cmdBacklog(options, flags, cwd, write);
+        return await cmdBacklog(options, flags, cwd, write, writeErr);
       case 'routing':
         return cmdRouting(options, flags, cwd, write);
       case 'bto-optimize':