dsh-continual-evolve 0.2.0 → 0.3.0

package/README.md

@@ -7,7 +7,7 @@
 [![CI](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml/badge.svg)](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%5E22.19%20%7C%7C%20%3E%3D24-339933)](package.json)
-[![Tests](https://img.shields.io/badge/tests-302%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-401%20passing-brightgreen)]()
 [![Status](https://img.shields.io/badge/status-all%20phases%20complete%20%C2%B7%20maintenance-ff69b4)]()
 
 Continual self-evolution for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness): a versioned, auditable, rollback-safe layer of harness state — prompt notes, memories, skills, and subagent specs — refined from session trajectories.
@@ -101,8 +101,13 @@ dsh-continual-evolve/
 │   ├── rollback.ts       # deterministic inverse-op rollback
 │   ├── plan.ts           # proposal JSON parsing (truncation-aware)
 │   ├── tool.ts           # evolve_* model-facing tools (5)
-│   ├── command.ts        # /evolve command (incl. benchmark subcommands)
+│   ├── command.ts        # /evolve command dispatcher + shared utilities
+│   ├── goal-command.ts   # /evolve goal subcommand handler
+│   ├── mount-command.ts  # /evolve mount + unmount subcommand handlers
+│   ├── benchmark-command.ts # /evolve benchmark subcommand handler
+│   ├── wrapup-command.ts # /evolve wrapup subcommand handler
 │   ├── planner.ts        # ctx.llm planner
+│   ├── llm-text.ts       # unified streaming-text helper (BlockAssembler + finish check)
 │   ├── render.ts         # bounded prompt rendering
 │   ├── inject.ts         # dynamic system-prompt section (prompt notes + delegation specs, ranked injection)
 │   ├── source.ts         # trajectory citations (sessionId + event seqs of distilled entries)
@@ -113,18 +118,21 @@ dsh-continual-evolve/
 │   ├── review.ts         # gate LLM judgment (declines local duplicates of globally covered topics)
 │   ├── approval.ts       # human approval for global edits
 │   ├── skill.ts          # skill materialization ($DSH_HOME/skills/)
+│   ├── skill-render.ts   # shared skill rendering (skillNameOf + renderSkillMarkdown, breaks circular dependency)
 │   ├── skillquality.ts   # skill standard in the loop (skill-creator template reading + frontmatter code checks)
 │   ├── mount.ts          # hot-mounted skill plugins (loader.create + boot restore)
-│   ├── benchmark.ts      # benchmark store
+│   ├── benchmark.ts      # benchmark store + CellScore types (with runtime evidence fields)
 │   ├── rubric.ts         # rubric ACL (AES-256-GCM envelopes, auto-generated local key)
 │   ├── logfile.ts        # plugin-owned file logging (JSONL exporter + rotation)
 │   ├── score.ts          # code-owned aggregation + acceptance rule
-│   ├── evaluate.ts       # two-stage evaluation runner (executor evidence → independent reviewer) + failure-cell protocol
+│   ├── evaluate.ts       # two-stage evaluation runner (executor evidence → independent reviewer) + failure-cell protocol + runtime verification
 │   ├── pool.ts           # bounded-concurrency worker pool for evaluation runs
 │   ├── store.ts          # store layout + snapshots + result history
 │   ├── service.ts        # evolution engine (onApplied hook)
-│   └── wrapup.ts         # session wrap-up lifecycle (promote / split-promote → global, guarded archive; shared proposal builders)
-└── test/                 # 23 files, 290 tests
+│   ├── usage.ts          # entry injection usage tracking (durable counts, staleness detection)
+│   ├── failures.ts       # failure-signature aggregation (gate + benchmark failures by class, /evolve failures)
+│   └── wrapup.ts         # session wrap-up lifecycle (promote / split-promote → global, guarded archive; shared proposal builders; staleness signal)
+└── test/                 # 28 files, 401 tests
 ```
 
 ## Install
@@ -152,6 +160,7 @@ Swap `web` for your profile name (`headless`, or a custom profile).
 /evolve archive <id>     hide an entry from injection (data kept, restorable)
 /evolve unarchive <id>   restore an archived entry
 /evolve log [tail N] [session <id>]  show the recent plugin log (default 50 lines; optional per-session filter)
+/evolve failures                  aggregated failure counts (review-gate + benchmark, by class — D1 observation layer)
 /evolve export <path>    backup the local store to JSON
 /evolve import <path>    restore a store from an export file
 /evolve mount <skillId>  hot-mount a skill entry as a live cordis plugin (tool: skill_<name>)
@@ -290,6 +299,10 @@ profile (optional; the file log remains the baseline that always exists).
 /evolve benchmark status <bid>                         scoreboard + decisions
 /evolve benchmark run <bid>                            evaluate current state → reference
 /evolve benchmark run <bid> candidate <refinementId>   evaluate post-refinement state → decide
+/evolve benchmark casecheck <bid>                      quality-gate check all cases
+/evolve benchmark pilot <bid> <cid>                    single pilot run for calibration
+/evolve benchmark freeze <bid> <cid>                   freeze a case as formal baseline
+/evolve benchmark meta <bid> <cid> <field> <value>     set case metadata (capability/distinguisher/shortcuts)
 ```
 
 The loop: freeze a reference score → evolve a candidate (`/evolve plan`) →
@@ -325,6 +338,9 @@ never decrypts); a rejection is recorded in the scoreboard and the
 refinement is rolled back automatically (`autoRollbackOnReject`, on by
 default).
 
+Ready-to-use seed cases are in [`examples/`](examples/) — copy-paste the
+statement and rubric to get started in under a minute.
+
 ### Real recorded run (ACCEPT)
 
 A live `dsh web` session, one case, one candidate — the first genuine
@@ -364,6 +380,8 @@ where the baseline was already perfect).
 | `autoRollbackOnReject` | `true` | after a benchmark decision rejects a candidate, roll the refinement back automatically (same engine path as `/evolve rollback` — deterministic, snapshotted, audited) |
 | `localFate` | `true` | gate local-fate dimension: the gate audits the session's local entries on its own cadence and proposes promote/archive — consulted first, never written silently (only meaningful with `autoReview`) |
 | `fateIntervalTurns` | follows `reviewIntervalTurns` | minimum turns between local-fate assessments on the turn-interval path (compaction is unconditional) |
+| `goalBlockedWrapupTurns` | `3` | D3: after this many consecutive gate runs observing the goal phase `blocked`, run one local-fate assessment (`0` disables) |
+| `reviewModel` | (agent's own) | optional model override for the review gate (cheaper model); format: `"provider/model"` or just `"model"` |
 
 Example (profile `cordis.patch.yml`):
 
@@ -388,7 +406,7 @@ pnpm lint           # oxlint src test
 
 Hit a wall? See [`docs/FAQ.md`](docs/FAQ.md) — real failure/fix records (service planes, schema DSL, structured output, gate counting, verifying prompt injection).
 
-Where we still lag behind prime-agent `/refine` and penguin-harness — and what to build next: [`docs/gap-analysis.md`](docs/gap-analysis.md) (P0 shipped: evaluator/scorer separation, failure-cell protocol; next: P1 runtime provenance checks, usage statistics, auto-decay).
+Where we still lag behind prime-agent `/refine` and penguin-harness — and what to build next: [`docs/gap-analysis.md`](docs/gap-analysis.md) (P0+P1+P2+P3 shipped: evaluator/scorer separation, failure-cell protocol, runtime provenance verification + material-drift detection, usage statistics, auto-decay, case lifecycle + quality gate, entry directory view, review model separation, blast-radius annotations, duration tracking, evolve_complete events, seed benchmark; D1 observation layer + D3 goal-blocked trigger shipped; remaining: cross-process sync on demand + D1/D2 full engineering pending experiment data).
 
 ## Roadmap
 
@@ -408,10 +426,30 @@ Where we still lag behind prime-agent `/refine` and penguin-harness — and what
 - **2026-08-17 wrap-up wave (done)**:
   - **`/evolve wrapup`** — a session's local entries get a real exit at session end: mechanical audit (local candidates + global-coverage detection; coverage judges **title similarity only** — a bare id collision with a different title is deliberately NOT coverage, and the real matching global titles are shown to the assessor) → LLM classification (`promote` / `archive` / `keep` + A-form split promotion: archive a mixed entry while promoting a cleaned durable sub-object) → deterministic guards re-checked at apply time (promote can never write a global duplicate; the symmetric archive guard requires user confirmation before an uncovered, user-sourced archive hides content; splits that duplicate a global topic drop to plain archive) → one human approval gate for every global create
   - **gate local-fate dimension** — the wrap-up machinery now runs inside the auto-review gate on its own cadence (`fateIntervalTurns`, compaction unconditional): local entries are audited, classified and partitioned while the session is still running; governed actions are consulted first (one dialog, decline cooldown), covered/operational entries archive silently, compaction applies only silent archives and defers governed actions with an audit record; every decision lands in `reviews.jsonl` and applied actions get a follow-up notice. Apply writes are shared with the wrap-up command (byte-identical proposals)
+- **2026-08-19 research-wave precursors (done)**:
+  - **goal-blocked wrap-up (D3)** — a goal stuck in `blocked` for `goalBlockedWrapupTurns` consecutive gate runs (default 3) triggers one local-fate assessment, so the blocked encounter is distilled before the session moves on; the streak resets on any non-blocked run and after each assessment, and declined proposals follow the normal fate cooldown (never nagged). Disable with `goalBlockedWrapupTurns: 0`
+  - **failure-signature aggregation (D1 observation layer)** — `/evolve failures` counts every failed review-gate record and benchmark failed cell by deterministic failure class (`rubric-decrypt` / `executor` / `reviewer` / `material-drift` / `gate` / `max-tokens` / …), the data layer a future failure-signature Refiner would route on
+  - **bootstrap-update experiment scaffold (D2)** — [`docs/experiment-bootstrap.md`](docs/experiment-bootstrap.md) designs a ≤3-round controlled experiment (fixed reference → evolve harness → candidate) to test whether a refined harness accelerates the next run; `scripts/benchmark-trend.sh` extracts the per-run trend table (overall / totalDurationMs / failed / case-hash consistency) from scoreboards
 - **2026-08-17 gap P0 (done)**:
   - **evaluator/scorer separation** — benchmark evaluation is now two-stage (gap A1): the executor performs the task and records concrete evidence without ever seeing the rubric; an independent reviewer grades that evidence against the rubric (the only branch that decrypts it). The assessed agent can no longer optimize toward or self-grade against the criteria.
   - **failure-cell protocol** — cells carry `status: ok|failed` (gap A2): failed units are excluded from every mean and counted, and the acceptance rule rejects rounds with failures beyond `maxFailedCells` (0 default) instead of averaging a zero into the mean. Scoreboard status/run surfaces failed counts and per-cell reasons.
   - **trace evidence pointer** — each cell records the executor's session id (gap A4), so a score drills back to the exact transcript that earned it
+- **2026-08-18 gap P1 (done)**:
+  - **runtime evidence verification (A3)** — cells now record actual `provider`, `model`, and `caseHash` (SHA-256 prefix of statement + rubric) written by the host, not the model; material changes between reference and candidate runs are detected and re-mark the affected candidate cells as failed (version_changed semantics, `score.flagMaterialDrift`), so a drifted round can never be accepted
+  - **entry usage statistics (B1)** — injection counts are durably tracked per entry in `<baseDir>/evolve/usage.json`; `evolve_list` shows usage counts; `zeroUsageEntries()` surfaces never-injected local entries as archive candidates
+  - **automatic staleness detection (B2)** — entries with zero injection usage AND old recency are flagged `stale` in wrap-up candidates; the LLM assessor is instructed to prefer "archive" for stale entries
+- **2026-08-18 gap P2 (done)**:
+  - **case lifecycle + quality gate (A5)** — cases follow a `draft → calibrating → frozen` state machine; `casecheck` runs mechanical quality validation (capability contract, distinguisher, shortcuts); `pilot` performs a single-run calibration; `freeze` locks a case as a formal baseline (requires quality gate pass); `meta` sets case metadata fields
+  - **entry directory view (B3)** — the injection block now includes a lightweight directory of ALL non-archived entries (id + title, one line each) when entries exceed the curated cap, giving the model a zero-cost overview
+  - **review model separation (C1)** — `reviewModel` config option lets the review gate use a cheaper model than the main agent
+  - **blast-radius annotations (C2)** — every edit now carries a `blastRadius` field (`general` / `project` / `session`); the planner is instructed to annotate it and the parser validates values
+  - **duration tracking (C3)** — each evaluation cell records `durationMs` (wall-clock time); aggregate totals and decision reports show timing comparison
+- **2026-08-18 code refactoring (done)**:
+  - **circular dependency break (P1-1)** — extracted `skill-render.ts` to decouple `skill.ts ↔ skillquality.ts`
+  - **LLM call deduplication (P1-2)** — extracted `llm-text.ts` with shared `streamText()` (~107 lines removed from review/planner/wrapup)
+  - **config type derivation (P2-1)** — `EvolveConfig` now derived from schemastery schema via `Schemastery.TypeT` (eliminated 20-line handwritten interface)
+  - **command.ts split (P2-2)** — 860-line god file split into `goal-command.ts`, `mount-command.ts`, `benchmark-command.ts`, `wrapup-command.ts`
+  - **P3 cleanups** — `questionServiceOf()` cast dedup (4 sites), dead exports removed, contradictory comments fixed
 
 The upcoming/candidates list is empty for now — future work is driven by real usage.
 

package/README.zh.md

@@ -7,7 +7,7 @@
 [![CI](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml/badge.svg)](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%5E22.19%20%7C%7C%20%3E%3D24-339933)](package.json)
-[![Tests](https://img.shields.io/badge/tests-302%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-401%20passing-brightgreen)]()
 [![Status](https://img.shields.io/badge/status-all%20phases%20complete%20%C2%B7%20maintenance-ff69b4)]()
 
 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（`dsh`）的持续自进化插件：一套**版本化、可审计、可回滚**的 harness 状态层——提示词补充、记忆、技能、子代理规格——从会话轨迹中沉淀而来。
@@ -75,8 +75,13 @@ dsh-continual-evolve/
 │   ├── rollback.ts       # 确定性逆操作回滚
 │   ├── plan.ts           # 提案 JSON 解析（截断诊断）
 │   ├── tool.ts           # evolve_* 模型工具（5 个）
-│   ├── command.ts        # /evolve 命令（含 benchmark 子命令）
+│   ├── command.ts        # /evolve 命令分发器 + 共享工具
+│   ├── goal-command.ts   # /evolve goal 子命令处理
+│   ├── mount-command.ts  # /evolve mount + unmount 子命令处理
+│   ├── benchmark-command.ts # /evolve benchmark 子命令处理
+│   ├── wrapup-command.ts # /evolve wrapup 子命令处理
 │   ├── planner.ts        # ctx.llm 规划器
+│   ├── llm-text.ts       # 统一流式文本助手（BlockAssembler + finish 检查）
 │   ├── render.ts         # 有界提示词渲染
 │   ├── inject.ts         # 动态系统提示词段（prompt 补充 + 委派规格，打分排序注入）
 │   ├── source.ts         # 轨迹引用（沉淀条目的 sessionId + 事件 seq）
@@ -87,18 +92,21 @@ dsh-continual-evolve/
 │   ├── review.ts         # 门禁 LLM 判断（拒绝 global 已覆盖主题的 local 重复沉淀）
 │   ├── approval.ts       # 全局写入人工审批
 │   ├── skill.ts          # 技能物化（$DSH_HOME/skills/）
+│   ├── skill-render.ts   # 共享技能渲染（skillNameOf + renderSkillMarkdown，打破循环依赖）
 │   ├── skillquality.ts   # 自进化环中的技能标准（skill-creator 模板读取 + frontmatter 代码校验）
 │   ├── mount.ts          # 技能热挂载插件（loader.create + 启动恢复）
-│   ├── benchmark.ts      # benchmark 存储
+│   ├── benchmark.ts      # benchmark 存储 + CellScore 类型（含运行时实证字段）
 │   ├── rubric.ts         # rubric ACL（AES-256-GCM 密文信封，自动生成本地密钥）
 │   ├── logfile.ts        # 插件自带文件日志（JSONL exporter + 轮转）
 │   ├── score.ts          # 代码所有聚合 + 接受规则
-│   ├── evaluate.ts       # 两段式评估执行器（执行者产证据 → 独立评审者评分）+ 失败格协议
+│   ├── evaluate.ts       # 两段式评估执行器（执行者产证据 → 独立评审者评分）+ 失败格协议 + 运行时实证校验
 │   ├── pool.ts           # 评估运行的有界并发工作池
 │   ├── store.ts          # store 布局 + 快照 + 结果历史
 │   ├── service.ts        # 进化引擎（onApplied 钩子）
-│   └── wrapup.ts         # 会话收尾生命周期（提升/拆解提升到 global、带守卫的归档；共享 proposal 构造器）
-└── test/                 # 23 个文件，290 个测试
+│   ├── usage.ts          # 条目注入使用率追踪（持久计数、陈旧检测）
+│   ├── failures.ts       # 失败签名聚合（门禁 + benchmark 失败按类统计，/evolve failures）
+│   └── wrapup.ts         # 会话收尾生命周期（提升/拆解提升到 global、带守卫的归档；共享 proposal 构造器；陈旧信号）
+└── test/                 # 28 个文件，401 个测试
 ```
 
 ## 安装
@@ -126,6 +134,7 @@ dsh plugin --profile web add github:ZK-Andy/dsh-continual-evolve
 /evolve archive <id>          归档条目——不再注入（数据保留，可恢复）
 /evolve unarchive <id>        恢复已归档条目
 /evolve log [tail N] [session <id>] 查看最近插件日志（默认 50 行；可加会话过滤）
+/evolve failures                  失败聚合统计（门禁 + benchmark 失败按类计数——D1 观察层）
 /evolve export <path>         备份局部 store 为 JSON
 /evolve import <path>         从导出文件恢复 store
 /evolve mount <skillId>       热挂载 skill 条目为实时 cordis 插件（工具：skill_<name>）
@@ -180,6 +189,10 @@ tail -f ~/.dsh/evolve/plugin.log          # 实时跟随
 /evolve benchmark reset <bid>                         清空计分板（重跑参考线）
 /evolve benchmark run <bid>                           评估当前状态 → 参考线
 /evolve benchmark run <bid> candidate <refinementId>  评估进化后状态 → 决策
+/evolve benchmark casecheck <bid>                     质量门禁检查所有 case
+/evolve benchmark pilot <bid> <cid>                   单次 pilot 运行（校准用）
+/evolve benchmark freeze <bid> <cid>                  冻结 case 为正式基线
+/evolve benchmark meta <bid> <cid> <field> <value>    设置 case 元数据（capability/distinguisher/shortcuts）
 ```
 
 闭环：冻结参考分 → 进化候选（`/evolve plan`）→ 用同一 case × run 矩阵复测进化后状态 → **代码所有**的接受规则只在总体均值严格提高且无 case 退化时保留候选（Self-Harness 风格）。
@@ -194,6 +207,8 @@ tail -f ~/.dsh/evolve/plugin.log          # 实时跟随
 
 聚合与决策都在 `src/score.ts`。rubric 隔离靠构造（规划器的提示词永远不含 rubric 文件、执行者分支永不解密）；拒绝会记录进 scoreboard 并自动回滚该 refinement（`autoRollbackOnReject`，默认开）。
 
+开箱即用的种子 case 在 [`examples/`](examples/)——复制粘贴 statement 和 rubric 即可在一分钟内上手。
+
 ### 真实运行记录（ACCEPT）
 
 一次真实的 `dsh web` 会话，一个 case、一个候选——第一次真正的接受：
@@ -227,6 +242,8 @@ tail -f ~/.dsh/evolve/plugin.log          # 实时跟随
 | `autoRollbackOnReject` | `true` | benchmark 决策拒绝候选后自动回滚该 refinement（与 `/evolve rollback` 同一引擎路径——确定性、快照、审计） |
 | `localFate` | `true` | 门禁 local 归宿维度：门禁按自有节奏审计本会话 local 条目并提议提升/归档——先征询、绝不静默写入（仅 `autoReview` 开启时有效） |
 | `fateIntervalTurns` | 跟随 `reviewIntervalTurns` | 回合间隔路径上两次 local 归宿评估的最小间隔（压缩时刻无条件触发） |
+| `goalBlockedWrapupTurns` | `3` | D3：连续多少次门禁运行观察到 goal 处于 `blocked` 后触发一次 local 归宿评估（`0` 关闭） |
+| `reviewModel` | （使用 agent 自身模型） | review 门禁的可选模型覆盖（更便宜的模型）；格式：`"provider/model"` 或仅 `"model"` |
 
 示例（profile `cordis.patch.yml`）：
 
@@ -251,7 +268,7 @@ pnpm lint           # oxlint src test
 
 遇到问题先看 [`docs/FAQ.md`](docs/FAQ.md)（真实踩坑记录：服务平面、schema DSL、结构化输出、门禁计数、注入验证等）。
 
-对照 prime-agent `/refine` 与 penguin-harness 的差距与下一步实施项（P0 已交付：评估者/评分者分离、失败格协议；下一步 P1：运行实证校验、使用率统计、自动衰减）：[`docs/gap-analysis.md`](docs/gap-analysis.md)。
+对照 prime-agent `/refine` 与 penguin-harness 的差距与下一步实施项（P0+P1+P2+P3 已交付：评估者/评分者分离、失败格协议、运行时实证校验+材料漂移检测、使用率统计、自动衰减、case 生命周期+质检、条目目录视图、review 模型分离、blast-radius 标注、耗时追踪、evolve_complete 事件、种子 benchmark；D1 观察层 + D3 goal-blocked 触发已交付；剩余：跨进程同步按需实现 + D1/D2 完整工程化待实验数据）：[`docs/gap-analysis.md`](docs/gap-analysis.md)。
 
 ## 路线图
 
@@ -271,10 +288,30 @@ pnpm lint           # oxlint src test
 - **2026-08-17 收尾 wave（完成）**：
   - **`/evolve wrapup`**——会话结束时 local 条目有了真正的归宿：先机械审计（local 候选 + 全局覆盖检测；**覆盖只看标题相似**——裸同 id 但标题迥异**不算**覆盖，真正命中的全局标题会展示给分类器）→ LLM 分类（`promote` / `archive` / `keep` + A 形拆解提升：混合条目整体归档、同时提升清洗出的持久子对象）→ 应用时刻确定性守卫复检（promote 永不写出全局重复；对称归档守卫要求用户确认后才隐藏未被覆盖、源自真实对话的条目；清洗标题撞全局主题的拆解降级为普通归档）→ 所有全局 create 走一个人工审批门
   - **门禁 local 归宿维度**——wrap-up 机制现在以内置节奏（`fateIntervalTurns`，压缩时刻无条件）跑在自动 review 门禁里：local 条目在会话进行中被审计、分类、划分；治理动作先征询（一个弹窗、拒绝冷却），被覆盖/操作性条目静默归档，压缩时刻只做静默归档并以审计记录推迟治理动作；每次决策落进 `reviews.jsonl`，已执行动作发后续通知。应用写入与 wrapup 命令共享构造器（逐字节一致）
+- **2026-08-19 研究项先导（完成）**:
+  - **goal-blocked 触发收尾（D3）**——goal 连续 `goalBlockedWrapupTurns` 次门禁运行（默认 3）处于 `blocked` 时触发一次 local 归宿评估，把卡住的原因沉淀下来再继续；连胜在任意非 blocked 运行与每次触发后被重置，被拒提案走正常 fate 冷却（绝不打扰）；`goalBlockedWrapupTurns: 0` 关闭
+  - **失败签名聚合（D1 观察层）**——`/evolve failures` 将门禁失败记录与 benchmark 失败格按确定性失败类（`rubric-decrypt` / `executor` / `reviewer` / `material-drift` / `gate` / `max-tokens` 等）统计——未来 failure-signature Refiner 的底层数据
+  - **bootstrap 加速实验脚手架（D2）**——[`docs/experiment-bootstrap.md`](docs/experiment-bootstrap.md) 设计 ≤3 轮对照实验（固定 reference → 沉淀 harness → 候选评估）验证"被提高的 harness 加速下一跑"；`scripts/benchmark-trend.sh` 从 scoreboard 提取每轮趋势表（overall / totalDurationMs / failed / case-hash 一致性）
 - **2026-08-17 差距 P0（完成）**：
   - **评估者/评分者分离**——benchmark 评估改为两段式（差距 A1）：执行者完成任务并记录具体证据、**永远看不到 rubric**；独立评审者按 rubric 给证据评分（唯一解密 rubric 的分支）。被测 agent 无法朝评分标准优化、也无法自评
   - **失败格协议**——cell 带 `status: ok|failed`（差距 A2）：失败格从所有均值中排除并计数，接受规则在失败格超过 `maxFailedCells`（默认 0）时拒绝整轮，而不是把 0 平均进均值。scoreboard status/run 展示失败数与逐格原因
   - **Trace 证据指针**——每个 cell 记录执行者会话 id（差距 A4），分数可下钻回产生它的确切会话轨迹
+- **2026-08-18 差距 P1（完成）**：
+  - **运行时实证校验（A3）**——cell 现在记录宿主写入的实际 `provider`、`model` 和 `caseHash`（statement + rubric 的 SHA-256 前缀）；参考线与候选运行之间的材料变化会被检出并把受影响候选格重标为失败（version_changed 语义，`score.flagMaterialDrift`），材料漂移的轮次绝不可能被接受
+  - **条目使用率统计（B1）**——注入计数持久追踪（`<baseDir>/evolve/usage.json`）；`evolve_list` 展示使用次数；`zeroUsageEntries()` 筛选从未注入的 local 条目作为归档候选
+  - **自动陈旧检测（B2）**——零注入且低新鲜度的条目标记为 `stale`；LLM 分类器被指示优先归档陈旧条目
+- **2026-08-18 差距 P2（完成）**：
+  - **case 生命周期 + 质量门禁（A5）**——case 遵循 `draft → calibrating → frozen` 状态机；`casecheck` 运行机械质量校验（能力合约、区分点、快捷方式）；`pilot` 执行单次校准运行；`freeze` 将 case 锁定为正式基线（需通过质量门禁）；`meta` 设置 case 元数据字段
+  - **条目目录视图（B3）**——注入块现在包含所有非归档条目的轻量目录（id + title，每条一行），在条目超出精选封顶时自动展示，为模型提供零成本全局概览
+  - **review 模型分离（C1）**——`reviewModel` 配置项让 review 门禁可使用比主 agent 更便宜的模型
+  - **blast-radius 标注（C2）**——每条编辑现在携带 `blastRadius` 字段（`general` / `project` / `session`）；规划器被要求标注该字段，解析器验证取值
+  - **耗时追踪（C3）**——每个评估单元格记录 `durationMs`（墙钟时间）；聚合总计和决策报告展示耗时对比
+- **2026-08-18 代码重构（完成）**：
+  - **循环依赖拆解（P1-1）**——抽出 `skill-render.ts` 解耦 `skill.ts ↔ skillquality.ts`
+  - **LLM 调用去重（P1-2）**——抽出 `llm-text.ts` 共享 `streamText()`（review/planner/wrapup 删除 ~107 行重复）
+  - **config 类型推导（P2-1）**——`EvolveConfig` 改为 `Schemastery.TypeT` 推导（消除 20 行手写接口）
+  - **command.ts 拆分（P2-2）**——860 行 god file 拆为 `goal-command.ts`、`mount-command.ts`、`benchmark-command.ts`、`wrapup-command.ts`
+  - **P3 清理**——`questionServiceOf()` cast 去重（4 处）、死导出清理、矛盾注释修复
 
 候选/待办清单暂时为空——后续工作随真实使用驱动。
 

package/lib/apply.js

@@ -8,7 +8,7 @@ export function applyRefinementProposal(state, proposal, options) {
     for (const edit of proposal.edits) {
         const computedId = edit.id ?? (edit.action === "create" ? slug(edit.title ?? edit.kind, edit.kind) : undefined);
         const id = computedId ?? "";
-        const validationError = validateEdit(edit, computedId);
+        const validationError = validateEdit(edit, computedId, options.scope);
         if (validationError) {
             appliedEdits.push({ ...edit, id, applied: false, error: validationError });
             continue;

package/lib/approval.d.ts

@@ -25,6 +25,12 @@ export interface QuestionService {
         }[];
     }>;
 }
+/**
+ * Lazily resolve the userQuestions service from the context.
+ * Returns undefined when the service is not loaded — callers decide
+ * whether that is an error or a fallback.
+ */
+export declare function questionServiceOf(ctx: Context): QuestionService | undefined;
 /**
  * Ask the user to approve a global edit. Throws when the service is missing,
  * the user declines, or the question cannot be answered.

package/lib/approval.js

@@ -1,9 +1,17 @@
+/**
+ * Lazily resolve the userQuestions service from the context.
+ * Returns undefined when the service is not loaded — callers decide
+ * whether that is an error or a fallback.
+ */
+export function questionServiceOf(ctx) {
+    return ctx.userQuestions;
+}
 /**
  * Ask the user to approve a global edit. Throws when the service is missing,
  * the user declines, or the question cannot be answered.
  */
 export async function requireGlobalApproval(ctx, agent, signal, what) {
-    const userQuestions = ctx.userQuestions;
+    const userQuestions = questionServiceOf(ctx);
     if (!userQuestions) {
         throw new Error("global evolution edits require the userQuestions service (load @deepseek-ai/dsh-user-questions)");
     }

package/lib/auto.d.ts

@@ -22,6 +22,22 @@ export interface AutoReviewConfig {
      * round.
      */
     fateIntervalTurns: number;
+    /**
+     * Gap C1: optional model override for the review gate (cheaper model).
+     * Format: "provider/model" or just "model" (same provider as the agent).
+     * When absent, the review gate uses the agent's own provider/model.
+     */
+    reviewModel?: string;
+    /**
+     * Goal-blocked trigger (D3): after this many CONSECUTIVE gate runs that
+     * observe the session goal in phase "blocked", run one local-fate
+     * assessment (the same audit → classify → consult → apply pipeline as the
+     * gate's normal fate dimension) so the blocked encounter is distilled
+     * before the session moves on. 0 disables. The streak resets on any
+     * non-blocked run and after each triggered assessment; a declined
+     * proposal then follows the normal fate cooldown.
+     */
+    goalBlockedWrapupTurns: number;
 }
 export interface GateState {
     turns: number;
@@ -41,6 +57,12 @@ export interface GateState {
      * window (the consultSkillEdits pattern — no nagging).
      */
     fateRejects: Map<string, number>;
+    /**
+     * Consecutive gate runs that observed the goal phase "blocked" (D3).
+     * Reset to 0 by any non-blocked run and after a triggered assessment —
+     * see runGoalBlockedFate.
+     */
+    goalBlockStreak: number;
 }
 /** Turns a rejected skill candidate stays silent before being offered again. */
 export declare const SKILL_CONSULT_COOLDOWN_TURNS = 10;
@@ -54,10 +76,9 @@ export interface ReviewRecord {
     refinementId?: string;
 }
 /**
- * Count completed turns from agent/status transitions alone. The runtime
- * emits `agent/status` with a `{status}` payload and (per host consumers like
- * dsh-host-apiproxy) an injected `agent` subject; `agent/turn-stopping` does
- * not reliably carry the agent, so it is NOT used for counting.
+ * Count completed turns from agent/status transitions (running → idle).
+ * Exported for unit testing; production counting uses agent/turn-stopping
+ * (see registerAutoReview) which empirically carries the agent subject.
  */
 export declare function advanceGateState(state: GateState, status: string): boolean;
 export declare function registerAutoReview(ctx: Context, engine: EvolutionEngine, config: AutoReviewConfig): void;
@@ -71,6 +92,19 @@ export declare function registerAutoReview(ctx: Context, engine: EvolutionEngine
  * local state (baseline checks compare local entries only).
  */
 export declare function loadGateHarnessView(engine: EvolutionEngine, sessionId: string): HarnessState;
+/**
+ * D3 (goal blocked → wrap-up coupling, reverse direction): count consecutive
+ * gate runs whose goal is in phase "blocked"; when the streak reaches
+ * `goalBlockedWrapupTurns`, run ONE local-fate assessment (same pipeline as
+ * the normal fate dimension — audit, classify, consult, apply deterministically).
+ * The streak resets on any non-blocked run and after a triggered assessment;
+ * a declined proposal is then protected by the normal fate cooldown, so a
+ * blocked session can never be nagged into another dialog.
+ *
+ * Exported for unit testing (the advanceGateState precedent); production runs
+ * it from runGate.
+ */
+export declare function runGoalBlockedFate(ctx: Context, engine: EvolutionEngine, agent: Agent, config: AutoReviewConfig, state: GateState, _reason: AutoRefineReason, record: (entry: Omit<ReviewRecord, "timestamp">) => void): Promise<void>;
 /**
  * Split a proposal into skill edits and everything else. Skill edits are the
  * governed part: they need explicit user consent before the gate applies

package/lib/auto.js

@@ -25,13 +25,14 @@ import { notifyAutoReview } from "./notify.js";
 import { runLocalFatePhase } from "./fate.js";
 import { entrySourceOf } from "./source.js";
 import { mergeHarnessStates } from "./state.js";
+import { questionServiceOf } from "./approval.js";
+import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
 /** Turns a rejected skill candidate stays silent before being offered again. */
 export const SKILL_CONSULT_COOLDOWN_TURNS = 10;
 /**
- * Count completed turns from agent/status transitions alone. The runtime
- * emits `agent/status` with a `{status}` payload and (per host consumers like
- * dsh-host-apiproxy) an injected `agent` subject; `agent/turn-stopping` does
- * not reliably carry the agent, so it is NOT used for counting.
+ * Count completed turns from agent/status transitions (running → idle).
+ * Exported for unit testing; production counting uses agent/turn-stopping
+ * (see registerAutoReview) which empirically carries the agent subject.
  */
 export function advanceGateState(state, status) {
     if (status === "running") {
@@ -134,6 +135,19 @@ export function registerAutoReview(ctx, engine, config) {
         });
     });
 }
+/**
+ * Gap C1: parse a "provider/model" or "model" string into its components.
+ * Returns undefined when the input is empty (no override).
+ */
+function parseReviewModel(reviewModel, fallbackProvider) {
+    if (!reviewModel || reviewModel.trim().length === 0)
+        return undefined;
+    const slash = reviewModel.indexOf("/");
+    if (slash > 0) {
+        return { provider: reviewModel.slice(0, slash), model: reviewModel.slice(slash + 1) };
+    }
+    return { provider: fallbackProvider ?? "deepseek", model: reviewModel };
+}
 function stateFor(map, sessionId) {
     let state = map.get(sessionId);
     if (!state) {
@@ -144,6 +158,7 @@ function stateFor(map, sessionId) {
             skillRejects: new Map(),
             lastFateAt: 0,
             fateRejects: new Map(),
+            goalBlockStreak: 0,
         };
         map.set(sessionId, state);
     }
@@ -171,8 +186,41 @@ export function loadGateHarnessView(engine, sessionId) {
  */
 async function runGate(ctx, engine, agent, config, state, reason, record) {
     await runReviewPhase(ctx, engine, agent, config, state, reason, record);
+    // D3: a goal stuck in "blocked" for consecutive gate runs gets one
+    // local-fate assessment (the pipeline below), so whatever led the goal
+    // astray is distilled before the session moves on.
+    await runGoalBlockedFate(ctx, engine, agent, config, state, reason, record);
     await runLocalFatePhase(ctx, engine, agent, config, state, reason, record);
 }
+/**
+ * D3 (goal blocked → wrap-up coupling, reverse direction): count consecutive
+ * gate runs whose goal is in phase "blocked"; when the streak reaches
+ * `goalBlockedWrapupTurns`, run ONE local-fate assessment (same pipeline as
+ * the normal fate dimension — audit, classify, consult, apply deterministically).
+ * The streak resets on any non-blocked run and after a triggered assessment;
+ * a declined proposal is then protected by the normal fate cooldown, so a
+ * blocked session can never be nagged into another dialog.
+ *
+ * Exported for unit testing (the advanceGateState precedent); production runs
+ * it from runGate.
+ */
+export async function runGoalBlockedFate(ctx, engine, agent, config, state, _reason, record) {
+    if (config.goalBlockedWrapupTurns <= 0)
+        return;
+    const goal = goalServiceOf(ctx)?.get(agent);
+    if (goal?.phase !== "blocked") {
+        state.goalBlockStreak = 0;
+        return;
+    }
+    state.goalBlockStreak += 1;
+    if (state.goalBlockStreak < config.goalBlockedWrapupTurns) {
+        return;
+    }
+    state.goalBlockStreak = 0; // one assessment per streak; declines follow the fate cooldown
+    const logger = ctx.logger("continual-evolve");
+    logger.info(`auto-review goal-blocked trigger [${agent.id}]: ${config.goalBlockedWrapupTurns} consecutive blocked gate runs → local-fate assessment`);
+    await runLocalFatePhase(ctx, engine, agent, config, state, "goal_blocked", record);
+}
 async function runReviewPhase(ctx, engine, agent, config, state, reason, record) {
     const sessionId = agent.id;
     const turnsSinceLastReview = state.turns - state.lastReviewAt;
@@ -192,6 +240,8 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
     const localState = engine.load("local", sessionId);
     const harnessState = loadGateHarnessView(engine, sessionId);
     const history = engine.history("local", sessionId);
+    // Gap C1: resolve optional review model override.
+    const reviewRoute = parseReviewModel(config.reviewModel, agent.options.provider);
     const review = await reviewAutoRefine(ctx, {
         agent,
         state: harnessState,
@@ -199,6 +249,7 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
         trajectory,
         context: { reason, turnsSinceLastReview },
         budgetTokens: config.budgetTokens,
+        ...(reviewRoute ? { overrideProvider: reviewRoute.provider, overrideModel: reviewRoute.model } : {}),
     });
     state.lastReviewAt = state.turns;
     if (!review.shouldRefine) {
@@ -243,6 +294,8 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
     });
     logger.info(`auto-review approved (${reason}) [${sessionId}] after ${turnsSinceLastReview} turns; auto-refine ${result.id}: ${result.appliedEdits.filter((e) => e.applied).length} applied, ${result.appliedEdits.filter((e) => !e.applied).length} failed — ${review.rationale}`);
     record({ sessionId, reason, turnsSinceLastReview, outcome: "approved", rationale: review.rationale, refinementId: result.id });
+    // Gap C4: emit structured evolve_complete event for third-party consumers.
+    emitEvolveComplete(engine.baseDir, buildEvolveCompleteEvent(result, `auto_review:${reason}`, sessionId));
     // Visibility: tell the user what the gate just persisted. Only the
     // turn-interval path notifies — a compaction-triggered gate must not wake
     // the agent mid-compaction — and only when something was actually applied
@@ -288,7 +341,7 @@ export async function consultSkillEdits(ctx, agent, skillEdits, gate) {
     if (lastReject !== undefined && gate.turns - lastReject < SKILL_CONSULT_COOLDOWN_TURNS) {
         return false;
     }
-    const userQuestions = ctx.userQuestions;
+    const userQuestions = questionServiceOf(ctx);
     if (!userQuestions) {
         return false;
     }

package/lib/benchmark-command.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `/evolve benchmark` subcommand handler. Extracted from command.ts (P2-2).
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { CommandInvocation, CommandResult } from "@deepseek-ai/dsh-commands";
+import type { EvolutionEngine } from "./service.js";
+import type { CommandRuntimeOptions } from "./command.js";
+export declare function executeBenchmarkCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, rest: string[], runtime: CommandRuntimeOptions): Promise<CommandResult>;
+//# sourceMappingURL=benchmark-command.d.ts.map