dsh-continual-evolve 0.1.1 → 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-184%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.
@@ -21,8 +21,11 @@ Continual self-evolution for [DeepSeek Harness](https://github.com/deepseek-ai/d
 > scoring, non-regressive acceptance, rubric ACL). Since then the plugin
 > keeps growing with usage-driven enhancements — the memory layer (ranked
 > injection, trajectory citations, archive), per-installation rubric keys,
-> and plugin-owned file logging. See the Roadmap for the full shipped and
-> candidate lists.
+> plugin-owned file logging, the session wrap-up (`/evolve wrapup`), and
+> the gate's automatic local-fate dimension (local entries get a promoted
+> or archived exit on the gate's own cadence — consulted first, never
+> written silently). See the Roadmap for the full shipped and candidate
+> lists.
 
 ## Background
 
@@ -98,27 +101,38 @@ 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)
-│   ├── auto.ts           # auto-review gate (turn/compaction triggers + audit, global-aware view)
+│   ├── auto.ts           # auto-review gate (turn/compaction triggers + audit, global-aware view, local-fate phase)
+│   ├── fate.ts           # gate local-fate dimension — auto promote/archive of local entries (consulted first, cooldown)
 │   ├── notify.ts         # gate visibility — follow-up notice after an approved auto-refine
 │   ├── goal.ts           # goal-driven evolution rounds (/evolve goal)
 │   ├── 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       # evaluation matrix runner (structured-output subagents)
+│   ├── 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)
-└── test/                 # 20 files, 184 tests
+│   ├── service.ts        # evolution engine (onApplied hook)
+│   ├── 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
@@ -141,9 +155,12 @@ Swap `web` for your profile name (`headless`, or a custom profile).
 /evolve history          applied refinements (ids for rollback)
 /evolve rollback <id>    deterministically revert a refinement
 /evolve plan [msg]       LLM planner against the current store
+/evolve wrapup           assess this session's local entries: promote reusable ones to the
+                         global store (approval required), archive session-specific ones
 /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>)
@@ -179,11 +196,82 @@ LangMem; no external services — everything is pure functions):
   `/evolve unarchive <id>` restores it. Archived entries are marked
   `[archived]` in `evolve_list` and skipped by injection; the overflow count
   excludes them.
+- **Session wrap-up** — a session's local entries otherwise become orphans when
+  it ends (later sessions never see them). `/evolve wrapup` gives them an exit.
+  Each entry is audited mechanically — global-coverage is judged by **title
+  similarity only** (a bare id collision with a different title is intentionally
+  NOT coverage; the actual matching global titles are shown to the assessor so
+  it judges against real content) — then classified as `promote` / `archive` /
+  `keep`. Promotions move reusable entries into the global store **through the
+  human approval gate**, keeping their trajectory citation and adding a
+  `sourcedFromLocal=<session>:<id>` back-link; the local copy is stamped
+  `promotedTo` and retired from injection so it is never offered again.
+  **Split promotion** (A-form): a mixed entry (durable facts + session snapshot)
+  can be archived while carrying a cleaned `promote` sub-object — only the
+  durable part lands globally, the snapshot stays in the archive. A **symmetric
+  archive guard** requires user confirmation before an archive that is NOT
+  globally covered AND was distilled from real user messages hides that content
+  from future sessions (over-archiving gets the same protection as
+  over-writing); operational entries still archive silently. Everything stays
+  snapshot/versioned/rollbackable.
+- **Gate local-fate (automatic wrap-up)** — the same wrap-up machinery now
+  runs inside the auto-review gate on its own cadence (`fateIntervalTurns`),
+  so local entries get their exit while the session is still running instead
+  of waiting for a manual `/evolve wrapup`. On each due gate run the audited
+  candidates are classified by the assessor and partitioned by the same
+  deterministic guards; the user is consulted FIRST before anything governed
+  lands (one dialog covering promotes, split promotions and review-required
+  archives — the consultSkillEdits pattern, with a decline cooldown). Covered
+  or operational entries still archive silently, and at compaction the gate
+  never opens a dialog: only silent archives apply, governed actions are
+  deferred with an audit record pointing at `/evolve wrapup`. Every fate
+  decision lands in `reviews.jsonl` (`approved` / `declined` / `deferred` /
+  `assessed` / `failed`) and applied actions are visible via a follow-up
+  notice. Apply writes are byte-identical to the wrap-up command (shared
+  proposal builders).
 - **Global-aware gate** — the auto-review gate and planner judge the merged
   global + local state with every entry's real scope labeled, so a topic
   already covered by a global entry is declined instead of being re-sedimented
   as a local duplicate.
 
+## Skill standard in the loop
+
+The planner and the auto-review gate are raw `ctx.llm` calls — they do not
+live in an agent session, so they cannot load skills through the `skill`
+tool. To keep self-evolved skills on the quality bar, the plugin references
+the **skill-creator** / **skill-audit** skills (user-level skills distilled
+by the author from the official deepseek-harness 11 skills; template facts
+verified against deepseek-harness `47f9438`) at runtime — they stay the
+single source of truth on disk, nothing is copied:
+
+- Every planning call receives a `<skill_quality_standard>` block: the
+  `skill-creator/references/template.md` facts when those skills are
+  installed (`<dshHome>/skills/`), or a builtin distilled guide otherwise
+  (~1KB, low-frequency calls). The planner must ground skill proposals in a
+  REAL trigger scenario from the trajectory, must not duplicate the
+  official 11 skills or existing entries, and self-checks every proposed
+  skill against the 7 structural features.
+- The gate judges skill-related trajectories against the skill-audit
+  dimensions (frontmatter routing, structural features, paragraph skeleton,
+  duplication) and declines proposals that would not meet the standard.
+- The mechanical frontmatter rules of `validate-frontmatter.mjs` are
+  code-enforced at apply time: skill bodies must not open with a second
+  `---` block (it would shadow the generated frontmatter), and resource
+  references may not escape the skill directory. After materialization the
+  rendered SKILL.md is re-checked and dangling `references/`/`scripts/`
+  links are logged as warnings.
+- **Two skill forms** — `executable` skills keep the python reference
+  contract (hot-mountable as tools); `guidance` skills are SKILL.md
+  documents with no reference, the form for recurring multi-step workflows
+  (session start/end routines, handoff procedures). Code enforces the
+  split: a guidance skill must NOT carry a reference or arguments contract.
+- **User-governed skill creation** — the gate never writes a skill
+  silently: when the planner proposes skill edits, the user is asked
+  (固化/不固化) before they land; a rejected candidate is not offered
+  again within a cooldown window. The rest of a proposal proceeds
+  regardless, so memory/prompt distillation is never blocked by a skill
+  decision.
+
 ## Logging
 
 Plugin-owned file logging: every cordis log message (from this plugin or any
@@ -211,16 +299,47 @@ 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`) →
 run the same case × run matrix against the post-refinement state → the
 **code-owned** acceptance rule keeps the candidate only if the overall mean
-strictly improves with no case regressing (Self-Harness style). The model
-produces raw per-cell scores only; aggregation and decisions live in
-`src/score.ts`. Rubric isolation is by construction (the planner never sees
-rubric files); a rejection is recorded in the scoreboard and the refinement
-is rolled back automatically (`autoRollbackOnReject`, on by default).
+strictly improves with no case regressing (Self-Harness style).
+
+**Evaluator/scorer separation (two-stage, gap A1)** — each case × run unit
+is a PAIR of fresh subagents:
+
+1. the **executor** performs the task with its tools and records **concrete
+   evidence** of what it did and found — it NEVER sees the rubric, so the
+   agent under test cannot optimize toward or self-grade against the grading
+   criteria;
+2. an **independent reviewer** grades that evidence strictly against the
+   rubric (the only branch that receives the decrypted rubric), eliminating
+   the "self-produced and self-scored" bias.
+
+Each cell records the executor's session id, so a score can be drilled back
+to the exact transcript that produced it (trace evidence pointer, gap A4).
+
+**Failure-cell protocol (gap A2)** — a unit that cannot produce a score
+(rubric decrypt error, executor/reviewer crash, protocol error) is recorded
+as a **failed** cell, NEVER a zero: aggregation excludes failed cells from
+every mean and counts them (`/evolve benchmark status` shows `(N failed)`),
+and the acceptance rule rejects a round with more failed cells than
+`maxFailedCells` (0 by default) instead of silently averaging a 0 into the
+mean.
+
+Aggregation and decisions live in `src/score.ts`. Rubric isolation is by
+construction (the planner never sees rubric files, and the executor branch
+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)
 
@@ -234,9 +353,10 @@ acceptance:
 | re-evaluate | `/evolve benchmark run lint_convention candidate <id>` | **100** — evaluator ran `evolve_list`, hit the memory, quoted it verbatim |
 | decision | — | `overall: 90 → 100` · `lint_knowledge: 90 → 100` · **DECISION: ACCEPTED** |
 
-The evaluator does not grade model common sense — it inspects the actual
-harness state under test (grep, `evolve_list`) and scores against it, so a
-harness change measurably moves the score. Earlier runs in the same session
+The executor does not grade model common sense — it inspects the actual
+harness state under test (grep, `evolve_list`) and records what it found;
+the independent reviewer grades that record. A harness change measurably
+moves the score. Earlier runs in the same session
 produced honest `REJECTED` decisions (0 → 0 stub cases, and 100 → 100
 where the baseline was already perfect).
 
@@ -258,6 +378,10 @@ where the baseline was already perfect).
 | `logLevel` | `1` | file log level: 0=error, 1=info, 2=warn, 3=debug |
 | `logMaxBytes` | 5 MiB | rotate the log to `plugin.log.1` when it exceeds this size |
 | `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`):
 
@@ -282,6 +406,8 @@ 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+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
 
 **Shipped**
@@ -295,6 +421,35 @@ Hit a wall? See [`docs/FAQ.md`](docs/FAQ.md) — real failure/fix records (servi
   - **gate-proposed archiving** — stale entries are a first-class refine target: the planner can emit `action: "archive"` (kind + id only), which stamps `metadata.archivedAt` through the normal apply path — snapshot, version bump, audit event, and a deterministic rollback inverse that restores the pre-archive state. Archive hides from injection but never deletes; re-archiving an archived entry is rejected, and the base system prompt stays immutable
   - **automatic rollback on benchmark rejection** — the acceptance loop is closed: when the code-owned decision rejects a candidate, the refinement is reverted automatically through the same engine path as `/evolve rollback` (deterministic inverse edits, snapshotted and audited; configurable via `autoRollbackOnReject`, on by default). Failures report the manual fallback instead of throwing
   - **per-session log filtering** — `/evolve log [tail N] [session <id>]` keeps only the lines mentioning a given session id (exact token match, drawn from the rendered message and raw args); gate records now carry the session id in their log line
+  - **skill standard in the loop** — the planner and gate now author and judge skill entries against the skill-creator/skill-audit standard (author-distilled from the official deepseek-harness 11 skills): every plan call injects the `template.md` facts (builtin distilled guide as fallback) as `<skill_quality_standard>`; apply code-enforces the frontmatter mechanics (no shadowing `---`, no escaping resource refs); materialized SKILL.md files are re-checked and dangling resource references are logged;
+  - **guidance skills + user-governed creation** — a second skill form (SKILL.md documents without a python reference) lets recurring workflows be proposed as skills; the gate offers every auto-created skill to the user (固化/不固化) before it lands, with a rejection cooldown — skills grow under governance, never silently
+- **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,12 +7,12 @@
 [![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-184%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 状态层——提示词补充、记忆、技能、子代理规格——从会话轨迹中沉淀而来。
 
-> **状态：全部阶段完成，进入长期维护。** Phase 1–3 交付了完整进化闭环：纯核心引擎、模型工具与 `/evolve` 命令、自动 review 门禁（回合间隔 + 压缩检查点、全局写入人工审批）、真实系统提示词注入（prompt 补充 + 委派规格，空 store 零 token 成本）、benchmark 驱动验证闭环（代码所有计分、非退化接受、rubric ACL）。此后插件随真实使用持续增强——记忆层（排序注入、轨迹引用、归档）、每安装实例独立的 rubric 密钥、插件自带文件日志。已交付与候选清单见"路线图"。
+> **状态：全部阶段完成，进入长期维护。** Phase 1–3 交付了完整进化闭环：纯核心引擎、模型工具与 `/evolve` 命令、自动 review 门禁（回合间隔 + 压缩检查点、全局写入人工审批）、真实系统提示词注入（prompt 补充 + 委派规格，空 store 零 token 成本）、benchmark 驱动验证闭环（代码所有计分、非退化接受、rubric ACL）。此后插件随真实使用持续增强——记忆层（排序注入、轨迹引用、归档）、每安装实例独立的 rubric 密钥、插件自带文件日志、会话收尾（`/evolve wrapup`）、以及门禁的自动 local 归宿维度（local 条目在门禁自有节奏下获得提升或归档的归宿——先征询、绝不静默写入）。已交付与候选清单见"路线图"。
 
 ## 背景
 
@@ -75,27 +75,38 @@ 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）
-│   ├── auto.ts           # 自动 review 门禁（回合/压缩触发 + 审计，global 感知视图）
+│   ├── auto.ts           # 自动 review 门禁（回合/压缩触发 + 审计，global 感知视图，local 归宿阶段）
+│   ├── fate.ts           # 门禁 local 归宿维度——自动提议 local 条目提升/归档（先征询、带冷却）
 │   ├── notify.ts         # 门禁可见性——approved 自动沉淀后发送可见通知
 │   ├── goal.ts           # goal 驱动的进化轮次（/evolve goal）
 │   ├── 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 钩子）
-└── test/                 # 20 个文件，184 个测试
+│   ├── service.ts        # 进化引擎（onApplied 钩子）
+│   ├── usage.ts          # 条目注入使用率追踪（持久计数、陈旧检测）
+│   ├── failures.ts       # 失败签名聚合（门禁 + benchmark 失败按类统计，/evolve failures）
+│   └── wrapup.ts         # 会话收尾生命周期（提升/拆解提升到 global、带守卫的归档；共享 proposal 构造器；陈旧信号）
+└── test/                 # 28 个文件，401 个测试
 ```
 
 ## 安装
@@ -118,9 +129,12 @@ dsh plugin --profile web add github:ZK-Andy/dsh-continual-evolve
 /evolve history               已应用的 refinement（回滚用 id）
 /evolve rollback <id>         确定性回滚某个 refinement
 /evolve plan [msg]            LLM 规划器
+/evolve wrapup                评估本会话 local 条目：可复用的提升到 global（需审批），
+                              会话特有的一次性条目归档
 /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>）
@@ -140,8 +154,20 @@ dsh plugin --profile web add github:ZK-Andy/dsh-continual-evolve
 - **打分排序注入**——某类条目超过 6 条封顶时，注入块不再固定取前 6 条：先按与 agent 最近直接用户消息的相关度打分（关键词/BM25 级别，标题命中权重 2×），再按新鲜度排序（`updated_at`，30 天半衰期），让"最新 + 最相关"的条目填满封顶。空 store 零 token 行为不变。
 - **轨迹引用**——每条新沉淀条目都会记录 `metadata.sourceSession` + `metadata.sourceSeqs`，指向它蒸馏自的直接用户消息（DSH 会话是事件溯源、seq 连续，引用可展开回持久会话日志）。列表显示 `src=<sessionId>:<seqs>`；旧条目不迁移也不报错。
 - **归档**——`/evolve archive <id>` 让条目不再注入（`metadata.archivedAt`，数据保留、与快照/回滚兼容），`/evolve unarchive <id>` 恢复。归档条目在 `evolve_list` 中标记 `[archived]`，注入跳过，溢出计数不含它们。
+- **会话收尾**——否则会话结束时的 local 条目会变成孤岛（后续会话永远看不到）。`/evolve wrapup` 给它们一个归宿：先机械审计——**全局覆盖只看标题相似**（裸同 id 但标题迥异**不算**覆盖；实际命中的全局标题会展示给分类器，让它对照真实内容判断）——再由模型逐条分类为 `promote` / `archive` / `keep`。提升把可复用条目写入 global store——**经人工审批门禁**，保留轨迹引用并追加 `sourcedFromLocal=<session>:<id>` 反向回引；本地副本随后盖 `promotedTo` 戳退出注入，永不再被提议。**拆解提升（A 形）**：混合条目（持久事实 + 会话快照）可整体归档、同时带一个清洗过的 `promote` 子对象——只有持久部分落进 global，快照留在归档里。**对称归档守卫**：未被全局覆盖、且源自真实用户消息的归档，先征求用户确认才隐藏内容（防过度归档与防过度写入获得同等保护）；操作性条目仍静默归档。一切仍走快照/版本/可回滚。
+- **门禁 local 归宿（自动收尾）**——同一套 wrap-up 机制现在以内置节奏（`fateIntervalTurns`）跑在自动 review 门禁里：local 条目在会话进行中就能获得归宿，不必等手动 `/evolve wrapup`。每次到期的门禁运行都会审计候选条目、由分类器分类、再经同一套确定性守卫划分；任何治理动作落地前**先征询用户**（一个弹窗覆盖提升、拆解提升与需确认归档——consultSkillEdits 模式，带拒绝冷却）。被全局覆盖或操作性条目仍静默归档；压缩时刻门禁绝不弹窗：只做静默归档，治理动作以审计记录推迟并指向 `/evolve wrapup`。每次 fate 决策都落进 `reviews.jsonl`（`approved` / `declined` / `deferred` / `assessed` / `failed`），已执行动作通过后续通知可见。应用写入与 wrapup 命令逐字节一致（共享 proposal 构造器）。
 - **global 感知门禁**——自动 review 门禁与规划器评审的是合并后的 global + local 状态，每条条目标注真实 scope；global 已覆盖的主题会被 declined，不再重复沉淀为 local 条目。
 
+## 自进化环中的技能标准
+
+规划器与自动门禁是裸 `ctx.llm` 调用——不在 agent 会话内，无法通过 `skill` 工具加载技能。为了让自进化长出的技能保持在质量线上，插件在运行时引用 **skill-creator** / **skill-audit** 技能（作者从官方 deepseek-harness 11 个技能蒸馏的自建技能，模板事实核验自官方源码 `47f9438`；留在磁盘上作为单一事实源，零复制）：
+
+- **每次规划调用注入 `<skill_quality_standard>` 块**：`skill-creator/references/template.md` 事实（技能已安装时，位于 `<dshHome>/skills/`），否则用内置精华版兜底（约 1KB，低频调用）。规划器必须把技能提案锚定在轨迹中的**真实触发场景**、不得重复官方 11 技能或已有条目，并逐条自检 7 条结构特征。
+- **门禁按 skill-audit 维度评审**技能相关轨迹（frontmatter 路由、结构特征、段落骨架、防重复），不达标的提案 declined 并说明改进方向。
+- **机械 frontmatter 规则代码强制**（移植 `validate-frontmatter.mjs`）：技能正文不得以第二个 `---` 块开头（会遮蔽自动生成的 frontmatter）、资源引用不得越出技能目录；物化后对渲染产物复检，悬空 `references/`/`scripts/` 引用记 warn 日志。
+- **两种技能形态**——`executable`（可执行，保留 python reference 契约，可热挂载为工具）与 `guidance`（指导型：SKILL.md 文档、无 reference，用于反复出现的多步流程，如会话开始/结束、交接流程）。代码强制区分：guidance 技能**不得**携带 reference 或 arguments 契约。
+- **用户治理的技能创建**——门禁绝不静默写技能：规划器提议技能编辑时，先问用户（固化/不固化）再落地；被拒候选在冷却窗口内不再打扰。提案其余部分（记忆/提示词沉淀）不受影响照常进行——技能决策永不阻塞普通沉淀。
+
 ## 日志
 
 插件自带文件日志：所有 cordis 日志消息（本插件或其他插件）追加写入 `<dshHome>/evolve/plugin.log`（JSONL、0600，超过 `logMaxBytes` 轮转到 `plugin.log.1`）。与 `dsh web` 的启动方式无关——无需安装额外组件、不依赖启动脚本。查看方式：
@@ -163,9 +189,25 @@ 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 风格）。模型只产出原始细胞级分数；聚合与决策都在 `src/score.ts`。rubric 隔离靠构造（规划器的提示词永远不含 rubric 文件）；拒绝会记录进 scoreboard 并自动回滚该 refinement（`autoRollbackOnReject`，默认开）。
+闭环：冻结参考分 → 进化候选（`/evolve plan`）→ 用同一 case × run 矩阵复测进化后状态 → **代码所有**的接受规则只在总体均值严格提高且无 case 退化时保留候选（Self-Harness 风格）。
+
+**评估者/评分者分离（两段式，差距 A1）**——每个 case × run 单元是一对全新子代理：
+1. **执行者**用工具完成任务并记录**具体证据**（做了什么、查到了什么）——它**永远看不到 rubric**，被测 agent 无法朝评分标准优化、也无法自评；
+2. **独立评审者**严格按 rubric 给证据打分（唯一接收解密 rubric 的分支），消除"自产自审"偏差。
+
+每个 cell 记录执行者会话 id——分数可下钻回产生该证据的确切会话轨迹（Trace 证据指针，差距 A4）。
+
+**失败格协议（差距 A2）**——无法产出分数的单元（rubric 解密失败、执行者/评审者崩溃、协议错误）记为**失败格**，**绝不是 0 分**：聚合从所有均值中排除失败格并计数（`/evolve benchmark status` 显示 `(N failed)`），接受规则在失败格超过 `maxFailedCells`（默认 0）时拒绝整轮，而不是把 0 平均进均值。
+
+聚合与决策都在 `src/score.ts`。rubric 隔离靠构造（规划器的提示词永远不含 rubric 文件、执行者分支永不解密）；拒绝会记录进 scoreboard 并自动回滚该 refinement（`autoRollbackOnReject`，默认开）。
+
+开箱即用的种子 case 在 [`examples/`](examples/)——复制粘贴 statement 和 rubric 即可在一分钟内上手。
 
 ### 真实运行记录（ACCEPT）
 
@@ -178,7 +220,7 @@ tail -f ~/.dsh/evolve/plugin.log          # 实时跟随
 | 复测 | `/evolve benchmark run lint_convention candidate <id>` | **100**——评估器跑 `evolve_list` 命中记忆并逐字引用 |
 | 决策 | — | `overall: 90 → 100` · `lint_knowledge: 90 → 100` · **DECISION: ACCEPTED** |
 
-评估器评的不是模型常识，而是**被测 harness 状态本身**（grep、`evolve_list` 检查）——所以 harness 的改动会真实地反映在分数上。同一会话早些时候还产生过诚实的 `REJECTED` 决策（0→0 占位符 case、100→100 满分基线无法超越）。
+执行者评的不是模型常识，而是**实际检查被测 harness 状态**（grep、`evolve_list`）并记录产出，再由独立评审者按 rubric 评分——所以 harness 的改动会真实地反映在分数上。同一会话早些时候还产生过诚实的 `REJECTED` 决策（0→0 占位符 case、100→100 满分基线无法超越）。
 
 ## 配置
 
@@ -198,6 +240,10 @@ tail -f ~/.dsh/evolve/plugin.log          # 实时跟随
 | `logLevel` | `1` | 文件日志级别：0=error、1=info、2=warn、3=debug |
 | `logMaxBytes` | 5 MiB | 超过该大小轮转到 `plugin.log.1` |
 | `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`）：
 
@@ -222,6 +268,8 @@ pnpm lint           # oxlint src test
 
 遇到问题先看 [`docs/FAQ.md`](docs/FAQ.md)（真实踩坑记录：服务平面、schema DSL、结构化输出、门禁计数、注入验证等）。
 
+对照 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)。
+
 ## 路线图
 
 **已交付**
@@ -235,6 +283,35 @@ pnpm lint           # oxlint src test
   - **门禁提议归档**——过时条目是一等 refine 目标：规划器可输出 `action: "archive"`（仅需 kind + id），代码经正常 apply 通道盖 `metadata.archivedAt` 戳——快照、版本 +1、审计事件、以及恢复归档前状态的确定性回滚逆编辑。归档隐藏于注入但绝不删除；重复归档被拒绝；基础系统提示词保持不可变
   - **benchmark 拒绝自动回滚**——接受闭环已闭合：代码所有决策拒绝候选时，refinement 经与 `/evolve rollback` 相同的引擎路径自动撤销（确定性逆编辑、快照 + 审计；`autoRollbackOnReject` 配置，默认开）。失败时给出手动回滚提示而不是抛错
   - **日志按会话过滤**——`/evolve log [tail N] [session <id>]` 只保留提及指定会话 id 的行（精确 token 匹配，取自渲染消息与原始 args）；门禁记录的行现在携带会话 id
+  - **自进化环中的技能标准**——规划器与门禁现在按 skill-creator/skill-audit 标准（作者蒸馏自官方 deepseek-harness 11 技能）创作与评审技能条目：每次规划注入 `template.md` 事实（内置精华版兜底）为 `<skill_quality_standard>`；apply 代码强制 frontmatter 机械规则（禁止遮蔽 `---`、禁止越界资源引用）；物化后的 SKILL.md 复检，悬空资源引用记日志;
+  - **guidance 技能形态 + 用户治理创建**——第二种技能形态（无 python reference 的 SKILL.md 文档技能）让反复出现的流程可以被提议为技能；门禁把每次自动创建的技能先交给用户决定（固化/不固化）再落地，带拒绝冷却——技能在治理下生长，绝不静默写入
+- **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;
@@ -82,6 +82,7 @@ export function applyRefinementProposal(state, proposal, options) {
                     : {}),
             }
             : {};
+        const skillKind = edit.skill_kind ?? before?.skill_kind;
         const after = {
             id,
             kind: edit.kind,
@@ -91,6 +92,7 @@ export function applyRefinementProposal(state, proposal, options) {
             scope: before?.scope ?? options.scope ?? "local",
             reference: edit.reference ?? before?.reference ?? {},
             arguments: edit.arguments ?? before?.arguments ?? {},
+            ...(skillKind !== undefined ? { skill_kind: skillKind } : {}),
             metadata: { ...sourceMetadata, ...(edit.metadata ?? before?.metadata ?? {}) },
             source: "evolve",
             created_at: before?.created_at ?? now,

package/lib/approval.d.ts

@@ -6,6 +6,31 @@
  */
 import type { Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
+export interface QuestionService {
+    ask(request: {
+        questions: {
+            id: string;
+            question: string;
+            options?: {
+                label: string;
+                description?: string;
+            }[];
+        }[];
+        agent?: Agent;
+        signal?: AbortSignal;
+    }): Promise<{
+        answers?: {
+            id: string;
+            selected?: string[];
+        }[];
+    }>;
+}
+/**
+ * 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)");
     }