dsh-continual-evolve 0.7.2 → 0.7.3

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-675%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-737%20passing-brightgreen)]()
 
 Continual self-evolution for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness): a versioned, auditable, rollback-safe harness state layer — prompt notes, memories, skills, subagent specs — refined from session trajectories.
 
@@ -19,17 +19,19 @@ Agents accumulate reusable experience (repeated failures, durable facts, reusabl
 
 - **Three scopes** with merge semantics (global < project < local): **local** per-session staging, **project** per-workspace cross-session store, **global** cross-project — plus mechanical promotion guards so only portable, substantial, non-duplicate knowledge reaches global
 - **Typed one-fact memories**: every memory entry carries a recall type (`user | feedback | project | reference`); pitfalls (`feedback`) must include Why + How to apply
+- **Dedicated background memory agent**: after eligible successful turns, a bounded ZCode-style loop searches the frozen memory manifest and proposes memory-only edits through a closed tool set; it cannot call agents, MCP, the network, or write source files
 - **Deterministic rollback**: inverse edits generated from applied results — no LLM re-guessing
 - **Benchmark loop**: candidate refinements are evaluated against frozen cases by a separate scorer before acceptance (rubric encrypted at rest)
 - **Store hygiene**: `/evolve consolidate` turns write-time conflict hints and zero-use staleness into one approved, fully reversible batch of archives — with `merge`, near-duplicate content folds into the surviving original
 
 ## How it works
 
-1. **Sediment** — the model creates entries via `evolve_add`, or the automatic review gate proposes them from incremental snapshots captured after successful turns (plus compaction checkpoints).
-2. **Guard** — code-enforced validation: edit schema, blast-radius/scope coherence, and the promotion policy (project-scoped markers, thin content, near-duplicate detection, credential screening keep the global store clean — secrets are rejected at every write sink, including mount materialization). Global creates that near-duplicate an existing entry are rejected at write time (≥0.8 similarity); moderate overlaps carry a `conflictHint` for later consolidation.
-3. **Approve** — global and project writes require explicit human approval; local-fate proposals are consulted before they land.
-4. **Apply & inject** — atomic apply with snapshot + audit event. Prompt notes and delegation specs inject into the system prompt (capped, relevance-ranked, contradicted entries demoted, zero tokens when empty); memories/skills appear as a relevance-ordered capped directory index (`- [memory:type:id] title` hooks, full text one `evolve_list` away).
-5. **Validate & roll back** — benchmarks score candidates against frozen cases; rejected candidates roll back deterministically and are captured as draft regression cases (`auto_regression` benchmark).
+1. **Sediment** — the model creates entries via `evolve_add`, or the automatic pipeline consumes incremental snapshots captured after successful turns (plus compaction checkpoints): a dedicated memory agent runs first, then the general review/planner proposes non-memory refinements.
+2. **Capability-aware auxiliary calls** — the memory loop, review, planner, wrapup, and fate resolve exact provider/model metadata through [`src/llm-text.ts`](src/llm-text.ts) and use the lowest advertised enabled reasoning effort (falling back to a closing effort only when no enabled level exists); models without reasoning metadata use their provider default.
+3. **Guard** — code-enforced validation: edit schema, blast-radius/scope coherence, and the promotion policy (project-scoped markers, thin content, near-duplicate detection, credential screening keep the global store clean — secrets are rejected at every write sink, including mount materialization). Global creates that near-duplicate an existing entry are rejected at write time (≥0.8 similarity); moderate overlaps carry a `conflictHint` for later consolidation.
+4. **Approve** — global and project writes require explicit human approval; the dialog shows the bounded structured edit diff and conflict warnings, while malformed/lost responses remain retryable rather than counting as rejection.
+5. **Apply & inject** — memory batches preflight every persistent approval, recheck abort before writes, and compensate earlier scope writes if a later batch fails; every successful scope still passes through snapshot + audit. Prompt notes and delegation specs inject into the system prompt (capped, relevance-ranked, contradicted entries demoted, zero tokens when empty); memories/skills appear as a relevance-ordered capped directory index (`- [memory:type:id] title` hooks, full text one `evolve_list` away).
+6. **Validate & roll back** — benchmarks score candidates against frozen cases; rejected candidates roll back deterministically and are captured as draft regression cases (`auto_regression` benchmark).
 
 ## Install
 
@@ -62,13 +64,13 @@ Commands (in-session):
 | `/evolve goal [objective · done · block]` | round-driven auto-review goal |
 | `/evolve benchmark …` | case lifecycle, runs, acceptance |
 | `/evolve pause · resume · status` | pause/resume the auto-review gate (manual tools keep working), gate state |
-| `/evolve usage` | per-entry injection counts + exact provider-reported tokens for direct review/planner/wrapup/fate calls (benchmark host subagents excluded) |
+| `/evolve usage` | per-entry injection counts + exact provider-reported tokens for direct memory/review/planner/wrapup/fate calls (benchmark host subagents excluded) |
 
 Model tools: `evolve_list / add / update / delete / rollback` (`evolve_delete` takes `id` or a batch `ids` array — one refinement, one approval).
 
 For third-party consumers: every applied evolution (gate or manual) appends a structured `evolve_complete` event to `reviews.jsonl` (`src/evolve-event.ts` defines the shape) alongside the human-readable audit records.
 
-`/evolve usage` also reads `evolve/token-usage.jsonl`: exact provider-reported input/cache/output/total tokens for the plugin's direct review, planner, manual-wrapup, and automatic-fate calls. The report covers a retained tail rather than lifetime usage, distinguishes missing provider samples, and explicitly excludes host benchmark subagents, their agent-loop calls, and per-entry injection attribution.
+`/evolve usage` also reads `evolve/token-usage.jsonl`: exact provider-reported input/cache/output/total tokens for the plugin's direct memory-agent, review, planner, manual-wrapup, and automatic-fate calls. The report covers a retained tail rather than lifetime usage, distinguishes missing provider samples, and explicitly excludes host benchmark subagents, their agent-loop calls, and per-entry injection attribution.
 
 Injection shape: prompt notes and delegation specs inject with content (≤6/kind × 180 chars, relevance-ranked). Memories and skills appear as a relevance-ordered directory index (`[memory:type:id] title` hooks, capped at 15 lines with a fold counter) — full text via `evolve_list`. Empty store = zero injected tokens.
 
@@ -77,7 +79,7 @@ Injection shape: prompt notes and delegation specs inject with content (≤6/kin
 | Key | Default | Meaning |
 |---|---|---|
 | `baseDir` | resolved DSH home | root for the `evolve/` stores |
-| `autoReview` | `false` | initial automatic-review default when no runtime switch exists; the listener is always registered |
+| `autoReview` | `false` | initial memory+review pipeline default when no runtime switch exists; the listener is always registered |
 | `reviewIntervalTurns` | `6` | legacy local-fate cadence fallback; successful-turn review no longer waits for this interval |
 | `maxReviewInputChars` | `40000` | trajectory slice handed to the gate |
 | `reviewBudgetTokens` | `4096` | output budget for the gate call |
@@ -95,7 +97,7 @@ Injection shape: prompt notes and delegation specs inject with content (≤6/kin
 | `logToFile` / `logLevel` / `logMaxBytes` | `true` / `1` / 5 MiB | plugin-owned JSONL file log with rotation |
 | `autoRollbackOnReject` | `true` | deterministic rollback after a benchmark rejection |
 | `autoCase` | `true` | failed evolution attempts are captured as draft regression cases (`auto_regression` benchmark) |
-| `reviewModel` | agent's own | optional cheaper model for the gate (`"provider/model"`) |
+| `reviewModel` | agent's own | optional cheaper model for the dedicated memory agent and review gate (`"provider/model"`) |
 | `plannerPrefixCache` | `auto` | Route A session-prefix input when cache evidence exists (`session` always, `off` legacy flat text) |
 | `plannerPrefixMaxChars` | `12000` | session-prefix budget for Route A planning inputs (chars) |
 | `historyRetain` | `{snapshots: 20, refinements: 500, reviews: 500, tokenUsage: 500}` | storage hygiene: snapshots per store, tail lines per store history, shared `reviews.jsonl` tail, and direct-call `token-usage.jsonl` tail |
@@ -120,7 +122,7 @@ paused.
 
 ```bash
 pnpm install && pnpm build   # deps + tsc -> lib/
-pnpm test                    # vitest (675 tests)
+pnpm test                    # vitest (737 tests)
 pnpm test:coverage           # v8 coverage, thresholds enforced in CI
 pnpm lint                    # oxlint src test
 ```
@@ -128,8 +130,8 @@ pnpm lint                    # oxlint src test
 Project layout:
 
 ```
-├── src/                   # engine, tools, commands, gate, fate, benchmark, injection + token usage…
-├── test/                  # vitest suites (43 files)
+├── src/                   # engine, tools, commands, memory agent, gate, fate, benchmark, injection + token usage…
+├── test/                  # vitest suites (44 files)
 ├── lib/                   # build output (tsc)
 ├── docs/
 │   ├── design.md          # full design doc (hardening matrix)

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-675%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-737%20passing-brightgreen)]()
 
 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（`dsh`）的持续自进化插件：一套**版本化、可审计、可回滚**的 harness 状态层——提示词补充、记忆、技能、子代理规格——从会话轨迹中沉淀而来。
 
@@ -19,17 +19,19 @@ Agent 在每个会话里积累可复用经验（重复失败、持久事实、
 
 - **三作用域**与合并语义（global < project < local）：**local** 本会话暂存、**project** 本项目跨会话库、**global** 跨项目——配合机械化晋升守卫，只有可携带、有分量、非重复的知识才能进全局
 - **类型化单条记忆**：每条 memory 带召回类型（`user | feedback | project | reference`）；踩坑（`feedback`）必须含 Why + How to apply
+- **专用后台记忆 Agent**：成功回合通过机械 eligibility 后，有界 ZCode 式 loop 检索冻结的 memory manifest，并经闭集工具提出纯 memory 编辑；不能调用 Agent、MCP、网络，也不能写源码
 - **确定性回滚**：逆操作编辑由已应用结果生成——不靠 LLM 重新猜测
 - **benchmark 闭环**：候选沉淀先经冻结用例 + 独立评分者评估再接受（rubric 加密落盘）
 - **store 卫生**：`/evolve consolidate` 把写入时冲突提示与零使用陈旧条目变成一次批准、完全可逆的批量归档——加 `merge` 可将近重复内容并入幸存原条目
 
 ## 工作原理
 
-1. **沉淀**——模型经 `evolve_add` 创建条目，或自动 review 门禁从成功回合后的增量 snapshot（以及压缩检查点）提议。
-2. **守卫**——代码强制校验：编辑 schema、blast-radius 与作用域一致性、晋升政策（项目专属标记 / 过薄内容 / 近似重复检测 / 凭据筛查保持全局库干净——密钥类内容在所有写入出口被拒，含 mount 物化）。全局 create 与既有条目高度相似（≥0.8）时写入即拒；中等重叠带 `conflictHint` 供后续合并。
-3. **审批**——全局与项目写入需明确人工批准；local 归宿提议先征询后落地。
-4. **应用与注入**——原子应用带快照与审计事件。prompt 补充与委派规格注入系统提示词（封顶、按相关性排序、被证伪条目降权、空 store 零 token）；memory/skill 以按相关性排序的目录索引出现（`[memory:type:id] 标题`钩子）。
-5. **验证与回滚**——benchmark 用冻结用例为候选打分；被拒候选确定性回滚，并自动沉淀为 draft 回归用例（`auto_regression` 基准）。
+1. **沉淀**——模型经 `evolve_add` 创建条目，或自动管线消费成功回合后的增量 snapshot（以及压缩检查点）：先运行专用 memory Agent，再由通用 review/planner 提议非 memory 精炼。
+2. **能力感知的辅助调用**——memory loop、review、planner、wrapup、fate 通过 [`src/llm-text.ts`](src/llm-text.ts) 解析精确 provider/model 能力并使用模型公布的最低开启 reasoning effort；只有没有开启档时才回退关闭档，没有 reasoning 元数据时使用 provider 默认行为。
+3. **守卫**——代码强制校验：编辑 schema、blast-radius 与作用域一致性、晋升政策（项目专属标记 / 过薄内容 / 近似重复检测 / 凭据筛查保持全局库干净——密钥类内容在所有写入出口被拒，含 mount 物化）。全局 create 与既有条目高度相似（≥0.8）时写入即拒；中等重叠带 `conflictHint` 供后续合并。
+4. **审批**——全局与项目写入需明确人工批准；弹窗展示有界结构化编辑 diff 与冲突提示，弹窗丢失/响应畸形会重试，不会被误记为拒绝。
+5. **应用与注入**——memory 批次先完成所有持久化审批，写前重查 abort；后续 scope 失败时补偿回滚先前写入，成功 scope 仍保留快照与审计。prompt 补充与委派规格注入系统提示词（封顶、按相关性排序、被证伪条目降权、空 store 零 token）；memory/skill 以按相关性排序的目录索引出现（`[memory:type:id] 标题`钩子）。
+6. **验证与回滚**——benchmark 用冻结用例为候选打分；被拒候选确定性回滚，并自动沉淀为 draft 回归用例（`auto_regression` 基准）。
 
 ## 安装
 
@@ -62,13 +64,13 @@ dsh plugin add ZK-Andy/dsh-continual-evolve
 | `/evolve goal [objective · done · block]` | 回合驱动的自进化目标 |
 | `/evolve benchmark …` | 用例生命周期、运行、接受决策 |
 | `/evolve pause · resume · status` | 暂停/恢复自动门禁（手动工具不受影响）、门禁状态 |
-| `/evolve usage` | 每条目注入次数 + review/planner/wrapup/fate 直属调用的 provider 精确 token（不含 benchmark 宿主子代理） |
+| `/evolve usage` | 每条目注入次数 + memory/review/planner/wrapup/fate 直属调用的 provider 精确 token（不含 benchmark 宿主子代理） |
 
 模型工具：`evolve_list / add / update / delete / rollback`（`evolve_delete` 支持 `id` 或批量 `ids` 数组——一次 refinement、一次审批）。
 
 第三方消费：每次进化落地（门禁或手动）都会向 `reviews.jsonl` 追加结构化 `evolve_complete` 事件（shape 见 `src/evolve-event.ts`），与人类可读的审计记录并存。
 
-`/evolve usage` 还会读取 `evolve/token-usage.jsonl`：插件直属 review、planner、手动 wrapup 与自动 fate 调用的 provider 精确 input/cache/output/total token。报告只覆盖保留尾部而非终身累计，单独显示 provider 未返回 usage 的调用，并明确排除宿主 benchmark 子代理、其 agent-loop 调用与逐条 memory 注入归因。
+`/evolve usage` 还会读取 `evolve/token-usage.jsonl`：插件直属 memory Agent、review、planner、手动 wrapup 与自动 fate 调用的 provider 精确 input/cache/output/total token。报告只覆盖保留尾部而非终身累计，单独显示 provider 未返回 usage 的调用，并明确排除宿主 benchmark 子代理、其 agent-loop 调用与逐条 memory 注入归因。
 
 注入形态：prompt 补充与委派规格带内容注入（每 kind ≤6 条 × 180 字符，按相关性排序）。memory/skill 以按相关性排序的目录索引出现（`[memory:type:id] 标题`钩子，15 行封顶 + 折叠计数行）——全文经 `evolve_list` 获取。空 store = 零注入 token。
 
@@ -77,7 +79,7 @@ dsh plugin add ZK-Andy/dsh-continual-evolve
 | 键 | 默认 | 含义 |
 |---|---|---|
 | `baseDir` | 解析后的 DSH home | `evolve/` 存储根目录 |
-| `autoReview` | `false` | 没有 runtime 开关时的自动 review 初始默认；监听器始终注册 |
+| `autoReview` | `false` | 没有 runtime 开关时自动 memory+review 管线的初始默认；监听器始终注册 |
 | `reviewIntervalTurns` | `6` | local-fate 的兼容节奏；成功回合 review 不再等待这个间隔 |
 | `maxReviewInputChars` | `40000` | 交给门禁的轨迹切片 |
 | `reviewBudgetTokens` | `4096` | 门禁调用输出预算 |
@@ -95,7 +97,7 @@ dsh plugin add ZK-Andy/dsh-continual-evolve
 | `logToFile` / `logLevel` / `logMaxBytes` | `true` / `1` / 5 MiB | 插件自带 JSONL 文件日志带轮转 |
 | `autoRollbackOnReject` | `true` | benchmark 拒绝后自动确定性回滚 |
 | `autoCase` | `true` | 失败的进化尝试自动沉淀为 draft 回归用例（`auto_regression` 基准） |
-| `reviewModel` | agent 自身 | 门禁可选更便宜的模型（`"provider/model"`） |
+| `reviewModel` | agent 自身 | 专用 memory Agent 与 review 门禁可选更便宜的模型（`"provider/model"`） |
 | `plannerPrefixCache` | `auto` | 有缓存证据时用会话前缀输入（`session` 总是前缀，`off` 保持旧扁平文本） |
 | `plannerPrefixMaxChars` | `12000` | Route A 会话前缀预算（字符） |
 | `historyRetain` | `{snapshots: 20, refinements: 500, reviews: 500, tokenUsage: 500}` | 存储卫生：每 store 快照数、每 store 历史尾行、共享 `reviews.jsonl` 尾行、直属调用 `token-usage.jsonl` 尾行 |
@@ -115,7 +117,7 @@ profile patch 示例：
 
 ```bash
 pnpm install && pnpm build   # 依赖 + tsc -> lib/
-pnpm test                    # vitest（675 例）
+pnpm test                    # vitest（737 例）
 pnpm test:coverage           # v8 覆盖率，CI 强制阈值
 pnpm lint                    # oxlint src test
 ```
@@ -123,8 +125,8 @@ pnpm lint                    # oxlint src test
 目录结构：
 
 ```
-├── src/                   # 引擎、工具、命令、门禁、fate、benchmark、注入 + token 用量…
-├── test/                  # vitest 测试套件（43 个文件）
+├── src/                   # 引擎、工具、命令、memory Agent、门禁、fate、benchmark、注入 + token 用量…
+├── test/                  # vitest 测试套件（44 个文件）
 ├── lib/                   # 构建产物（tsc）
 ├── docs/
 │   ├── design.md          # 完整设计文档（硬化矩阵）

package/lib/approval.d.ts

@@ -1,11 +1,12 @@
 /**
- * Human approval gate for cross-session (global) evolution edits. Forward
- * edits to the shared global store require an explicit human "批准" before
- * they are applied; rollbacks (which restore prior recorded state) do not.
- * The engine itself stays a pure library — this is a policy at the boundary.
+ * Human approval gate for persistent-scope evolution edits. Project and
+ * global edits require an explicit human "批准" before they are applied;
+ * rollbacks (which restore prior recorded state) do not. The engine itself
+ * stays a pure library — this is a policy at the boundary.
  */
 import type { Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
+export type ScopeApprovalDecision = "approved" | "declined";
 export interface QuestionService {
     ask(request: {
         questions: {
@@ -31,6 +32,12 @@ export interface QuestionService {
  * whether that is an error or a fallback.
  */
 export declare function questionServiceOf(ctx: Context): QuestionService | undefined;
+/**
+ * Ask once for a persistent-scope edit. Only a unique, explicit approval
+ * choice is accepted. A missing/ambiguous/unknown answer throws so callers
+ * never interpret a lost or malformed dialog as a durable rejection.
+ */
+export declare function requestScopeApproval(ctx: Context, agent: Agent | undefined, signal: AbortSignal | undefined, scope: "project" | "global", what: string): Promise<ScopeApprovalDecision>;
 /**
  * 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

@@ -7,28 +7,44 @@ 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.
+ * Ask once for a persistent-scope edit. Only a unique, explicit approval
+ * choice is accepted. A missing/ambiguous/unknown answer throws so callers
+ * never interpret a lost or malformed dialog as a durable rejection.
  */
-export async function requireGlobalApproval(ctx, agent, signal, what) {
+export async function requestScopeApproval(ctx, agent, signal, scope, what) {
     const userQuestions = questionServiceOf(ctx);
     if (!userQuestions) {
         throw new Error("global evolution edits require the userQuestions service (load @deepseek-ai/dsh-user-questions)");
     }
+    const storeLabel = scope === "project" ? "本项目跨会话 store" : "跨会话全局 store";
     const answer = await userQuestions.ask({
         questions: [
             {
                 id: "approve-global-evolve",
-                question: `批准写入跨会话全局 store？\n\n${what}`,
+                question: `批准写入${storeLabel}？\n\n${what}`,
                 options: [{ label: "批准" }, { label: "拒绝" }],
             },
         ],
         ...(agent ? { agent } : {}),
         ...(signal ? { signal } : {}),
     });
-    const item = answer.answers?.find((entry) => entry.id === "approve-global-evolve");
-    const approved = item?.selected?.includes("批准") ?? false;
-    if (!approved) {
+    const matching = answer.answers?.filter((entry) => entry.id === "approve-global-evolve") ?? [];
+    if (matching.length !== 1 || !Array.isArray(matching[0]?.selected)) {
+        throw new Error("evolution approval returned no unique explicit decision");
+    }
+    const selected = [...new Set(matching[0]?.selected ?? [])];
+    const known = selected.filter((label) => label === "批准" || label === "拒绝");
+    if (known.length !== 1 || selected.length !== 1) {
+        throw new Error(`evolution approval returned an invalid decision: ${JSON.stringify(selected)}`);
+    }
+    return known[0] === "批准" ? "approved" : "declined";
+}
+/**
+ * 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) {
+    if ((await requestScopeApproval(ctx, agent, signal, "global", what)) !== "approved") {
         throw new Error("global evolution edit rejected by the user");
     }
 }

package/lib/auto.d.ts

@@ -1,8 +1,10 @@
+import type { ScopeApprovalDecision } from "./approval.js";
 import type { Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { HarnessState, RefinementEdit, RefinementProposal } from "./types.js";
 import type { EvolutionEngine } from "./service.js";
 import { type AutoRefineReason } from "./review.js";
+import { type TurnSnapshot } from "./turn-snapshot.js";
 import type { PromotionPolicy } from "./promotion.js";
 import type { PlannerPrefixCacheMode } from "./prefix-cache.js";
 export interface AutoReviewConfig {
@@ -32,6 +34,8 @@ export interface AutoReviewConfig {
      * When absent, the review gate uses the agent's own provider/model.
      */
     reviewModel?: string;
+    /** Dedicated memory-agent writes to project/global require the normal human approval boundary. */
+    requireGlobalApproval?: boolean;
     /**
      * Prefix-cache routing for the gate input (see reviewAutoRefine).
      * Absent mode → auto-detect; absent budget → the default prefix budget.
@@ -74,6 +78,10 @@ export interface GateState {
     completedTurn: number;
     /** Latest turn whose snapshot acquisition was reserved. */
     lastSnapshotTurn: number;
+    /** Latest successful/no-op memory boundary, independent of later review/fate completion. */
+    memoryCheckpoint?: string;
+    /** Per-boundary/scope approval decisions retained until the memory phase settles. */
+    memoryDecisions: Record<string, ScopeApprovalDecision>;
     lastReviewAt: number;
     running: boolean;
     /**
@@ -145,6 +153,22 @@ export declare function loadGateHarnessView(engine: EvolutionEngine, sessionId:
  * 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>;
+/**
+ * Dedicated ZCode-style memory phase. It shares the scheduler snapshot and
+ * snapshot with the general review, but owns its request loop, manifest and
+ * memory-only tool policy. Its phase-specific checkpoint advances after a
+ * successful/no-op memory outcome; later review/fate failures do not replay
+ * old memory decisions, while memory failures leave the boundary retryable.
+ */
+export declare function runMemoryExtractionPhase(ctx: Context, engine: EvolutionEngine, agent: Agent, config: AutoReviewConfig, state: GateState, snapshot: TurnSnapshot, signal?: AbortSignal): Promise<void>;
+/** True when the general planner returned only edits owned by the memory phase. */
+export declare function isDedicatedMemoryOnlyProposal(proposal: RefinementProposal): boolean;
+/**
+ * Remove memory edits from the general auto-review planner. The dedicated
+ * memory phase owns this responsibility and has already run against the same
+ * snapshot; accepting a second memory proposal would reintroduce duplicates.
+ */
+export declare function stripDedicatedMemoryEdits(proposal: RefinementProposal): RefinementProposal;
 /**
  * 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

@@ -30,14 +30,17 @@ import { questionServiceOf } from "./approval.js";
 import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
 import { DEFAULT_REVIEWS_RETAIN, pruneJsonlFile } from "./store.js";
 import { isGateEnabled } from "./runtime.js";
-import { createReviewScheduler } from "./review-scheduler.js";
-import { captureTurnSnapshot } from "./turn-snapshot.js";
+import { compareReviewCursors, createReviewScheduler } from "./review-scheduler.js";
+import { captureTurnSnapshot, sliceTurnSnapshot } from "./turn-snapshot.js";
 import { captureAutoCase } from "./autocase.js";
+import { applyMemoryExtractionProposal, buildMemoryManifest, runMemoryAgent, } from "./memory-agent.js";
 /** Turns a rejected skill candidate stays silent before being offered again. */
 export const SKILL_CONSULT_COOLDOWN_TURNS = 10;
 export function registerAutoReview(ctx, engine, config) {
     const perSession = new Map();
     const schedulers = new Map();
+    const captureTails = new Map();
+    const disposedSessions = new Set();
     const logger = ctx.logger("continual-evolve");
     const reviewsPath = join(engine.baseDir, "evolve", "reviews.jsonl");
     const defaultEnabled = config.enabledByDefault ?? true;
@@ -96,7 +99,7 @@ export function registerAutoReview(ctx, engine, config) {
         return scheduler;
     };
     const captureAndSchedule = (agent, state, reason) => {
-        if (!isGateEnabled(engine.baseDir, defaultEnabled))
+        if (disposedSessions.has(agent.id) || !isGateEnabled(engine.baseDir, defaultEnabled))
             return;
         const turn = state.completedTurn;
         const previousSnapshotTurn = state.lastSnapshotTurn;
@@ -104,15 +107,20 @@ export function registerAutoReview(ctx, engine, config) {
             return;
         if (reason === "turn_snapshot")
             state.lastSnapshotTurn = turn;
-        const cursor = schedulerFor(agent, state).getCursor();
-        void captureTurnSnapshot(ctx, agent, {
-            turn,
-            reason,
-            ...(cursor !== undefined ? { cursor } : {}),
-            maxChars: config.maxInputChars,
-        })
-            .then((snapshot) => schedulerFor(agent, state).schedule(snapshot))
-            .catch((cause) => {
+        const previousCapture = captureTails.get(agent.id) ?? Promise.resolve();
+        const captureTask = previousCapture.then(async () => {
+            if (disposedSessions.has(agent.id) || !isGateEnabled(engine.baseDir, defaultEnabled))
+                return;
+            const cursor = schedulerFor(agent, state).getCursor();
+            const snapshot = await captureTurnSnapshot(ctx, agent, {
+                turn,
+                reason,
+                ...(cursor !== undefined ? { cursor } : {}),
+                maxChars: config.maxInputChars,
+            });
+            if (!disposedSessions.has(agent.id))
+                schedulerFor(agent, state).schedule(snapshot);
+        }).catch((cause) => {
             const message = cause instanceof Error ? cause.message : String(cause);
             logger.warn(`auto-review snapshot failed for ${agent.id}: ${message}`);
             record({
@@ -126,6 +134,7 @@ export function registerAutoReview(ctx, engine, config) {
                 state.lastSnapshotTurn = previousSnapshotTurn;
             }
         });
+        captureTails.set(agent.id, captureTask);
     };
     // DSH emits this awaited boundary when a turn is about to close. The idle
     // transition is the safe point at which to read the durable surface.
@@ -175,8 +184,10 @@ export function registerAutoReview(ctx, engine, config) {
         const agent = payload.agent;
         if (!agent)
             return;
+        disposedSessions.add(agent.id);
         schedulers.get(agent.id)?.shutdown();
         schedulers.delete(agent.id);
+        captureTails.delete(agent.id);
         perSession.delete(agent.id);
     });
     ctx.on("session/event", (session, event) => {
@@ -213,6 +224,7 @@ function stateFor(map, sessionId) {
             turns: 0,
             completedTurn: 0,
             lastSnapshotTurn: 0,
+            memoryDecisions: {},
             lastReviewAt: 0,
             running: false,
             skillRejects: new Map(),
@@ -224,6 +236,21 @@ function stateFor(map, sessionId) {
     }
     return state;
 }
+function advanceMemoryCheckpoint(state, next) {
+    if (state.memoryCheckpoint === undefined) {
+        state.memoryCheckpoint = next;
+        return;
+    }
+    const order = compareReviewCursors(next, state.memoryCheckpoint);
+    if (order === undefined || order > 0)
+        state.memoryCheckpoint = next;
+}
+function rememberMemoryDecision(state, key, decision) {
+    state.memoryDecisions[key] = decision;
+    const keys = Object.keys(state.memoryDecisions);
+    while (keys.length > 128)
+        delete state.memoryDecisions[keys.shift() ?? ""];
+}
 /**
  * The state view the gate and planner judge: the session's local entries
  * merged with the project and global stores, each entry carrying its real
@@ -255,6 +282,7 @@ async function runGate(ctx, engine, agent, config, state, snapshot, record, sign
     }
     state.running = true;
     try {
+        await runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, signal);
         await runReviewPhase(ctx, engine, agent, config, state, snapshot, record, signal);
         // D3: a goal stuck in "blocked" for consecutive gate runs gets one
         // local-fate assessment (the pipeline below), so whatever led the
@@ -295,6 +323,84 @@ export async function runGoalBlockedFate(ctx, engine, agent, config, state, _rea
     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);
 }
+/**
+ * Dedicated ZCode-style memory phase. It shares the scheduler snapshot and
+ * snapshot with the general review, but owns its request loop, manifest and
+ * memory-only tool policy. Its phase-specific checkpoint advances after a
+ * successful/no-op memory outcome; later review/fate failures do not replay
+ * old memory decisions, while memory failures leave the boundary retryable.
+ */
+export async function runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, signal) {
+    const memorySnapshot = state.memoryCheckpoint ? sliceTurnSnapshot(snapshot, state.memoryCheckpoint) : snapshot;
+    if (!memorySnapshot.eligible || !memorySnapshot.trajectory) {
+        advanceMemoryCheckpoint(state, snapshot.cursor);
+        ctx.logger("continual-evolve").info(`memory agent no-op (${snapshot.reason}) [${agent.id}]: no new eligible evidence after checkpoint`);
+        return;
+    }
+    const sessionId = agent.id;
+    const projectKey = snapshot.projectKey ?? projectKeyOf(agent);
+    const baselines = {
+        local: engine.load("local", sessionId),
+        global: engine.load("global", undefined),
+        ...(projectKey ? { project: engine.load("project", projectKey) } : {}),
+    };
+    const manifest = buildMemoryManifest(loadGateHarnessView(engine, sessionId, projectKey ? { projectKey } : undefined));
+    const overrideRoute = parseReviewModel(config.reviewModel, agent.options.provider);
+    const provider = overrideRoute?.provider ?? agent.options.provider;
+    const model = overrideRoute?.model ?? agent.options.model;
+    if (!provider || !model)
+        throw new Error("evolve: no provider/model route for the memory extraction agent");
+    const tokenUsage = {
+        baseDir: engine.baseDir,
+        sessionId,
+        retain: engine.retention.tokenUsage,
+        onError: (cause) => ctx
+            .logger("continual-evolve")
+            .warn(`token-usage ledger failed for ${sessionId}: ${cause instanceof Error ? cause.message : String(cause)}`),
+    };
+    const run = await runMemoryAgent(ctx, {
+        provider,
+        model,
+        manifest,
+        trajectory: memorySnapshot.trajectory,
+        trajectoryEvents: memorySnapshot.events,
+        maxOutputTokens: config.budgetTokens,
+        ...(signal ? { signal } : {}),
+        tokenUsage,
+        ...((config.prefixCacheMode !== undefined || config.prefixMaxChars !== undefined
+            ? {
+                prefixCache: {
+                    ...(config.prefixCacheMode !== undefined ? { mode: config.prefixCacheMode } : {}),
+                    ...(config.prefixMaxChars !== undefined ? { maxChars: config.prefixMaxChars } : {}),
+                },
+            }
+            : {})),
+    });
+    if (run.proposal.edits.length === 0) {
+        advanceMemoryCheckpoint(state, memorySnapshot.cursor);
+        ctx.logger("continual-evolve").info(`memory agent no-op (${snapshot.reason}) [${sessionId}] after ${run.turns} turn(s): ${run.proposal.rationale}`);
+        return;
+    }
+    const source = { sessionId, ...(memorySnapshot.sourceSeqs.length > 0 ? { seqs: [...memorySnapshot.sourceSeqs] } : {}) };
+    const application = await applyMemoryExtractionProposal(ctx, engine, run.proposal, {
+        agent,
+        baselines,
+        ...(projectKey ? { projectKey } : {}),
+        requireApproval: config.requireGlobalApproval ?? true,
+        source,
+        decisionCursor: memorySnapshot.cursor,
+        scopeDecisions: state.memoryDecisions,
+        onScopeDecision: (key, decision) => rememberMemoryDecision(state, key, decision),
+        ...(signal ? { signal } : {}),
+    });
+    for (const result of application.results) {
+        emitEvolveComplete(engine.baseDir, buildEvolveCompleteEvent(result, `memory_agent:${snapshot.reason}`, sessionId), config.reviewsRetain ?? DEFAULT_REVIEWS_RETAIN);
+    }
+    state.memoryCheckpoint = memorySnapshot.cursor;
+    const applied = application.results.reduce((count, result) => count + result.appliedEdits.filter((edit) => edit.applied).length, 0);
+    const declined = application.declinedScopes.length > 0 ? `; declined scopes=${application.declinedScopes.join(",")}` : "";
+    ctx.logger("continual-evolve").info(`memory agent applied ${applied} edit(s) across ${application.results.length} scope batch(es) [${sessionId}] after ${run.turns} turn(s)${declined}: ${run.proposal.rationale}`);
+}
 async function runReviewPhase(ctx, engine, agent, config, state, snapshot, record, signal) {
     const sessionId = agent.id;
     const reason = snapshot.reason;
@@ -345,7 +451,7 @@ async function runReviewPhase(ctx, engine, agent, config, state, snapshot, recor
         record({ sessionId, reason, turnsSinceLastReview, outcome: "declined", rationale: review.rationale });
         return;
     }
-    const proposal = await planWithLlm(ctx, {
+    const plannedProposal = await planWithLlm(ctx, {
         agent,
         state: harnessState,
         history,
@@ -367,6 +473,8 @@ async function runReviewPhase(ctx, engine, agent, config, state, snapshot, recor
             }
             : {})),
     });
+    const proposal = stripDedicatedMemoryEdits(plannedProposal);
+    const memoryOnlyPlan = isDedicatedMemoryOnlyProposal(plannedProposal);
     // Skills are governed resources: an auto-created skill is OFFERED to the
     // user for a decision (固化/不固化) before it lands — the gate never
     // writes a skill silently. Without consent the skill edits are withheld
@@ -385,7 +493,7 @@ async function runReviewPhase(ctx, engine, agent, config, state, snapshot, recor
         logger.info(`auto-review declined (${reason}) [${sessionId}]: no consented edits${withheld} — ${review.rationale}`);
         // P1 auto-case capture: an attempted evolution that never landed is a
         // regression asset. Contained — capture failure must not disturb the gate.
-        if (config.autoCase) {
+        if (config.autoCase && !memoryOnlyPlan) {
             try {
                 const captured = captureAutoCase({
                     baseDir: engine.baseDir,
@@ -422,6 +530,25 @@ async function runReviewPhase(ctx, engine, agent, config, state, snapshot, recor
         notifyAutoReview(ctx, agent, result, turnsSinceLastReview);
     }
 }
+/** True when the general planner returned only edits owned by the memory phase. */
+export function isDedicatedMemoryOnlyProposal(proposal) {
+    return proposal.edits.length > 0 && proposal.edits.every((edit) => edit.kind === "memory");
+}
+/**
+ * Remove memory edits from the general auto-review planner. The dedicated
+ * memory phase owns this responsibility and has already run against the same
+ * snapshot; accepting a second memory proposal would reintroduce duplicates.
+ */
+export function stripDedicatedMemoryEdits(proposal) {
+    const edits = proposal.edits.filter((edit) => edit.kind !== "memory");
+    if (edits.length === proposal.edits.length)
+        return proposal;
+    return {
+        ...proposal,
+        edits,
+        summary: `${proposal.summary} (memory edits owned by dedicated extractor)`,
+    };
+}
 /**
  * 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/index.js

@@ -3,9 +3,10 @@
  *
  * Mounts the evolution engine, registers the model-facing evolve_* tools,
  * the human-facing /evolve command, the system-prompt guidance section, and
- * the automatic review gate. The listener is always registered, while its
- * effective state is controlled by the runtime switch. Successful turns feed
- * incremental snapshots through a per-session serial scheduler.
+ * the automatic memory+review pipeline. The listener is always registered,
+ * while its effective state is controlled by the runtime switch. Successful
+ * turns feed a dedicated memory agent and general review through one
+ * per-session serial scheduler.
  */
 import { join } from "node:path";
 import z from "@deepseek-ai/schemastery";
@@ -194,11 +195,12 @@ export function apply(ctx, config) {
         rubricKey,
         ...(config.historyRetain?.reviews !== undefined ? { reviewsRetain: config.historyRetain.reviews } : {}),
         ...(config.reviewModel ? { reviewModel: config.reviewModel } : {}),
+        requireGlobalApproval: config.requireGlobalApproval ?? true,
         ...(config.plannerPrefixCache ? { prefixCacheMode: config.plannerPrefixCache } : {}),
         ...(config.plannerPrefixMaxChars !== undefined ? { prefixMaxChars: config.plannerPrefixMaxChars } : {}),
     });
     const runtimeDefault = config.autoReview ?? false;
-    ctx.logger("continual-evolve").info(`continual-evolve auto-review registered (default ${runtimeDefault ? "on" : "off"}; successful-turn snapshots; local-fate ${config.localFate ?? true ? "on" : "off"} every ${config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6} turns)`);
+    ctx.logger("continual-evolve").info(`continual-evolve auto-review registered (default ${runtimeDefault ? "on" : "off"}; successful-turn memory agent + general review; local-fate ${config.localFate ?? true ? "on" : "off"} every ${config.fateIntervalTurns ?? config.reviewIntervalTurns ?? 6} turns)`);
     ctx.logger("continual-evolve").info(`continual-evolve mounted (baseDir=${baseDir})`);
 }
 //# sourceMappingURL=index.js.map