@dzhechkov/harness-cli 0.3.253 → 0.3.254

package/.dz-manifest.json

@@ -9,7 +9,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "d4275f137eadedaba625b8e05918b343db87288811f37d7b31ef6d5688935906"
+        "sha256": "fc57c105e5031d2d6751ef08b64769dc463cd79c5cf7637b48bc8cb7190e5b3a"
       },
       {
         "path": "coverage/coverage-final.json",
@@ -41,15 +41,15 @@
       },
       {
         "path": "dist/cli.d.ts.map",
-        "sha256": "c9b415287eda0a7c2ad32dbb7cfc3ecce19aa3b90c96d3fbeedd62d20fe34bc7"
+        "sha256": "4268f56e38f72625c2c490add4b17ee12d7ff7db991a2090f426afbb026b98a9"
       },
       {
         "path": "dist/cli.js",
-        "sha256": "56b4da2639c1721180387f28166d84d065718a4002f556307a6598570d335809"
+        "sha256": "fe24568930cc226e0bad8b4ccba559e2f837bb4cb068c2cc37750b5a10c27a70"
       },
       {
         "path": "dist/cli.js.map",
-        "sha256": "4a172ba5384c9716fa48570979b7ffba969599ed5c639d7e7268a829d2b9b4e1"
+        "sha256": "4a0b554fab78cd50fc46cff653411b2003b7dd9a4df1b16af6e9f5a0e24379ff"
       },
       {
         "path": "dist/index.d.ts",
@@ -73,7 +73,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "6c0a974541d458977c4606f21fa230f12c300a999bf7ef2cd5b5dae3de83b617"
+        "sha256": "c6469d0f7539ce6c0a8176d0b795952a667df2b975c9f93c66e7cd6eba843383"
       },
       {
         "path": "src/bin.ts",
@@ -81,7 +81,7 @@
       },
       {
         "path": "src/cli.ts",
-        "sha256": "1aceceef391cac55d00f7872632d28c4116a82025b9235343b81398fc515f944"
+        "sha256": "13d3946992186e019310c1c8666fd724ce74880b8fda19850eeb8b6e0399e3d7"
       },
       {
         "path": "src/index.ts",
@@ -91,6 +91,10 @@
         "path": "test/cli.test.ts",
         "sha256": "7d6ba26ec1188db3b3ac89f50b015ba1f0c6117b5c30d99b22da41da10c96c12"
       },
+      {
+        "path": "test/epoch-replay-cli.test.ts",
+        "sha256": "a5a48585b565288ca1ea96030b02b2ccb37a621ef7b3cfe54cd7aaa7164d6904"
+      },
       {
         "path": "tsconfig.json",
         "sha256": "e80ef2911c3347a713dc3dca6a5f6034d91e938e58e71345ea920dd9833bcdbb"
@@ -101,5 +105,5 @@
       }
     ]
   },
-  "signature": "Z1iFk6oNIUD/wUDtCYcGGumn9HbL/wmzeljhrrYhWV7p5sXFpMXImxLq2p1s8F04rbV1nCNeIKq7sZ68YARTAg=="
+  "signature": "lRzsYJCin4HX25rutyyh0Veo7d29P+AOTtJyKdgPcBrzIY44kdm7AHYRYCKcTrH5esXg8nVfhxd1Uw74PjtZAg=="
 }

package/README.md

@@ -132,7 +132,7 @@ point any tool at (a skill is just Markdown). Dedicated targets are on the [road
 
 ## User Journey — from install to mastery
 
-All 61 commands mapped to a real workflow:
+All 62 commands mapped to a real workflow:
 
 ```
 DISCOVER → INSTALL → USE → CREATE → MAINTAIN → SHARE
@@ -236,6 +236,11 @@ dz workflow --task security-audit               # adversarial security scan
 
 # Cross-host state sync:
 dz roam --apply                                 # sync agent state across machines
+
+# Is the self-learning loop actually paying off?
+dz compounding                                  # readiness + payoff report (INSUFFICIENT_DATA is a real answer)
+dz epoch-replay --mock --n 24 --effect 0.9      # $0 dry run of the cold-vs-warm verdict math
+dz epoch-replay --emit                          # ready? emit the real cold-vs-warm work order
 ```
 
 ### Phase 6: Share (publish to the world)
@@ -464,6 +469,98 @@ The prompt queries that make replay possible stay on your machine: `.dz/recall-u
 git-ignored, entries are truncated at 200 chars and flagged when truncated (a prefix is not a prompt,
 so flagged rows never count as replayable).
 
+### Did the lessons actually change outcomes? — `dz epoch-replay`
+
+`dz compounding` says a cold-vs-warm replay **can** be run. `dz epoch-replay` **runs** it and reports
+what it found: Epoch 0 (cold — the prompt alone) vs Epoch 1 (warm — the same prompt plus exactly the
+lessons the apply leg injected), on the same instances, scored into a three-valued verdict.
+
+**The test is PAIRED.** Each instance is one judgment on one prompt, so the statistic is a single
+binomial over *decisive* pairs: `p̂ = warm wins / (warm wins + cold wins)`, with a `95%` Wilson
+interval reported on the **lift** scale `2p̂ − 1`. Ties carry no direction — they are excluded from
+the denominator and reported separately.
+
+**`SUPPORTED` only when the lift interval lies entirely above zero.** `FALSIFIED` only on **harm**
+(entirely below zero) or on a passed **non-superiority** test — the lift upper bound below a
+pre-registered margin, default `0.05`, at 10+ decisive pairs. Everything else is `INCONCLUSIVE`, a
+first-class honest outcome; below 5 decisive pairs there is no verdict at all.
+
+**A tie is under-powered, not refuted.** `6/12` gives a lift interval of `[-0.492, 0.492]` — that
+excludes nothing, so it reads `INCONCLUSIVE`. So does a *perfectly* even 500/500 over 1000 pairs
+(lift upper `0.0619`): the most uninformative result the protocol can produce must not be reported
+as a refutation. A refutation has to clear a bar too.
+
+**Try it at $0 first — `--mock` generates seeded synthetic outcomes at a TRUE effect you choose, and
+runs them through the real verdict math:**
+
+```
+$ dz epoch-replay --mock --n 24 --effect 0.9 --seed 20260729
+  COLD (epoch 0, no injected lessons): 1/24   CI95 [0.007, 0.202]
+  WARM (epoch 1, apply-leg lessons):   23/24  CI95 [0.798, 0.993]
+  VERDICT: SUPPORTED
+    warm 23/24 CI [0.798, 0.993] is DISJOINT above cold 1/24 CI [0.007, 0.202]
+
+$ dz epoch-replay --mock --n 24 --effect -0.9 --seed 20260729   # → FALSIFIED (harm)
+$ dz epoch-replay --mock --n 24 --effect 0.4  --seed 20260729   # → INCONCLUSIVE (neither separates nor excludes)
+$ dz epoch-replay --mock --n 12 --effect 0    --seed 7          # → INCONCLUSIVE (6/6 tie: under-powered, NOT refuted)
+```
+
+```
+$ dz epoch-replay --mock --n 24 --effect 0.9 --seed 20260729
+  SLICE: all · 24 scored instance(s) · 24 DECISIVE pair(s)
+  COLD (epoch 0, no injected lessons): 1/24 decisive   CI95 [0.007, 0.202]
+  WARM (epoch 1, apply-leg lessons):   23/24 decisive  CI95 [0.798, 0.993]
+  LIFT (paired, 2p−1 over decisive pairs): +0.917  [0.595, 0.985]
+  VERDICT: SUPPORTED — the lift interval lies ENTIRELY above zero
+```
+
+Every mock run prints `SYNTHETIC … it is NOT evidence about the learning loop`, and the same seed
+gives byte-identical output — a demo is a reproducer.
+
+**Real mode: the runner ORCHESTRATES and SCORES — it never calls a model.** Generation and judging
+happen out of band, so the core stays pure, offline and reproducible:
+
+```
+$ dz epoch-replay --emit                   # → .dz/epoch-replay/work-order.json  (git-ignored: raw prompts)
+     25 instance(s) · seed 20260729 · blind A/B assignment PRE-REGISTERED
+  # 1. have an agent fill coldPlan / warmPlan for each item (symmetric length, same task)
+$ dz epoch-replay --judge .dz/epoch-replay/work-order.json     # → blind judge prompts
+  # 2. have an EXTERNAL, cross-model judge answer them → [{ "id": …, "winner": "A|B|TIE" }]
+$ dz epoch-replay --score judgments.json --work-order .dz/epoch-replay/work-order.json --slice task
+```
+
+Three things make that blind real rather than decorative:
+
+- **The judge sees `{id, prompt}` and nothing else.** No assignment, no arm names, no slice label,
+  not even a path back to the work order. The judge file is byte-identical whichever way the
+  assignment fell, so it cannot be decoded. (Skipped items are reported on stdout, not in the file —
+  their reasons name arms.)
+- **The work order is integrity-checked.** It carries a sha256 digest over its pre-registered core
+  (version, seed, margin, corpus fingerprint, every `[id, warmIsA]`); `--judge` and `--score`
+  recompute it *and* re-derive every assignment from the stated seed, refusing on any mismatch. A
+  hand-written order does not buy a verdict.
+  > **Honest scope:** this is an integrity check against accidental corruption and mismatch — **not
+  > a cryptographic commitment.** The hash is self-contained, so a determined operator can re-forge
+  > it (seed-searching a matching assignment at n=12 takes a few thousand tries). The threat model
+  > is *you making a mistake*: a hand-edited file, a stale order paired with fresh judgments. The
+  > honest-use contract is procedural — emit once, then judge, and keep the emitted file. `--emit`
+  > records `emittedAt` + a corpus fingerprint and `--score` prints the digest, seed and margin, so
+  > a reviewer can ask for the original and compare three numbers.
+- **The non-superiority margin is pre-registered.** `--margin` is accepted only at `--emit`, is
+  stored in the work order and covered by the digest, and `--score` **refuses** a `--margin` flag —
+  a margin chosen once you can see the counts is not a pre-registration, and `--margin 99` at
+  scoring time would simply buy `FALSIFIED`. Out of range (outside `(0, 0.5]`) is refused, not
+  clamped.
+- **Corrupt input is refused, not measured.** Duplicate judgement ids exit 1 rather than counting
+  one opinion N times. Unknown ids and unparseable winners are skipped **with a reason**, never
+  guessed.
+
+The warm arm's only delta is the injected lessons: no gold answers, no verdicts, no outcome labels
+ever enter a work order.
+
+**When to use:** after `dz compounding` reports the replay as READY; before claiming that recall
+"works"; and any time you want the claim re-checked as the corpus grows.
+
 ### Usage estimates you can act on — `dz usage`
 
 `dz usage` estimates how much of your Claude session (5h block) and week you have spent, from local
@@ -726,7 +823,7 @@ Get the whole set with `dz init --target claude-code --preset meta`, or pick one
 
 > **A skill and its npx toolkit are not duplicates — they're a graduation.** Several skills (e.g. `feature-adr`, `design-thinking`) exist BOTH as a skill inside a `dz` preset AND as a standalone `npx` package. The preset's SKILL.md is **fully functional on its own** (the whole methodology — modules + references — travels with it, and it auto-activates by description), and it's the only way to compile that capability to the **non-Claude platforms** (Codex/OpenCode/Hermes/OpenClaude) via `dz`. The npx package adds **project-level runtime governance** around the same skill: a slash command, governance rules, a context shard, and (for feature-adr) reward-learning + `/harvest`. So: pick the **skill/preset** for a working capability across platforms; pick the **npx toolkit** when you want it as a governed, command-driven fixture of one project.
 
-## All Commands (61)
+## All Commands (62)
 
 ```
 dz setup             --target <name> [--preset <name>] [--select id,id,...] [--skills-dir <dir>] [--memory agentdb] [--no-memory] [--no-hooks] [--install-driver] [--force]
@@ -784,6 +881,10 @@ dz discrimination-check --test <f[,f]> [--base <ref>] [--name <filter>] [--runne
 dz delivery-check --slug <slug> [--context-only] [--findings <f.json>] [--strict] [--author <model>] [--json]   # portable Step-10 Delivery Gate: the `manual` form that travels to every shell target — prints the 4-plane review brief (regressions ‖ security ‖ code-quality ‖ product-honesty) + artifact probes; --findings classifies a fed-back review into a fail-closed ready|blocked hand-off (only cross-validated BLOCKER/HIGH count) and writes features/<slug>/10_delivery_review.md; --strict exits 1 on blocked
 dz skills-verify     [--dir <project>] [--expect a,b] [--static] [--strict] [--timeout <s>] [--json]   # does .claude/skills/ actually REGISTER? --static = instant layout scan (CI-safe, no session): flags dirs that can never register; default also starts a real session and reads the authoritative system/init listing. exit 0 pass / 1 fail / 2 inconclusive — an unobservable registration is NEVER a pass
 dz compounding       [--project <dir>] [--json]   # honest learning-loop payoff report: pool write-only ratio, guard repeat-violation trajectory (rate per audit-half), cold-vs-warm replay readiness over unique untruncated prompt events, apply-leg staleness — a gate without enough data says INSUFFICIENT_DATA, never a verdict
+dz epoch-replay --mock  [--n <N>] [--effect <-1..1>] [--tie-rate <0..1>] [--seed <N>] [--slice <name>] [--margin <0..0.5>] [--json]   # $0 synthetic run through the REAL verdict math; labelled SYNTHETIC, same seed = byte-identical
+dz epoch-replay --emit  [--project <dir>] [--limit <N>] [--seed <N>] [--margin <0..0.5>] [--out <file>] [--json]   # cold-vs-warm work order: replayable instances + PRE-REGISTERED blind A/B assignment + the PRE-REGISTERED non-superiority margin + a sha256 integrity digest + emittedAt/corpus fingerprint (raw prompts — defaults into the git-ignored .dz/epoch-replay/)
+dz epoch-replay --judge <filled-work-order.json> [--out <file>] [--json]   # blind judge prompts from the filled plans — the file carries {id, prompt} ONLY (no assignment, no arm names); refuses an order whose digest or seed-derived assignment does not check out; half-pairs skipped WITH A REASON, on stdout
+dz epoch-replay --score <judgments.json> --work-order <file> [--slice <name>] [--json]   # un-blind against the VERIFIED pre-registered assignment; ONE paired binomial over DECISIVE pairs (ties excluded, reported) → SUPPORTED only when the lift interval (2p−1) lies entirely above zero; FALSIFIED only on harm or a passed non-superiority test (lift upper bound below the margin PRE-REGISTERED in the work order, default 0.05, at 10+ decisive pairs); else INCONCLUSIVE (min 5 decisive pairs). Refuses a forged work order, a --margin flag, or duplicate judgement ids; the verdict is data, not an exit code
 dz score             --slug <feature> [--project <dir>] [--json]   # process scorecard for ONE feature-adr run, from its artifacts: ADR confirmation, discrimination proof, cross-model QE grade, live verification, README-first, learning loop, amendments — DESCRIPTIVE-ONLY (a low score exits 0); evidence lines are shown so the reader judges the heuristics
 dz backlog <sub>     add "<idea>" | list | show <id> | goals [--validate] | roulette [--seed n] [--commit <id>] | enrich <id> | jira <id> | harmonize [--apply]   # brain-backed idea backlog: capture an idea → semantic dedup against past ideas/features via the REUSED agentdb vector engine (DUPLICATE≥0.92 / RELATED / NEW) + GoalMap alignment ("map+compass") → weighted seeded roulette picks one to work on → enrich STAGES an idea2prd hand-off → jira writes an auditable outbox via a configurable MCP adapter seam (jira-mcp|copilot-mcp|none). No 2nd vector store; without agentdb it degrades to exact-text dedup (honest)
 dz sign --init --out <path>  |  --pack <dir> --key <path>   # --init: generate the Ed25519 keypair (private OUTSIDE the repo, prints the public key for keys/dz.pub); else sign a pack's manifest + CycloneDX SBOM

package/dist/cli.d.ts.map

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

package/dist/cli.js

@@ -9,7 +9,9 @@ import { fileURLToPath } from 'node:url';
 import { execSync, spawn } from 'node:child_process';
 import { homedir, tmpdir } from 'node:os';
 import { createRequire } from 'node:module';
-import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, 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_NAMES, 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, 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, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, generateSigningKeypair, evaluateGuard, resolveRules, auditRecord, guardExitCode, DEFAULT_RULES, parsePnpmLockImporters, 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, scoreRun, renderScorecard, renderCompoundingReport, readReinforcementState, readQuarantineState, registrationExitCode, renderRegistrationReport, 
+import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, 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_NAMES, 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, 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, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, generateSigningKeypair, evaluateGuard, resolveRules, auditRecord, guardExitCode, DEFAULT_RULES, parsePnpmLockImporters, 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, 
+// Cold-vs-warm EPOCH RUNNER (feature epoch-replay) — orchestrates + scores, never calls a model.
+replayableInstances, buildWorkOrder, buildJudgePrompts, unblindJudgments, verifyWorkOrder, isValidMargin, DIGEST_HONEST_SCOPE, scoreEpochReplay, generateMockOutcomes, renderEpochReplayResult, renderWorkOrderSummary, renderJudgePromptsSummary, WORK_ORDER_KIND, DEFAULT_MOCK_N, DEFAULT_MOCK_SEED, scoreRun, renderScorecard, renderCompoundingReport, readReinforcementState, readQuarantineState, registrationExitCode, renderRegistrationReport, 
 // Smart Backlog (feature smart-backlog) — goal-directed idea pipeline over the Brain vector engine.
 readBacklogConfig, readIdeas, writeIdeas, ideaId, dedupIdea, readGoalMap, readGoalMapDetailed, parseEffort, ensureBacklogGitignored, isSafeId, alignIdea, mirrorIdeaVector, snapshotIdeas, spinRoulette, rankRoulette, seededRng, eligibleIdeas, stageEnrichment, buildJiraDraft, resolveJiraAdapter, makeBacklogIO, harmonizeBacklog, BACKLOG_BACKENDS, } from '@dzhechkov/harness-core';
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
@@ -39,6 +41,10 @@ Usage:
   dz delivery-check --slug <slug> [--context-only] [--findings <f.json>] [--strict] [--author <model>] [--json]   (portable Step-10 Delivery Gate: prints the 4-plane review brief + artifact probes; --findings classifies a fed-back review into a fail-closed ready|blocked hand-off and writes features/<slug>/10_delivery_review.md; --strict exits 1 on blocked)
   dz skills-verify [--dir <project>] [--expect a,b] [--static] [--strict] [--json]   (does .claude/skills/ actually REGISTER? --static = instant layout scan for CI; default reads the authoritative system/init listing from a real session. exit 0 pass / 1 fail / 2 inconclusive — never a false pass)
   dz compounding [--project <dir>] [--json]   (honest learning-loop payoff report: pool write-only ratio, guard repeat-violation trajectory, cold-vs-warm replay readiness, instrumentation health — a gate without enough data says INSUFFICIENT_DATA, never a fake verdict)
+  dz epoch-replay --mock [--n <N>] [--effect <-1..1>] [--tie-rate <0..1>] [--seed <N>] [--slice <name>] [--json]   ($0 synthetic run — exercises the verdict math, NOT evidence)
+  dz epoch-replay --emit [--project <dir>] [--limit <N>] [--seed <N>] [--out <file>]   (cold-vs-warm work order: instances + PRE-REGISTERED blind A/B assignment; the runner never calls a model)
+  dz epoch-replay --judge <filled-work-order.json> [--out <file>]   (blind judge prompts from the filled plans)
+  dz epoch-replay --score <judgments.json> --work-order <file> [--slice <name>] [--json]   (un-blind against the pre-registered assignment → SUPPORTED only when the two 95% Wilson CIs are DISJOINT, else FALSIFIED / INCONCLUSIVE)
   dz score --slug <feature> [--project <dir>] [--json]   (process scorecard for ONE feature-adr run, from its artifacts: ADR confirmation, discrimination, cross-model QE grade, live verification, README-first, learning loop, amendments — descriptive-only, a low score exits 0)
   dz backlog add "<idea>" [--effort 1-5] [--proposal <text>] [--dry-run] [--project <dir>] [--json]   (capture an idea: semantic dedup against existing ideas via the Brain vector engine (DUPLICATE>=0.92 merges, RELATED links, NEW creates) + GoalMap alignment; --dry-run classifies without writing)
   dz backlog list [--status <s>] [--goal <id>] [--project <dir>] [--json]   (list captured ideas, filterable by status/goal)
@@ -5495,6 +5501,46 @@ function cmdScore(options, flags, cwd, write) {
         write(renderScorecard(card));
     return 0;
 }
+/**
+ * Read the apply-leg usage log into the shape `compounding.ts` / `epoch-replay.ts` expect.
+ *
+ * ONE reader, because there were two and they disagreed: the `dz compounding` fact-gatherer used
+ * to drop `eventId` and `queryTruncated`, so the readiness gate counted 48 "replayable pairs" over
+ * a log whose honest count is 25 (MEASURED on this repo, 2026-07-29). Both defences documented in
+ * `assembleCompoundingReport` — "one prompt = one pair" (Codex #1) and "a truncated query is a
+ * prefix, not the prompt" (Codex #3) — were correct in the pure function and DEAD at its only
+ * caller, because the caller never passed the fields they read.
+ */
+function readRecallUsageEvents(root) {
+    const usage = [];
+    try {
+        const text = readFileSync(join(root, '.dz', 'recall-usage.jsonl'), 'utf-8');
+        for (const line of text.split('\n')) {
+            if (line.trim() === '')
+                continue;
+            try {
+                const o = JSON.parse(line);
+                if (typeof o.dzId === 'string' && typeof o.ts === 'string' && o.kind !== 'aggregate') {
+                    usage.push({
+                        dzId: o.dzId,
+                        ts: o.ts,
+                        ...(typeof o.query === 'string' ? { query: o.query } : {}),
+                        ...(typeof o.runId === 'string' ? { runId: o.runId } : {}),
+                        ...(typeof o.eventId === 'string' ? { eventId: o.eventId } : {}),
+                        ...(o.queryTruncated === true ? { queryTruncated: true } : {}),
+                    });
+                }
+            }
+            catch {
+                /* one bad line must not kill the read */
+            }
+        }
+    }
+    catch {
+        /* no log yet — callers report the absence */
+    }
+    return usage;
+}
 /**
  * `dz compounding` — does the learning loop actually PAY? (feature compounding, scout C2.)
  * Gathers the facts (store rows, apply-leg usage log, guard audit) and hands them to the PURE
@@ -5532,31 +5578,7 @@ function cmdCompounding(options, flags, cwd, write) {
         reward: typeof r.score === 'number' ? r.score : null,
     }));
     // apply-leg usage events (read records only; aggregate rows carry no query by construction)
-    const usage = [];
-    try {
-        const text = readFileSync(join(root, '.dz', 'recall-usage.jsonl'), 'utf-8');
-        for (const line of text.split('\n')) {
-            if (line.trim() === '')
-                continue;
-            try {
-                const o = JSON.parse(line);
-                if (typeof o.dzId === 'string' && typeof o.ts === 'string' && o.kind !== 'aggregate') {
-                    usage.push({
-                        dzId: o.dzId,
-                        ts: o.ts,
-                        ...(typeof o.query === 'string' ? { query: o.query } : {}),
-                        ...(typeof o.runId === 'string' ? { runId: o.runId } : {}),
-                    });
-                }
-            }
-            catch {
-                /* one bad line must not kill the report */
-            }
-        }
-    }
-    catch {
-        /* no log yet — the report says so */
-    }
+    const usage = readRecallUsageEvents(root);
     // guard audit events
     const guard = [];
     try {
@@ -5589,6 +5611,307 @@ function cmdCompounding(options, flags, cwd, write) {
         write(renderCompoundingReport(report));
     return 0;
 }
+// ── `dz epoch-replay` (feature epoch-replay) ────────────────────────────────────────────────────
+const EPOCH_REPLAY_DIR = join('.dz', 'epoch-replay');
+const EPOCH_REPLAY_USAGE = [
+    'dz epoch-replay --mock  [--n <N>] [--effect <-1..1>] [--tie-rate <0..1>] [--seed <N>] [--slice <name>] [--margin <0..1>] [--json]',
+    'dz epoch-replay --emit  [--project <dir>] [--limit <N>] [--seed <N>] [--margin <0..0.5>] [--out <file>] [--json]',
+    'dz epoch-replay --judge <filled-work-order.json> [--out <file>] [--json]',
+    'dz epoch-replay --score <judgments.json> --work-order <file> [--slice <name>] [--json]   (margin comes from the work order)',
+].join('\n  ');
+/** Read a JSON file into an object, or return a parse/IO error string. */
+function readJsonFile(path) {
+    try {
+        return { value: JSON.parse(readFileSync(path, 'utf-8')) };
+    }
+    catch (e) {
+        return { error: `cannot read ${path}: ${e instanceof Error ? e.message : String(e)}` };
+    }
+}
+/**
+ * Integrity-check a parsed work order. Checking `kind` + `Array.isArray(items)` was VACUOUS: a
+ * hand-written file with those two fields and a fabricated `warmIsA` bought whatever verdict its
+ * author wanted (Codex QE HIGH-2). `verifyWorkOrder` recomputes the digest AND re-derives every
+ * assignment from the stated seed.
+ */
+function asVerifiedWorkOrder(value) {
+    const v = verifyWorkOrder(value);
+    if (!v.ok)
+        return { problems: v.problems };
+    return { order: value };
+}
+function writeJsonOut(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+/** Numeric option parsing that never silently accepts garbage. */
+function numOpt(options, key) {
+    const raw = options.get(key);
+    if (raw === undefined)
+        return null;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return { error: `--${key} expects a finite number, got ${JSON.stringify(raw)}` };
+    return { value: n };
+}
+/**
+ * `dz epoch-replay` — the executable cold-vs-warm epoch runner (feature epoch-replay, scout #4).
+ *
+ * `dz compounding` says whether a replay CAN be run; this says what it FOUND. The runner never
+ * calls a model: real mode emits a work order, renders blind judge prompts, and scores filled
+ * judgments; `--mock` exercises the same verdict math on seeded synthetic outcomes at $0.
+ */
+function cmdEpochReplay(options, flags, cwd, write) {
+    const json = flags.has('json');
+    const fail = (msg) => {
+        write(json ? JSON.stringify({ error: msg, exitCode: 1 }) : `dz epoch-replay: ${msg}\n  usage:\n  ${EPOCH_REPLAY_USAGE}`);
+        return 1;
+    };
+    if (flags.has('help')) {
+        write(`dz epoch-replay — cold (epoch 0) vs warm (epoch 1), Wilson-CI three-valued verdict\n  ${EPOCH_REPLAY_USAGE}`);
+        write('');
+        write('  ONE binomial over DECISIVE pairs (ties carry no direction and are excluded from the test).');
+        write('  SUPPORTED only when the paired lift interval lies ENTIRELY above zero.');
+        write('  FALSIFIED only on HARM (entirely below zero), or on a passed NON-SUPERIORITY test (the');
+        write('  lift upper bound below the PRE-REGISTERED margin, default 0.05). Otherwise INCONCLUSIVE —');
+        write('  a first-class honest outcome; a tie is UNDER-POWERED, never "refuted".');
+        write('  The margin is pre-registered at --emit and stored in the work order; --score reads it there.');
+        write('  This runner ORCHESTRATES and SCORES; it never calls a model. The judge-facing file holds');
+        write('  {id, prompt} and nothing else; --score refuses any work order whose digest or seed-derived');
+        write('  assignment does not check out, and refuses duplicate judgement ids.');
+        return 0;
+    }
+    const allowedFlags = new Set(['mock', 'emit', 'json', 'help']);
+    for (const flag of flags) {
+        if (!allowedFlags.has(flag))
+            return fail(`unknown option --${flag}`);
+    }
+    const allowedOptions = new Set(['judge', 'score', 'work-order', 'project', 'out', 'n', 'effect', 'tie-rate', 'seed', 'slice', 'limit', 'margin']);
+    for (const key of options.keys()) {
+        if (key.startsWith('_positional_'))
+            return fail(`unexpected argument "${options.get(key)}"`);
+        if (!allowedOptions.has(key))
+            return fail(`unknown option --${key}`);
+    }
+    // Exactly ONE mode. A command whose default mode is a report can silently swallow a typo'd mode
+    // flag and print something that reads like a result — so there is NO default mode here.
+    const modes = [
+        flags.has('mock') ? 'mock' : null,
+        flags.has('emit') ? 'emit' : null,
+        options.has('judge') ? 'judge' : null,
+        options.has('score') ? 'score' : null,
+    ].filter((m) => m !== null);
+    if (modes.length === 0)
+        return fail('pick exactly one mode: --mock | --emit | --judge <file> | --score <file>');
+    if (modes.length > 1)
+        return fail(`modes are exclusive, got: ${modes.join(', ')}`);
+    const mode = modes[0];
+    const num = (key) => {
+        const r = numOpt(options, key);
+        if (r === null)
+            return undefined;
+        if ('error' in r)
+            return r;
+        return r.value;
+    };
+    // ── --mock: seeded synthetic outcomes, $0, exercises the real verdict math ──
+    if (mode === 'mock') {
+        for (const key of ['judge', 'score', 'work-order', 'project', 'out', 'limit']) {
+            if (options.has(key))
+                return fail(`--${key} is not valid with --mock`);
+        }
+        const parsed = {};
+        for (const key of ['n', 'effect', 'tie-rate', 'seed']) {
+            const v = num(key);
+            if (typeof v === 'object' && v !== null)
+                return fail(v.error);
+            parsed[key] = v;
+        }
+        const outcomes = generateMockOutcomes({
+            n: parsed.n ?? DEFAULT_MOCK_N,
+            effect: parsed.effect ?? 0,
+            tieRate: parsed['tie-rate'] ?? 0,
+            seed: parsed.seed ?? DEFAULT_MOCK_SEED,
+        });
+        const marginOpt = numOpt(options, 'margin');
+        if (marginOpt !== null && 'error' in marginOpt)
+            return fail(marginOpt.error);
+        const result = scoreEpochReplay(outcomes, {
+            slice: options.get('slice') ?? 'all',
+            ...(marginOpt !== null ? { margin: marginOpt.value } : {}),
+        });
+        if (result.refusal !== null)
+            return fail(result.refusal);
+        if (json) {
+            write(JSON.stringify({ mode: 'mock', synthetic: true, ...result, exitCode: 0 }, null, 2));
+        }
+        else {
+            write(renderEpochReplayResult(result));
+            write('');
+            write(`  SYNTHETIC (--mock): outcomes generated with seed ${parsed.seed ?? DEFAULT_MOCK_SEED} at a TRUE effect of ${parsed.effect ?? 0}. ` +
+                'This exercises the protocol, it is NOT evidence about the learning loop.');
+        }
+        return 0;
+    }
+    // ── --emit: the generation work order (real mode, stage 1) ──
+    if (mode === 'emit') {
+        for (const key of ['judge', 'score', 'work-order', 'n', 'effect', 'tie-rate', 'slice']) {
+            if (options.has(key))
+                return fail(`--${key} is not valid with --emit`);
+        }
+        const root = resolve(cwd, options.get('project') ?? '.');
+        const seed = num('seed');
+        if (typeof seed === 'object' && seed !== null)
+            return fail(seed.error);
+        const limit = num('limit');
+        if (typeof limit === 'object' && limit !== null)
+            return fail(limit.error);
+        // HIGH-B: the non-superiority margin is PRE-REGISTERED here, digest-covered, and read back by
+        // --score. Out of range is refused, never clamped — `--margin 99` must not buy FALSIFIED.
+        const emitMargin = num('margin');
+        if (typeof emitMargin === 'object' && emitMargin !== null)
+            return fail(emitMargin.error);
+        if (typeof emitMargin === 'number' && !isValidMargin(emitMargin)) {
+            return fail(`--margin ${emitMargin} must be in (0, 0.5] — refused, not clamped: an oversized margin buys FALSIFIED`);
+        }
+        const lessonText = new Map();
+        for (const r of loadStoreRecords(root)) {
+            if (typeof r.text === 'string' && r.text.trim() !== '')
+                lessonText.set(r.id, r.text);
+        }
+        // The SAME reader `dz compounding` uses — readiness and the runner must see one corpus.
+        const instances = replayableInstances(readRecallUsageEvents(root), lessonText);
+        const order = buildWorkOrder(instances, {
+            ...(typeof seed === 'number' ? { seed } : {}),
+            ...(typeof limit === 'number' ? { limit } : {}),
+            ...(typeof emitMargin === 'number' ? { margin: emitMargin } : {}),
+        });
+        const outPath = resolve(cwd, options.get('out') ?? join(root, EPOCH_REPLAY_DIR, 'work-order.json'));
+        try {
+            writeJsonOut(outPath, order);
+        }
+        catch (e) {
+            return fail(`cannot write ${outPath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        if (json) {
+            write(JSON.stringify({ mode: 'emit', out: outPath, instances: order.items.length, seed: order.seed, margin: order.margin, digest: order.digest, corpusFingerprint: order.corpusFingerprint, emittedAt: order.emittedAt, exitCode: 0 }, null, 2));
+        }
+        else
+            write(renderWorkOrderSummary(order, outPath));
+        return 0;
+    }
+    // ── --judge: blind judge prompts from a FILLED work order (real mode, stage 2) ──
+    if (mode === 'judge') {
+        for (const key of ['score', 'work-order', 'n', 'effect', 'tie-rate', 'slice', 'limit', 'seed', 'margin']) {
+            if (options.has(key))
+                return fail(`--${key} is not valid with --judge`);
+        }
+        const inPath = resolve(cwd, options.get('judge'));
+        const read = readJsonFile(inPath);
+        if ('error' in read)
+            return fail(read.error);
+        const verified = asVerifiedWorkOrder(read.value);
+        if ('problems' in verified) {
+            return fail(`${inPath} is not a verifiable ${WORK_ORDER_KIND}: ${verified.problems.join('; ')} (emit one with \`dz epoch-replay --emit\`)`);
+        }
+        const result = buildJudgePrompts(verified.order);
+        const outPath = resolve(cwd, options.get('out') ?? join(dirname(inPath), 'judge-prompts.json'));
+        try {
+            // The JUDGE-FACING artifact. Its whole content is {id, prompt} per item — no `warmIsA`, no
+            // arm names, no path back to the work order, and NOT the `skipped` list (whose reasons name
+            // arms). Anything else here hands the judge the answer key (Codex QE CRITICAL-1).
+            writeJsonOut(outPath, {
+                kind: 'dz-epoch-replay-judge-prompts',
+                version: 1,
+                prompts: result.prompts.map((p) => ({ id: p.id, prompt: p.prompt })),
+            });
+        }
+        catch (e) {
+            return fail(`cannot write ${outPath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        // `skipped` is OPERATOR-facing only — stdout / --json, never the file.
+        if (json)
+            write(JSON.stringify({ mode: 'judge', out: outPath, prompts: result.prompts.length, skipped: result.skipped, exitCode: 0 }, null, 2));
+        else
+            write(renderJudgePromptsSummary(result, outPath));
+        return 0;
+    }
+    // ── --score: un-blind + verdict (real mode, stage 3) ──
+    for (const key of ['n', 'effect', 'tie-rate', 'limit', 'seed', 'out', 'project']) {
+        if (options.has(key))
+            return fail(`--${key} is not valid with --score`);
+    }
+    // HIGH-B: a margin chosen once the counts are visible is not a pre-registration — and `--margin 99`
+    // at scoring time would simply buy FALSIFIED. Real mode reads it from the work order, full stop.
+    if (options.has('margin')) {
+        return fail('--margin is not valid with --score: the non-superiority margin is PRE-REGISTERED at --emit and stored in the work order (re-emit to change it)');
+    }
+    const orderPath = options.get('work-order');
+    if (orderPath === undefined) {
+        return fail('--score requires --work-order <file>: un-blinding must use the PRE-REGISTERED assignment, not a label in the judgments file');
+    }
+    const orderRead = readJsonFile(resolve(cwd, orderPath));
+    if ('error' in orderRead)
+        return fail(orderRead.error);
+    const verifiedOrder = asVerifiedWorkOrder(orderRead.value);
+    if ('problems' in verifiedOrder) {
+        return fail(`${resolve(cwd, orderPath)} is not a verifiable ${WORK_ORDER_KIND} — refusing to un-blind against it: ${verifiedOrder.problems.join('; ')}`);
+    }
+    const order = verifiedOrder.order;
+    const judgePath = resolve(cwd, options.get('score'));
+    const judgeRead = readJsonFile(judgePath);
+    if ('error' in judgeRead)
+        return fail(judgeRead.error);
+    const rawRows = Array.isArray(judgeRead.value)
+        ? judgeRead.value
+        : typeof judgeRead.value === 'object' && judgeRead.value !== null && Array.isArray(judgeRead.value.judgments)
+            ? judgeRead.value.judgments
+            : null;
+    if (rawRows === null)
+        return fail(`${judgePath} must be an array of {id, winner} rows (or {"judgments": [...]})`);
+    const unblind = unblindJudgments(order, rawRows.map((r) => {
+        const o = (typeof r === 'object' && r !== null ? r : {});
+        return { id: typeof o.id === 'string' ? o.id : '', winner: typeof o.winner === 'string' ? o.winner : '' };
+    }));
+    // A duplicated judgement id is corrupt input, not a skippable row — refuse loudly.
+    if (!unblind.ok)
+        return fail(unblind.error ?? 'judgments refused');
+    const { outcomes, skipped } = unblind;
+    const result = scoreEpochReplay(outcomes, {
+        slice: options.get('slice') ?? 'all',
+        margin: order.margin, // PRE-REGISTERED in the work order, verified by the digest
+    });
+    if (result.refusal !== null)
+        return fail(result.refusal);
+    if (json) {
+        write(JSON.stringify({
+            mode: 'score',
+            workOrder: resolve(cwd, orderPath),
+            judgments: judgePath,
+            scored: outcomes.length,
+            skipped,
+            provenance: { seed: order.seed, margin: order.margin, emittedAt: order.emittedAt, digest: order.digest, corpusFingerprint: order.corpusFingerprint, digestScope: DIGEST_HONEST_SCOPE },
+            ...result,
+            exitCode: 0,
+        }, null, 2));
+    }
+    else {
+        write(renderEpochReplayResult(result));
+        if (skipped.length > 0) {
+            write('');
+            write(`  ${skipped.length} judgment(s) SKIPPED (never guessed):`);
+            for (const s of skipped)
+                write(`    · ${s.id}: ${s.reason}`);
+        }
+        // Provenance, so a reviewer can ask for the original emitted file and compare.
+        write('');
+        write(`  WORK ORDER: seed ${order.seed} · margin ${order.margin} (pre-registered) · emitted ${order.emittedAt}`);
+        write(`    digest ${order.digest}`);
+        write(`    corpus ${order.corpusFingerprint}`);
+        write(`    ${DIGEST_HONEST_SCOPE}`);
+    }
+    return 0;
+}
 /**
  * Env vars an INHERITED Claude session leaks into a child. Left in place, the probe can silently
  * read the parent's project instead of the target — the exact confound that made a hand-rolled
@@ -6756,6 +7079,8 @@ export async function runCli(argv, io = {}) {
                 return cmdSkillsVerify(options, flags, cwd, write);
             case 'compounding':
                 return cmdCompounding(options, flags, cwd, write);
+            case 'epoch-replay':
+                return cmdEpochReplay(options, flags, cwd, write);
             case 'score':
                 return cmdScore(options, flags, cwd, write);
             case 'backlog':