@dzhechkov/harness-cli 0.4.2 → 0.4.3

package/.dz-manifest.json

@@ -9,7 +9,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "4e4049b871ded58ff38fc36b60387a2324610db81dedcb623fb9cce6e77b057b"
+        "sha256": "532051106b153c0d9bb7ad2abbeb71d418f88f1bc88e60a35e29cf42162af243"
       },
       {
         "path": "coverage/coverage-final.json",
@@ -37,15 +37,15 @@
       },
       {
         "path": "dist/cli.d.ts.map",
-        "sha256": "a260f0e8d698ac142b38e33ef4d4ed0a21ccee96b179514bcb01bf81c5dce00f"
+        "sha256": "5bdc153e789ac180543e9b4955ea36666dc27b7238637b05875e048fc49ae30f"
       },
       {
         "path": "dist/cli.js",
-        "sha256": "b8a9c6d50cea7eda1065d76adb83e7c853ed9d82db72e7b24f952598e9dbd9d9"
+        "sha256": "0183c01a98e232554a7460be48ee5fdf59dd3a7d09c719a31b08acc9c6b3528c"
       },
       {
         "path": "dist/cli.js.map",
-        "sha256": "4af214e9233bd8f37ab92b95b90fcf05bd46752ecdc0d9491484ee8a7e55c539"
+        "sha256": "c5bd1b0b852dd21de328494d7a99db336afbde4397b7c687d416f1a6f3c297b2"
       },
       {
         "path": "dist/index.d.ts",
@@ -69,7 +69,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "fa591b644f5abda81022a2cfe37996d739a2290ac46e09dcb958faa4e12be9f6"
+        "sha256": "4a164e5ac53ceec178463c1bdab9f80c1755311d5e4202c1f6234ca22c473b37"
       },
       {
         "path": "src/bin.ts",
@@ -77,7 +77,7 @@
       },
       {
         "path": "src/cli.ts",
-        "sha256": "c9847974744f5bfd383866eb1832e97cb856e73d6f65cad19abfb91f22998cae"
+        "sha256": "0a1097fc3a2294f934fc50f5871b287cfbc5ec85becdab914b7caeca42cb7d1a"
       },
       {
         "path": "src/index.ts",
@@ -189,12 +189,16 @@
       },
       {
         "path": "test/mutation-registry.json",
-        "sha256": "3dd056f9d05712e45173b0911fc5900f0f52f8deba506d57c0e2b8281eb36a74"
+        "sha256": "fe8e5792626cf58678c1e2bcb809f63413655c2e171439157b74deb8b4fd80fb"
       },
       {
         "path": "test/statusline-panel.test.ts",
         "sha256": "b09b42c4ece1a83e5d3f3765629b0756a8f30a7122f3fc30363f93f092a44c0d"
       },
+      {
+        "path": "test/trace-bundle-cli.test.ts",
+        "sha256": "fdaad63359ca7ce351e505e613b547bbc653e0847403edfae88d22a8a524b7a0"
+      },
       {
         "path": "test/workflow-init-lint-clean.test.ts",
         "sha256": "b7a64462983901adca86ecc29e76b3f95885210e5aaba68352356191e6bfac7f"
@@ -217,5 +221,5 @@
       }
     ]
   },
-  "signature": "nT7OzOloD2DCFR2ZYd4uWJ6isGyyfLiYk7v8hUKp4f0OTP0fTpsVvbDYJF9VvxASNVqwOGaQ7F6WQVu3NrkmBQ=="
+  "signature": "wIo2tChkUqPT1qEHFeLlgbuzL29rRhhpVer4yaDmeuq7CsvdMeYN2QcttC496DwlepKeZ1EE3h2sSoY5w16qAA=="
 }

package/README.md

@@ -1141,6 +1141,57 @@ host run there is nothing to read, and it says so rather than inventing a timeli
 follows from the same boundary: on a non-Claude-Code target the authoring and lint verbs work
 unchanged, and only execution is absent.
 
+### Move a run's telemetry to another machine (`workflow-trace export` / `import`)
+
+A run leaves traces on the machine that produced it. `export` puts one run's telemetry into a single
+movable file; `import` reconstructs that run under a root you name.
+
+```bash
+dz workflow-trace export --slug my-feature --o my-feature.bundle.json
+dz workflow-trace import my-feature.bundle.json --into /other/project
+```
+
+**What a bundle carries** — the raw event lines (`trace.jsonl`, `.fa-state/checkpoints.jsonl`), the
+ledger rows selected for that run, optionally the training pairs, and `runMeta`: WHO ran each stage,
+read from the harness's own workflow records. **Events, never aggregates.** The one derived value —
+`attribution`, "which model ran which stage" — travels ALONGSIDE the records it was folded from,
+marked `derived`, naming its rule and the record ids, so a consumer that disagrees can recompute it.
+The rule is stated rather than implied: last-writer-wins by timestamp is a CHOICE — a run whose
+phases used different models has no single honest answer, and the map reports who ran it *last*.
+
+**The ledger selector** matches a row by `runId`, or by `slug` when the row has no `runId` — because
+only `loop-run` rows carry a `runId`, so a `runId`-only filter would select nothing for a feature-adr
+run. The bundle reports rows scanned vs matched, so an empty slice is visibly empty rather than
+indistinguishable from an absent ledger.
+
+**Consent does not travel inside the bundle.** Training pairs may contain target-repo code, so
+including them needs `--include-pairs --yes` at export AND `--with-pairs` at import; a pairs-bearing
+bundle imported without the flag writes no pair content.
+
+**Import is fail-closed.** It reconstructs the run's native layout under `--into`, and REFUSES to
+write into a run directory that already has content unless it is the bundle's own run and `--force`
+is given; an identity mismatch refuses even under `--force`. A refused import writes nothing — not
+one file.
+
+**Degradation is loud and typed**, and exactly one reason asks for action:
+
+| reason | meaning | action |
+|---|---|---|
+| `records-absent` / `no-match` | no harness records, or none for this run | none |
+| `predates-model-routing` | a genuine older run, from before per-stage model routing | none — this is history |
+| `unreadable` | a record could not be parsed | look at that record |
+| `layout-unrecognised` | records exist and parse, but the fields we read are gone | **the harness record layout CHANGED — update the reader** |
+
+By default a degraded export still succeeds and prints one named line per degraded member; `--strict`
+makes it exit non-zero so automation fails closed. The split exists because the actionable reason
+used to fire on normal data — three of thirty-two runs in a real store were simply older than
+per-stage routing — and an alarm that sounds on normal operation stops being an alarm.
+
+**Honest scope:** `runMeta` is read from a store this project does not own, so its shape can change
+without notice. That is precisely what `layout-unrecognised` exists to announce, and why the reader
+refuses rather than half-parsing: a partially-read record would report a model-blind run as
+model-known.
+
 **The v1 plan surface is deliberately NARROW and fully enacted** — `dz workflow validate` REJECTS
 (named diagnostics, never a silent no-op) anything the generated loop would not perform: retry
 timing (`initialDelayMs`/`backoffMultiplier`/`maxDelayMs`/`jitter` — v1 retries are immediate;
@@ -1245,6 +1296,8 @@ dz scout             [--topics <list>] [--since <date>] [--deep] [--output <file
 dz workflow          init --name <n> [--pattern pipeline|barrier|fanout|gate] [--o <plan.json>] | validate <plan.json> [--json] | render <plan.json> --o <script.js> [--check] [--force] | blobs [--check]   # loop-plan/1 authoring (the ADR-005 templates are retired)
 dz workflow-lint     <script.js> [--plan <plan.json>] [--require-plan|--legacy] [--json]   # 17-rule deterministic gate; exit 0/1/3 — inconclusive is never a pass
 dz workflow-trace    <runDir|--slug <s>|--run <id>> [--invariants <plan.json>] [--html <out.html>] [--json]   # timeline + SEQ invariant runner over the loop's own trace.jsonl
+dz workflow-trace export <run> --o <file> [--include-pairs --yes] [--strict]   # one run's telemetry as ONE movable file
+dz workflow-trace import <bundle> --into <root> [--force] [--with-pairs]       # reconstruct that run; fail-closed against clobbering
 dz plugin            [--version <ver>]
 dz downloads
 dz migrate           [--project <dir>]
@@ -1336,6 +1389,13 @@ exits 1 rather than silently weakening panel arbitration. It is load-bearing in
   24 h. Use `--project <dir>` to pin the panel to a specific project root.
 
 ### Usage estimate (`dz usage`)
+> **Pin the weekly reset to an ABSOLUTE instant.** `weeklyResetAnchor: "Wed 08:59"` is
+> server-timezone-relative — measured: the same moment lands a week apart under UTC vs `+03:00`, so
+> after a real account reset the counter can keep showing the OLD week for hours while printing the
+> "correct" clock time. Add your offset: `"Wed 08:59 +03:00"` in `.dz/config.json` — the boundary
+> then never moves with the machine's timezone, and `dz usage` prints the full anchor
+> (`resets Wed 08:59 +03:00`). Without an offset it warns on every run.
+
 
 `dz usage` prints a READONLY, never-throw ESTIMATE of Claude SESSION and WEEKLY token usage,
 aggregated from your local `~/.claude/projects/**/*.jsonl` transcripts. Weekly counts start at the
@@ -1713,6 +1773,27 @@ dz backlog ship 268d3cb1 --reason "shipped in harness-core 0.3.151"
 #   → dz backlog ship: 268d3cb1… new → shipped  add a compounding metric …
 #   (shipping an already-shipped idea is a SAID no-op, exit 0 — safe in cleanup batches)
 dz backlog drop 9286f5eb --reason "superseded by 268d3cb1"    # retire without shipping (→ dropped)
+dz backlog edit 9286f5eb --text "corrected wording"           # rewrite ONE idea's text; every other field
+
+# feed the learned auto-cost routing from REAL run telemetry, then read its advice
+dz routing recommend                # per-stage args.models suggestion, printed WITH its basis:
+                                    # n runs, the time window, the grade-floor rule (success ⇔ QE grade ≥ B,
+                                    # attributed run-level — an inference, and it says so), and every skipped
+                                    # record with WHY. qe is FORCED to the cross-family of the code pick —
+                                    # a same-family qe recommendation is unrepresentable, not filtered.
+dz routing recommend --apply        # feed the samples into .dz/routing-outcomes.json (the store the
+                                    # `auto-cost` plan spec reads) — idempotent by runId: a second apply
+                                    # feeds 0 and names the skipped runs. Insufficient data is SAID
+                                    # (cold-start pick + escalation chain), never dressed as a bar-met pick.
+                                                              # (status, effort, goal, uses…) is preserved byte-for-byte,
+                                                              # the previous text lands in .dz/backlog/edits.jsonl, and the
+                                                              # dedup vector is re-embedded in the same bounded form.
+                                                              # If the re-embed FAILS the edit still lands, exits 1, and the
+                                                              # record is MARKED embedStale — dedup then refuses to trust its
+                                                              # similarity (exact-text identity still applies) until
+                                                              # `dz vector reindex` repairs it. The guard sits where the harm
+                                                              # would be (the future duplicate verdict), not in a warning
+                                                              # nobody re-reads. --append adds instead of replacing; --dry-run previews.
 dz backlog reopen 268d3cb1                                    # changed your mind → back to the pool (new)
 #   reopen on an already-new idea is REFUSED (exit 1) — that is almost always the wrong id.
 #   Terminal→terminal never happens silently: ship on a dropped idea (or drop on shipped) is refused;
@@ -3222,7 +3303,7 @@ npx @dzhechkov/p-replicator init
 
 ## Status
 
-`v0.4.2` — published on npm. Also available as [Claude Plugin](#claude-plugin). Part of [DZ Harness Hub](https://github.com/djd1m/dz-harness-hub).
+`v0.4.3` — published on npm. Also available as [Claude Plugin](#claude-plugin). Part of [DZ Harness Hub](https://github.com/djd1m/dz-harness-hub).
 
 ## Claude Plugin
 

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAkbH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACjE;AAED,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KACvD;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAyyQ9E,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAoK5E"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAocH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACjE;AAED,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KACvD;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AA0lR9E,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAoK5E"}

package/dist/cli.js

@@ -10,15 +10,15 @@ import { execFileSync, execSync, spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { homedir, tmpdir } from 'node:os';
 import { createRequire } from 'node:module';
-import { createSkill, getSkillInfo, isTargetName, listSkills, runDoctor, runInit, resolvePackageSkillRoots, PACKAGE_SKILL_LAYOUTS, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, buildParityMatrix, TARGET_CAPABILITIES, TARGET_SHORT_LABELS, WORKFLOW_TEMPLATES_RETIRED_MESSAGE, parsePlan, isParseErrors, validatePlan, normalizePlan, planDigest, toTraceProjection, renderPlan, mergeRender, lint, lintExitCode, LOOP_BLOBS, parseTrace, assembleTimeline, runInvariants, renderTimelineHtml, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, lessonDeltaReport, removePatternsByIds, snapshotStore, recallHybrid, teachGuard, mirrorPatternsToVector, mirrorEntriesToVector, patternVectorEntry, readMemoryLearningConfig, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns, clearAgentdbQuarantine, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveCostLedger, renderCostLedger, verifyCostLedgerReport, writeCostLedgerJsonl, COST_LEDGER_SCOPE, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, claimCheck, summarize, queryBookKnowledge, loadStorePatternsSync, patternRecordId, loadStoreRecords, recordToPattern, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, RECALL_USAGE_LOG_RELATIVE, RECALL_USAGE_LOG_MAX_BYTES, parseRecallUsageLog, buildRecallUsageReport, EVENT_CHAIN_TAIL_BYTES, EMPTY_LOG_TAIL, readTailInfo, appendChainedLines, verifyEventChainText, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, generateSigningKeypair, evaluateGuard, resolveRules, auditRecord, guardExitCode, DEFAULT_RULES, parsePnpmLockImporters, scannableStubPath, 
+import { createSkill, getSkillInfo, isTargetName, listSkills, runDoctor, runInit, resolvePackageSkillRoots, PACKAGE_SKILL_LAYOUTS, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, buildParityMatrix, TARGET_CAPABILITIES, TARGET_SHORT_LABELS, WORKFLOW_TEMPLATES_RETIRED_MESSAGE, parsePlan, isParseErrors, validatePlan, normalizePlan, planDigest, toTraceProjection, renderPlan, mergeRender, lint, lintExitCode, LOOP_BLOBS, parseTrace, assembleTimeline, runInvariants, renderTimelineHtml, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, lessonDeltaReport, removePatternsByIds, snapshotStore, recallHybrid, teachGuard, mirrorPatternsToVector, mirrorEntriesToVector, patternVectorEntry, readMemoryLearningConfig, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns, clearAgentdbQuarantine, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveCostLedger, renderCostLedger, verifyCostLedgerReport, writeCostLedgerJsonl, COST_LEDGER_SCOPE, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, parseWeeklyResetAnchor, claimCheck, summarize, queryBookKnowledge, loadStorePatternsSync, patternRecordId, loadStoreRecords, recordToPattern, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, RECALL_USAGE_LOG_RELATIVE, RECALL_USAGE_LOG_MAX_BYTES, parseRecallUsageLog, buildRecallUsageReport, EVENT_CHAIN_TAIL_BYTES, EMPTY_LOG_TAIL, readTailInfo, appendChainedLines, verifyEventChainText, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, generateSigningKeypair, evaluateGuard, resolveRules, auditRecord, guardExitCode, DEFAULT_RULES, parsePnpmLockImporters, scannableStubPath, 
 // guard-promotion (feature guard-promotion, scout idea #1)
-assembleCandidates, renderPromotionReport, renderPromotionAdr, normalizePromotionState, nextPromotionState, globMatch, promotionAdrRelPath, DEFAULT_WINDOW_DAYS, DEFAULT_PERIODS, MAX_CONTENT_FETCHES, BUILTIN_COVERAGE, decideProvenance, isInsideTree, signManifest, verifyManifest, listSignablePackFiles, assertKeyOutsideTree, decidePublishGate, collectPackageFacts, planReleaseGates, selectAffectedPackages, classifyGateExecutions, buildFailureIssue, buildReleaseNotes, releaseTagName, firstOutputLine, formatPublishError, MANIFEST_NAME, SBOM_NAME, buildArchitectureMap, renderMapHuman, findArchitectureDrift, renderDriftReport, scanWorkspacePackages, loadSubsystemManifest, loadProductVision, checkFeatureAgainstArchitecture, renderArchCheck, planProjectSkills, guidanceForStage, renderInjectionReport, analyzeCorpus, renderRakeReport, renderCriticSection, rakeAsLesson, rakeReward, DEFAULT_RAKE_THRESHOLDS, streamSessionEvents, findLatestTranscript, detectProcessRakes, buildRetro, renderRetro, retroLessonText, PROCESS_SIGNATURES, RETRO_DOMAIN, scanForSetup, buildSetupPlan, scaffoldFromSpec, renderScaffoldPreview, readExistingForScaffold, assembleChallengeContext, buildChallengeBrief, planDiscriminationCheck, classifyDiscrimination, pickAdversaryModel, CHALLENGE_QUESTIONS, loadOutcomes, renderOutcomes, statsForKey, selectAutoCost, recordProvisional, finalizeOutcome, COST_LADDER, splitScenarios, budgetPlan, selectWinner, proseScopeOk, renderProseDiff, readScenarioIds, DEFAULT_MAX_JUDGE_RUNS, collectDeliveryFacts, planDeliveryCheck, renderDeliveryBrief, classifyDelivery, isUsablePlaneResult, renderDeliveryReview, scanSkillsLayout, parseInitFacts, verifyRegistration, buildContentProbePrompt, classifyContentProbe, renderContentProbe, findNonRegistrableSkillDirs, assembleCompoundingReport, 
+assembleCandidates, renderPromotionReport, renderPromotionAdr, normalizePromotionState, nextPromotionState, globMatch, promotionAdrRelPath, DEFAULT_WINDOW_DAYS, DEFAULT_PERIODS, MAX_CONTENT_FETCHES, BUILTIN_COVERAGE, decideProvenance, isInsideTree, signManifest, verifyManifest, listSignablePackFiles, assertKeyOutsideTree, decidePublishGate, collectPackageFacts, planReleaseGates, selectAffectedPackages, classifyGateExecutions, buildFailureIssue, buildReleaseNotes, releaseTagName, firstOutputLine, formatPublishError, MANIFEST_NAME, SBOM_NAME, buildArchitectureMap, renderMapHuman, findArchitectureDrift, renderDriftReport, scanWorkspacePackages, loadSubsystemManifest, loadProductVision, checkFeatureAgainstArchitecture, renderArchCheck, planProjectSkills, guidanceForStage, renderInjectionReport, analyzeCorpus, renderRakeReport, renderCriticSection, rakeAsLesson, rakeReward, DEFAULT_RAKE_THRESHOLDS, streamSessionEvents, findLatestTranscript, detectProcessRakes, buildRetro, renderRetro, retroLessonText, PROCESS_SIGNATURES, RETRO_DOMAIN, scanForSetup, buildSetupPlan, scaffoldFromSpec, renderScaffoldPreview, readExistingForScaffold, assembleChallengeContext, buildChallengeBrief, planDiscriminationCheck, classifyDiscrimination, pickAdversaryModel, CHALLENGE_QUESTIONS, loadOutcomes, renderOutcomes, statsForKey, selectAutoCost, recordProvisional, finalizeOutcome, harvestStageOutcomes, recommendModels, planFeed, GRADE_SUCCESS_FLOOR, COST_LADDER, splitScenarios, budgetPlan, selectWinner, proseScopeOk, renderProseDiff, readScenarioIds, DEFAULT_MAX_JUDGE_RUNS, collectDeliveryFacts, planDeliveryCheck, renderDeliveryBrief, classifyDelivery, isUsablePlaneResult, renderDeliveryReview, scanSkillsLayout, parseInitFacts, verifyRegistration, buildContentProbePrompt, classifyContentProbe, renderContentProbe, findNonRegistrableSkillDirs, assembleCompoundingReport, 
 // Cold-vs-warm EPOCH RUNNER (feature epoch-replay) — orchestrates + scores, never calls a model.
 replayableInstances, buildWorkOrder, buildJudgePrompts, unblindJudgments, verifyWorkOrder, isValidMargin, DIGEST_HONEST_SCOPE, scoreEpochReplay, generateMockOutcomes, renderEpochReplayResult, renderWorkOrderSummary, renderJudgePromptsSummary, WORK_ORDER_KIND, DEFAULT_MOCK_N, DEFAULT_MOCK_SEED, scoreRun, renderScorecard, renderCompoundingReport, readReinforcementState, readQuarantineState, registrationExitCode, renderRegistrationReport, 
 // Smart Backlog (feature smart-backlog) — goal-directed idea pipeline over the Brain vector engine.
-readBacklogConfig, readIdeas, writeIdeas, ideaId, dedupIdea, readGoalMap, readGoalMapDetailed, parseEffort, ensureBacklogGitignored, isSafeId, alignIdea, mirrorIdeaVector, ensureBacklogEmbedForm, readBacklogEmbedFormVersion, recordAbsorption, DEDUP_EMBED_FORM_VERSION, snapshotIdeas, spinRoulette, rankRoulette, seededRng, eligibleIdeas, stageEnrichment, buildJiraDraft, resolveJiraAdapter, makeBacklogIO, harmonizeBacklog, transitionIdeas, BACKLOG_BACKENDS, applyDomainBoost, DZ_OWNED_TASK_TYPES, applyExportHoldout, DEFAULT_HELD_OUT_DOMAINS, canonicalDomainKey, readAgentdbRowsByTaskType, heldOutAfterOptIn, renderHoldoutNote, renderSharedStoreAdvice, decideVectorExport, countDisplacedByCut, renderDomainBoostNote, renderDomainCutNote, parseReqeDebt, buildReqeBrief, settleReqeDebt, renderReqeList, REQE_SCOPE, 
+readBacklogConfig, readIdeas, writeIdeas, ideaId, dedupIdea, readGoalMap, readGoalMapDetailed, parseEffort, ensureBacklogGitignored, isSafeId, alignIdea, mirrorIdeaVector, ensureBacklogEmbedForm, readBacklogEmbedFormVersion, recordAbsorption, DEDUP_EMBED_FORM_VERSION, snapshotIdeas, spinRoulette, rankRoulette, seededRng, eligibleIdeas, stageEnrichment, buildJiraDraft, resolveJiraAdapter, makeBacklogIO, harmonizeBacklog, transitionIdeas, editIdea, clearEmbedStale, BACKLOG_BACKENDS, applyDomainBoost, DZ_OWNED_TASK_TYPES, applyExportHoldout, DEFAULT_HELD_OUT_DOMAINS, canonicalDomainKey, readAgentdbRowsByTaskType, heldOutAfterOptIn, renderHoldoutNote, renderSharedStoreAdvice, decideVectorExport, countDisplacedByCut, renderDomainBoostNote, renderDomainCutNote, parseReqeDebt, buildReqeBrief, settleReqeDebt, renderReqeList, REQE_SCOPE, 
 // Mutation gate (feature ha-mutation-gate) — break each named protection, run the suite, require red.
-parseMutationRegistry, applyMutationToText, countFailingTests, classifyBaseline, classifyRunFailure, classifyMutationOutcome, mutationGateExitCode, summarizeMutationResults, renderMutationReport, } from '@dzhechkov/harness-core';
+parseMutationRegistry, applyMutationToText, countFailingTests, classifyBaseline, classifyRunFailure, classifyMutationOutcome, mutationGateExitCode, summarizeMutationResults, renderMutationReport, TRACE_BUNDLE_LEDGER_PATH, TRACE_BUNDLE_SCHEMA, TRACE_BUNDLE_RUN_META_FILE, buildBundle, serializeBundle, parseBundle, planImport, } from '@dzhechkov/harness-core';
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
 import { scanGitHub, analyzeRepo, generateReport, deepAnalyze, scanAllSources, ScoutMemory } from '@dzhechkov/scout';
 const USAGE = `dz - DZ cross-platform harness CLI
@@ -39,6 +39,8 @@ Usage:
   dz workflow blobs [--check]                               (list/self-check the subsystem blob registry)
   dz workflow-lint <script.js> [--plan <plan.json>] [--require-plan|--legacy] [--json]   (layer-1 gate; exit 0/1/3 — inconclusive is never a pass)
   dz workflow-trace <runDir|--slug <s>|--run <id>> [--invariants <plan.json>] [--html <out.html>] [--json]   (timeline + SEQ invariant runner)
+  dz workflow-trace export <run> --o <file> [--include-pairs --yes] [--strict]   (one run's telemetry as ONE movable file: events, not aggregates; degradation is typed and LOUD, --strict fails closed)
+  dz workflow-trace import <bundle> --into <root> [--force] [--with-pairs]       (reconstruct that run under an explicit root; FAIL-CLOSED — never writes over a run that already has content)
   dz install <npm-pkg> [--target <name>] [--project <dir>] [--force]
   dz bundle  [--preset <name> | --select id,id,...] [--out <dir>] [--skills-dir <dir>] [--force]   (portable self-contained skill bundles for a generic/LangGraph consumer)
   dz doctor  [--project <dir>] [--pubkey <path>] [--require-signing]   (health + signature check of installed packs)
@@ -65,6 +67,8 @@ Usage:
   dz backlog roulette [--pick <N>] [--seed <n>] [--commit] [--project <dir>] [--json]   (WEIGHTED draw over eligible ideas: alignment^alpha * recencyDecay * 1/effort, seeded; --pick N = ranked shortlist; --commit flips the pick to in-progress)
   dz backlog ship <id> [<id>…] [--reason <t>] [--dry-run] [--project <dir>] [--json]   (mark work DONE: new|enriched|in-progress → shipped, removing it from the roulette pool — run it after finishing a task; short id prefixes ok, ambiguous = loud error)
   dz backlog drop <id> [<id>…] [--reason <t>] [--dry-run] [--project <dir>] [--json]   (retire an idea: new|enriched|in-progress → dropped)
+  dz backlog edit <id> --text "<new>" | --append "<more>" [--dry-run] [--project <dir>] [--json]   (rewrite ONE idea's text, preserving every other field; re-embeds the dedup vector, and on a failed re-embed MARKS the record embedStale so dedup refuses to trust it — previous text preserved in .dz/backlog/edits.jsonl)
+  dz routing recommend [--tier <t>] [--apply] [--json]   (per-stage args.models suggestion from REAL telemetry — harness records + imported run-meta sidecars — printed WITH its basis: n runs, window, the grade-floor rule, skip reasons; qe is FORCED cross-family of code; --apply feeds .dz/routing-outcomes.json idempotently by runId)
   dz backlog reopen <id> [<id>…] [--reason <t>] [--dry-run] [--project <dir>] [--json]   (back to the pool: shipped|dropped|in-progress → new)
   dz backlog enrich <id> [--project <dir>] [--json]                        (stage the idea2prd input scaffold in features/<slug>/ and hand off to the idea2prd-manual skill — the CLI never fabricates a PRD)
   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)
@@ -758,7 +762,244 @@ function cmdWorkflowLint(options, flags, cwd, write) {
 /** `dz workflow-trace` — timeline + invariant runner over a run's trace.jsonl. Scope is CAPPED
  * (AM-8): <runDir|--slug|--run>, --invariants, --html, --json. NO watch/filter/compare/search/
  * retention/access-control — adding one needs an ADR amendment (the surface test pins this). */
+/** The tool version stamped into a bundle's provenance. Unknown is honest; a throw is not. */
+function traceBundleToolVersion() {
+    try {
+        const req = createRequire(import.meta.url);
+        const pkg = req('../package.json');
+        return typeof pkg.version === 'string' ? pkg.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/** Resolve a run the SAME three ways the timeline reader does — positional, --slug, --run — so a
+ * bundle can never address a run by a scheme the rest of the command does not understand. */
+function resolveTraceRun(options, cwd, positional) {
+    const slug = options.get('slug');
+    const runId = options.get('run');
+    if (positional !== undefined && positional !== '') {
+        return { runDir: resolve(cwd, positional), slug: slug ?? null, runId: runId ?? null };
+    }
+    if (slug !== undefined)
+        return { runDir: resolve(cwd, 'features', slug), slug, runId: runId ?? null };
+    if (runId !== undefined)
+        return { runDir: resolve(cwd, '.dz', 'loop-trace', runId), slug: slug ?? null, runId };
+    return null;
+}
+/** Every harness workflow record under the project, already parsed. An unparseable file is SKIPPED
+ * here rather than guessed at — the pure half answers `unreadable` from what it is handed. */
+function readHarnessRecords(cwd) {
+    const out = [];
+    const base = join(cwd, 'roam', 'claude-state');
+    if (!existsSync(base))
+        return out;
+    let sessions = [];
+    try {
+        sessions = readdirSync(base);
+    }
+    catch {
+        return out;
+    }
+    for (const session of sessions) {
+        const dir = join(base, session, 'workflows');
+        if (!existsSync(dir))
+            continue;
+        let names = [];
+        try {
+            names = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!name.endsWith('.json'))
+                continue;
+            try {
+                out.push(JSON.parse(readFileSync(join(dir, name), 'utf-8')));
+            }
+            catch { /* skipped, never guessed */ }
+        }
+    }
+    return out;
+}
+/** `dz workflow-trace export` — one run's telemetry as ONE movable file. */
+function cmdWorkflowTraceExport(options, flags, cwd, write) {
+    const out = options.get('o') ?? options.get('out');
+    const run = resolveTraceRun(options, cwd, options.get('_positional_1'));
+    if (run === null || out === undefined || out === '') {
+        write('dz workflow-trace export: usage — dz workflow-trace export <runDir|--slug <s>|--run <id>> --o <file> [--include-pairs --yes] [--strict]');
+        return 1;
+    }
+    const wantPairs = flags.has('include-pairs');
+    if (wantPairs && !flags.has('yes')) {
+        write('dz workflow-trace export: --include-pairs needs --yes — training pairs may carry TARGET-REPO CODE and full prompts, so shipping them off this machine is a second, explicit decision');
+        return 1;
+    }
+    const readSlot = (abs, origin) => existsSync(abs)
+        ? { present: true, member: { origin, content: readFileSync(abs, 'utf-8') } }
+        : { present: false, reason: `absent on disk at ${origin}` };
+    const trace = readSlot(join(run.runDir, 'trace.jsonl'), 'trace.jsonl');
+    const checkpoints = readSlot(join(run.runDir, '.fa-state', 'checkpoints.jsonl'), '.fa-state/checkpoints.jsonl');
+    const ledgerAbs = join(cwd, TRACE_BUNDLE_LEDGER_PATH);
+    // An empty trailing line is not a malformed row — hand the pure half only real lines, or the
+    // bundle reports a phantom parse failure on every well-formed ledger (MEASURED on first run).
+    const ledgerLines = existsSync(ledgerAbs)
+        ? readFileSync(ledgerAbs, 'utf-8').split('\n').filter((line) => line.trim() !== '')
+        : null;
+    const pairFiles = [];
+    if (wantPairs && run.slug !== null) {
+        const pairDir = join(cwd, '.dz', 'fa-training', run.slug);
+        if (existsSync(pairDir)) {
+            for (const name of readdirSync(pairDir)) {
+                if (!name.endsWith('.jsonl'))
+                    continue;
+                pairFiles.push({ origin: `.dz/fa-training/${run.slug}/${name}`, content: readFileSync(join(pairDir, name), 'utf-8') });
+            }
+        }
+    }
+    const bundle = buildBundle({
+        sourceRoot: cwd,
+        runAddress: options.get('_positional_1') ?? (run.slug !== null ? `--slug ${run.slug}` : `--run ${String(run.runId)}`),
+        slug: run.slug,
+        runId: run.runId,
+        toolVersion: traceBundleToolVersion(),
+        createdAt: null,
+        trace,
+        checkpoints,
+        ledgerLines,
+        ...(ledgerLines === null ? { ledgerReason: `no ledger at ${TRACE_BUNDLE_LEDGER_PATH}` } : {}),
+        includePairs: wantPairs,
+        pairFiles: wantPairs ? pairFiles : null,
+        records: readHarnessRecords(cwd),
+    });
+    try {
+        mkdirSync(dirname(resolve(cwd, out)), { recursive: true });
+        writeFileSync(resolve(cwd, out), serializeBundle(bundle));
+    }
+    catch (err) {
+        write(`dz workflow-trace export: could not write ${out} — ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    // Degradation is NAMED, never silent — and exactly one reason is actionable.
+    let degraded = 0;
+    if (!bundle.trace.present) {
+        degraded++;
+        write(`dz workflow-trace export: trace absent — ${bundle.trace.reason}`);
+    }
+    if (!bundle.checkpoints.present) {
+        degraded++;
+        write(`dz workflow-trace export: checkpoints absent — ${bundle.checkpoints.reason}`);
+    }
+    if (!bundle.ledger.present) {
+        degraded++;
+        write(`dz workflow-trace export: ledger absent — ${String(bundle.ledger.reason)}`);
+    }
+    if (!bundle.runMeta.resolved) {
+        degraded++;
+        const reason = bundle.runMeta.reason;
+        write(reason === 'layout-unrecognised'
+            ? 'dz workflow-trace export: runMeta UNRESOLVED (layout-unrecognised) — the harness workflow-record layout CHANGED; update the reader in harness-core/src/trace-bundle.ts. This is the one reason that needs action'
+            : `dz workflow-trace export: runMeta unresolved (${reason}) — no action needed, this is history or absence, not a layout change`);
+    }
+    write(`dz workflow-trace export: wrote ${out} (${bundle.schema}; ledger rows scanned ${bundle.ledger.scanned}, matched ${bundle.ledger.matched}, malformed ${bundle.ledger.malformed})`);
+    if (degraded > 0 && flags.has('strict')) {
+        write(`dz workflow-trace export: --strict — ${degraded} member(s) degraded, failing closed`);
+        return 1;
+    }
+    return 0;
+}
+/** `dz workflow-trace import` — reconstruct a run under an explicit root. FAIL-CLOSED. */
+function cmdWorkflowTraceImport(options, flags, cwd, write) {
+    const file = options.get('_positional_1');
+    const into = options.get('into');
+    if (file === undefined || file === '' || into === undefined || into === '') {
+        write('dz workflow-trace import: usage — dz workflow-trace import <bundle.json> --into <root> [--force] [--with-pairs]');
+        return 1;
+    }
+    const abs = resolve(cwd, file);
+    if (!existsSync(abs)) {
+        write(`dz workflow-trace import: no such bundle: ${file}`);
+        return 1;
+    }
+    const parsed = parseBundle(readFileSync(abs, 'utf-8'));
+    if (!parsed.ok) {
+        write(parsed.reason === 'unknown-schema'
+            ? `dz workflow-trace import: REFUSED — unknown bundle schema "${parsed.found}"; this dz reads ${TRACE_BUNDLE_SCHEMA}. A future bundle is never best-effort parsed`
+            : parsed.reason === 'member-shape'
+                ? `dz workflow-trace import: REFUSED — member "${parsed.member}" fails its shape check; a partial import is never left behind`
+                : 'dz workflow-trace import: REFUSED — the bundle is not parseable JSON');
+        return 1;
+    }
+    const bundle = parsed.bundle;
+    const root = resolve(cwd, into);
+    const runDirRel = bundle.provenance.slug !== null ? join('features', bundle.provenance.slug) : join('.dz', 'loop-trace', String(bundle.provenance.runId ?? 'unknown-run'));
+    const runDirAbs = join(root, runDirRel);
+    let runDirHasContent = false;
+    try {
+        runDirHasContent = existsSync(runDirAbs) && readdirSync(runDirAbs).length > 0;
+    }
+    catch {
+        runDirHasContent = false;
+    }
+    let runIdentity = null;
+    const metaAbs = join(runDirAbs, TRACE_BUNDLE_RUN_META_FILE);
+    if (existsSync(metaAbs)) {
+        try {
+            const meta = JSON.parse(readFileSync(metaAbs, 'utf-8'));
+            runIdentity = {
+                slug: typeof meta.slug === 'string' ? meta.slug : null,
+                runId: typeof meta.runId === 'string' ? meta.runId : null,
+            };
+        }
+        catch {
+            runIdentity = null;
+        }
+    }
+    const plan = planImport(bundle, {
+        runDir: runDirRel,
+        existingPaths: [],
+        runDirHasContent,
+        runIdentity,
+        force: flags.has('force'),
+        withPairs: flags.has('with-pairs'),
+        bundleName: basename(abs),
+    });
+    if (!plan.ok) {
+        for (const refusal of plan.refusals)
+            write(`dz workflow-trace import: REFUSED ${refusal.path} — ${refusal.reason}`);
+        write('dz workflow-trace import: nothing was written');
+        return 1;
+    }
+    let written = 0;
+    const failures = [];
+    for (const entry of plan.writes) {
+        const target = join(root, entry.path);
+        try {
+            mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, entry.content);
+            written++;
+        }
+        catch (err) {
+            failures.push(`${entry.path} — ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // Report what ACTUALLY landed, computed from the writes, not from the plan.
+    for (const skipped of plan.refusals)
+        write(`dz workflow-trace import: skipped ${skipped.path} — ${skipped.reason}`);
+    for (const failure of failures)
+        write(`dz workflow-trace import: FAILED ${failure}`);
+    write(`dz workflow-trace import: wrote ${written} of ${plan.writes.length} member(s) under ${into}`);
+    return failures.length > 0 ? 1 : 0;
+}
 function cmdWorkflowTrace(options, flags, cwd, write) {
+    // Two subcommands ride the SAME run addressing as the timeline reader (AM-8 keeps the surface
+    // capped; these are bundle transport, not new query verbs).
+    const sub = options.get('_positional_0');
+    if (sub === 'export')
+        return cmdWorkflowTraceExport(options, flags, cwd, write);
+    if (sub === 'import')
+        return cmdWorkflowTraceImport(options, flags, cwd, write);
     const runDirArg = options.get('_positional_0');
     const slug = options.get('slug');
     const runId = options.get('run');
@@ -1599,7 +1840,16 @@ function cmdUsage(options, optionLists, flags, cwd, write) {
         const s = u.sessionPct === null ? 'n/a' : '~' + u.sessionPct + '%';
         const binding = hasModelLimits && u.weeklyBindingModel !== undefined ? ' ' + u.weeklyBindingModel + '-bound' : '';
         const w = u.weeklyPct === null ? 'n/a' : '~' + u.weeklyPct + '%' + binding;
-        write('usage: session ' + s + ' (resets ' + clock(u.sessionResetsAt) + ') · week ' + w + ' (resets ' + clock(u.weeklyResetsAt) + ') · estimated');
+        // The weekly reset is WEEKLY: print the anchor verbatim (weekday + offset), not a bare clock
+        // time — 'resets 08:59' reads as daily and hides the weekday (idea c8513be9: the bare form
+        // misread a Monday reading as '41 minutes after the boundary' when the boundary was Wednesday's).
+        const weeklyAnchorLabel = typeof lim.weeklyResetAnchor === 'string' && lim.weeklyResetAnchor !== ''
+            ? lim.weeklyResetAnchor
+            : clock(u.weeklyResetsAt);
+        write('usage: session ' + s + ' (resets ' + clock(u.sessionResetsAt) + ') · week ' + w + ' (resets ' + weeklyAnchorLabel + ') · estimated');
+        if (typeof lim.weeklyResetAnchor === 'string' && parseWeeklyResetAnchor(lim.weeklyResetAnchor)?.offsetMinutes === undefined) {
+            write('  ⚠ weeklyResetAnchor has NO utc offset — the boundary follows the SERVER timezone, not your account\'s true reset instant (measured: the same moment lands a week apart under UTC vs +03:00). Pin it: "' + lim.weeklyResetAnchor + ' +03:00" (your offset) in .dz/config.json');
+        }
         // re-QE debt surfacing (backlog 6b40e667): the moment someone checks usage is the moment a
         // usage-switched self-review debt should be visible. Best-effort — never breaks the contract.
         try {
@@ -8385,6 +8635,55 @@ async function cmdBacklog(options, flags, cwd, write) {
             write('  (dry-run — nothing written; re-run without --dry-run to apply)');
         return report.ok ? 0 : 1;
     }
+    // ── edit — replace/extend ONE idea's text (idea 1fde7bf6). The verb exists because a hand-edit
+    // does not re-embed: the dedup vector keeps describing the OLD text. editIdea owns the text change
+    // and MARKS the record embedStale; this layer owns the async re-embed and clears the mark ONLY
+    // after the vector tier confirms. A failed re-embed is loud here AND enforced at the harm point:
+    // classifyDedup refuses vector candidacy for a marked record (ADR-001).
+    if (sub === 'edit') {
+        const id = options.get('_positional_1');
+        if (id === undefined)
+            return emitErr('an idea id is required: dz backlog edit <id> --text "<new>" | --append "<more>" [--dry-run]');
+        const report = editIdea(projectRoot, id, {
+            ...(options.get('text') !== undefined ? { text: options.get('text') } : {}),
+            ...(options.get('append') !== undefined ? { append: options.get('append') } : {}),
+            dryRun: flags.has('dry-run'),
+        });
+        let embed = 'skipped';
+        if (report.ok && report.written && report.id !== undefined) {
+            const updated = readIdeas(projectRoot).find((i) => i.id === report.id);
+            if (updated !== undefined) {
+                const mirror = await mirrorIdeaVector(projectRoot, updated);
+                if (mirror.mirrored > 0 && mirror.error === undefined && clearEmbedStale(projectRoot, report.id))
+                    embed = 'ok';
+                else
+                    embed = 'stale';
+            }
+            else
+                embed = 'stale';
+        }
+        if (json) {
+            write(JSON.stringify({ verb: 'edit', ...report, embed, exitCode: report.ok ? (embed === 'stale' ? 1 : 0) : 1 }, null, 2));
+            return report.ok ? (embed === 'stale' ? 1 : 0) : 1;
+        }
+        for (const e of report.errors)
+            write(`dz backlog edit: ${e}`);
+        if (report.ok && report.id !== undefined) {
+            if (!report.written && !report.dryRun)
+                write(`dz backlog edit: ${report.id} — text unchanged, nothing to do`);
+            else
+                write(`dz backlog edit${report.dryRun ? ' (dry-run)' : ''}: ${report.id}\n  was: ${report.previousText?.slice(0, 100)}\n  now: ${report.newText?.slice(0, 100)}`);
+            if (report.written) {
+                if (embed === 'ok')
+                    write('  vector re-embedded (dedup form) — the record is fully consistent');
+                else
+                    write('  ⚠ vector NOT re-embedded — the record is MARKED embedStale: dedup will refuse to trust its similarity until `dz vector reindex` repairs it (the text edit itself landed)');
+            }
+            if (report.dryRun)
+                write('  (dry-run — nothing written; re-run without --dry-run to apply)');
+        }
+        return report.ok ? (embed === 'stale' ? 1 : 0) : 1;
+    }
     if (sub === 'enrich') {
         const id = options.get('_positional_1');
         if (id === undefined)
@@ -8486,6 +8785,68 @@ function cmdRouting(options, flags, cwd, write) {
         repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd;
     }
     catch { /* not git */ }
+    // ── recommend — harvest real telemetry, print per-stage picks WITH THE BASIS, optionally feed the
+    // store (a9c3dd5c fn 3, ADR-001). Sources: live harness records + imported run-meta.json sidecars.
+    if (options.get('_positional_0') === 'recommend') {
+        const records = readHarnessRecords(repoRoot);
+        // imported runs (trace-bundle ADR-001 D4): run-meta sidecars carry runMeta.records of the SAME shape
+        for (const base of [join(repoRoot, 'features'), join(repoRoot, '.dz', 'loop-trace')]) {
+            if (!existsSync(base))
+                continue;
+            let names = [];
+            try {
+                names = readdirSync(base);
+            }
+            catch {
+                continue;
+            }
+            for (const name of names) {
+                const sidecar = join(base, name, 'run-meta.json');
+                if (!existsSync(sidecar))
+                    continue;
+                try {
+                    const meta = JSON.parse(readFileSync(sidecar, 'utf-8'));
+                    if (meta.runMeta?.resolved === true && Array.isArray(meta.runMeta.records))
+                        records.push(...meta.runMeta.records);
+                }
+                catch { /* an unreadable sidecar contributes nothing — counted below as noResult */ }
+            }
+        }
+        const harvest = harvestStageOutcomes(records);
+        const rec = recommendModels(harvest, { ...(options.get('tier') !== undefined ? { tier: options.get('tier') } : {}) });
+        if (flags.has('apply')) {
+            const fedPath = join(repoRoot, '.dz', 'routing-fed.json');
+            let alreadyFed = [];
+            try {
+                alreadyFed = JSON.parse(readFileSync(fedPath, 'utf-8'));
+            }
+            catch { /* first apply */ }
+            const plan = planFeed(harvest.samples, alreadyFed);
+            for (const sample of plan.toFeed)
+                finalizeOutcome(repoRoot, sample.stage, sample.tier, sample.model, sample.success);
+            try {
+                mkdirSync(join(repoRoot, '.dz'), { recursive: true });
+                writeFileSync(fedPath, JSON.stringify(plan.fedAfter));
+            }
+            catch (e) {
+                write(`dz routing recommend: fed ${plan.toFeed.length} sample(s) but could NOT persist the fed-set — a re-apply WILL double-count: ${e.message}`);
+                return 1;
+            }
+            write(`dz routing recommend --apply: fed ${plan.toFeed.length} sample(s) into .dz/routing-outcomes.json${plan.skippedRuns.length > 0 ? `; skipped ${plan.skippedRuns.length} already-fed run(s) (idempotent by runId)` : ''}`);
+        }
+        if (flags.has('json')) {
+            write(JSON.stringify({ recommendation: rec, exitCode: 0 }, null, 2));
+            return 0;
+        }
+        write(`dz routing recommend — args.models suggestion from ${rec.basis.runsUsed} run(s)${rec.basis.window !== null ? ` (${rec.basis.window.min.slice(0, 10)}..${rec.basis.window.max.slice(0, 10)})` : ''}:`);
+        for (const s of rec.perStage) {
+            write(`  ${s.stage.padEnd(14)} ${s.spec.padEnd(20)} ${s.insufficientData ? '[insufficient data — cold-start pick]' : '[quality bar met]'} ${s.pick.evidence}`);
+        }
+        write(`  basis: ${rec.basis.rule}`);
+        write(`  basis: skipped records — no result ${rec.basis.skipped.noResult}, no modelsUsed ${rec.basis.skipped.noModels} (predates model routing — history, not an error), no grade ${rec.basis.skipped.noGrade}, unknown model ${rec.basis.skipped.unknownModel}`);
+        write(`  basis: ${rec.basis.crossFamilyNote}`);
+        return 0;
+    }
     const stage = options.get('stage');
     const tier = options.get('tier');
     const model = options.get('model');