dsh-continual-evolve 0.7.6 → 0.9.0

package/README.md

@@ -7,7 +7,10 @@
 [![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-738%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-1031%20passing-brightgreen)]()
+[![Coverage · statements](https://img.shields.io/badge/coverage_statements-98%25-brightgreen)]()
+[![Coverage · branches](https://img.shields.io/badge/coverage_branches-92%25-green)]()
+[![Coverage · functions](https://img.shields.io/badge/coverage_functions-99%25-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.
 
@@ -20,6 +23,7 @@ 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**: eligible successful turns feed a bounded ZCode-style loop that 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. The generic review/planner/fate path is not run by this listener
+- **Memory recall, projection, and receipts**: `evolve_recall` reads back full memory content by query/kind/scope/type; every memory apply also materializes a readable `MEMORY.md` index plus one fact file per entry; each extraction lands a unified audit receipt (no-op/applied/declined with duration and turn stats) and only applied outcomes notify the session
 - **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
@@ -56,6 +60,9 @@ Commands (in-session):
 | `/evolve plan [msg]` | run the LLM planner against the store |
 | `/evolve wrapup` | assess this session's local entries: promote / archive / keep |
 | `/evolve archive · unarchive · demote <id>` | hide from injection (data kept, restorable) — `demote` targets global noise |
+| `/evolve recall [scope] <query…>` | targeted memory recall: full content with version, source, and staleness |
+| `/evolve remember <type> [scope] <text…>` | immediately persist one typed memory (`user|feedback|project|reference`) |
+| `/evolve forget [scope] <query…>` | locate one memory and archive it (restorable); ambiguous queries only list |
 | `/evolve consolidate [apply] [merge]` | report (or apply) one batch archive of conflict-hinted + stale zero-use global entries; `merge` folds near-duplicate content into the survivors |
 | `/evolve failures` | aggregated failure classes (gate + benchmark) |
 | `/evolve log [tail N] [session <id>]` | plugin log |
@@ -66,13 +73,13 @@ Commands (in-session):
 | `/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 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).
+Model tools: `evolve_list / add / update / delete / rollback / recall` (`evolve_delete` takes `id` or a batch `ids` array — one refinement, one approval; `evolve_recall` filters by query, kinds, scopes, memory types, and limit, and returns full content with version, source, and staleness).
 
 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 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.
+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_recall` (targeted) or `evolve_list`. Every memory apply also refreshes a readable `MEMORY.md` index plus one fact file per entry in the store directory. Empty store = zero injected tokens.
 
 ## Configuration
 
@@ -81,6 +88,7 @@ Injection shape: prompt notes and delegation specs inject with content (≤6/kin
 | `baseDir` | resolved DSH home | root for the `evolve/` stores |
 | `autoReview` | `false` | initial Memory Agent default when no `evolve/runtime.json` exists yet; the listener is always registered, so this is not a registration gate |
 | `memoryMinUserWords` | `3` | ZCode-style minimum lexical words in one direct user text part; uses CJK-aware segmentation |
+| `sessionCloseDrainMs` | `15000` | session-close bounded drain for in-flight extraction in ms (`0` aborts immediately) |
 | `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 |
@@ -124,22 +132,27 @@ phases are not reachable from this listener. The memory trigger follows ZCode's
 lightweight eligibility: direct user text must contain at least
 `memoryMinUserWords` lexical words (CJK-aware segmentation), while
 empty/internal/direct-memory-write snapshots are skipped; compaction does not
-add a separate memory-only trigger.
+add a separate memory-only trigger. Every extraction writes a unified audit
+receipt (`noop`/`applied`/`declined` with duration and turn/search stats) to
+`reviews.jsonl`; only applied outcomes queue a visible follow-up, and a
+closing session lets in-flight extraction settle up to `sessionCloseDrainMs`
+before aborting.
 
 ## Development
 
 ```bash
 pnpm install && pnpm build   # deps + tsc -> lib/
-pnpm test                    # vitest (742 tests)
+pnpm test                    # vitest (1031 tests)
 pnpm test:coverage           # v8 coverage, thresholds enforced in CI
+pnpm coverage:gaps           # locate uncovered lines per file (read-only)
 pnpm lint                    # oxlint src test
 ```
 
 Project layout:
 
 ```
-├── src/                   # engine, tools, commands, memory agent, gate, fate, benchmark, injection + token usage…
-├── test/                  # vitest suites (44 files)
+├── src/                   # engine, tools, commands, memory agent, recall, projection, gate, fate, benchmark, injection + token usage…
+├── test/                  # vitest suites (50 files)
 ├── lib/                   # build output (tsc)
 ├── docs/
 │   ├── design.md          # full design doc (hardening matrix)

package/README.zh.md

@@ -7,7 +7,10 @@
 [![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-738%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-1031%20passing-brightgreen)]()
+[![Coverage · statements](https://img.shields.io/badge/coverage_statements-98%25-brightgreen)]()
+[![Coverage · branches](https://img.shields.io/badge/coverage_branches-92%25-green)]()
+[![Coverage · functions](https://img.shields.io/badge/coverage_functions-99%25-brightgreen)]()
 
 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（`dsh`）的持续自进化插件：一套**版本化、可审计、可回滚**的 harness 状态层——提示词补充、记忆、技能、子代理规格——从会话轨迹中沉淀而来。
 
@@ -20,6 +23,7 @@ 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、网络，也不能写源码。该 listener 不运行通用 review/planner/fate
+- **记忆召回、投影与回执**：`evolve_recall` 按 query/kind/scope/type 精确读回记忆全文；每次 memory 落盘同时生成可读的 `MEMORY.md` 索引 + 单事实文件；每次提取留统一审计回执（no-op/applied/declined + 耗时与轮次统计），只有实际沉淀才通知会话
 - **确定性回滚**：逆操作编辑由已应用结果生成——不靠 LLM 重新猜测
 - **benchmark 闭环**：候选沉淀先经冻结用例 + 独立评分者评估再接受（rubric 加密落盘）
 - **store 卫生**：`/evolve consolidate` 把写入时冲突提示与零使用陈旧条目变成一次批准、完全可逆的批量归档——加 `merge` 可将近重复内容并入幸存原条目
@@ -56,6 +60,9 @@ dsh plugin add ZK-Andy/dsh-continual-evolve
 | `/evolve plan [msg]` | 对 store 运行 LLM 规划器 |
 | `/evolve wrapup` | 收尾本会话 local 条目：晋升 / 归档 / 保留 |
 | `/evolve archive · unarchive · demote <id>` | 从注入中隐藏（数据保留可恢复）——`demote` 针对全局噪声 |
+| `/evolve recall [scope] <query…>` | 定向记忆召回：全文 + 版本 + 来源 + 过时信号 |
+| `/evolve remember <type> [scope] <text…>` | 立即持久化一条类型化记忆（`user|feedback|project|reference`） |
+| `/evolve forget [scope] <query…>` | 按 query 定位一条记忆并归档（可恢复）；多义只列候选不写 |
 | `/evolve consolidate [apply] [merge]` | 报告（或应用）冲突提示 + 零使用陈旧全局条目的批量归档；`merge` 将近重复内容并入幸存原条目 |
 | `/evolve failures` | 失败类聚合（门禁 + benchmark） |
 | `/evolve log [tail N] [session <id>]` | 插件日志 |
@@ -66,13 +73,13 @@ dsh plugin add ZK-Andy/dsh-continual-evolve
 | `/evolve pause · resume · status` | 暂停/恢复自动门禁（手动工具不受影响）、门禁状态 |
 | `/evolve usage` | 每条目注入次数 + memory/review/planner/wrapup/fate 直属调用的 provider 精确 token（不含 benchmark 宿主子代理） |
 
-模型工具：`evolve_list / add / update / delete / rollback`（`evolve_delete` 支持 `id` 或批量 `ids` 数组——一次 refinement、一次审批）。
+模型工具：`evolve_list / add / update / delete / rollback / recall`（`evolve_delete` 支持 `id` 或批量 `ids` 数组——一次 refinement、一次审批；`evolve_recall` 按 query/kind/scope/memoryType/limit 过滤，返回全文 + 版本 + 来源 + 过时信号）。
 
 第三方消费：每次进化落地（门禁或手动）都会向 `reviews.jsonl` 追加结构化 `evolve_complete` 事件（shape 见 `src/evolve-event.ts`），与人类可读的审计记录并存。
 
 `/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。
+注入形态：prompt 补充与委派规格带内容注入（每 kind ≤6 条 × 180 字符，按相关性排序）。memory/skill 以按相关性排序的目录索引出现（`[memory:type:id] 标题`钩子，15 行封顶 + 折叠计数行）——全文经 `evolve_recall`（精确）或 `evolve_list` 获取。每次 memory 落盘同时刷新 store 目录下的可读 `MEMORY.md` 索引 + 单事实文件。空 store = 零注入 token。
 
 ## 配置
 
@@ -81,6 +88,7 @@ dsh plugin add ZK-Andy/dsh-continual-evolve
 | `baseDir` | 解析后的 DSH home | `evolve/` 存储根目录 |
 | `autoReview` | `false` | 没有 `evolve/runtime.json` 时 Memory Agent 的初始默认；监听器始终注册，因此它不是注册门 |
 | `memoryMinUserWords` | `3` | ZCode 风格：单个直接用户文本至少包含的词数；使用 CJK 分词 |
+| `sessionCloseDrainMs` | `15000` | 会话关闭时在途提取的有界 drain（毫秒，`0` 立即 abort） |
 | `reviewIntervalTurns` | `6` | local-fate 的兼容节奏；成功回合 review 不再等待这个间隔 |
 | `maxReviewInputChars` | `40000` | 交给门禁的轨迹切片 |
 | `reviewBudgetTokens` | `4096` | 门禁调用输出预算 |
@@ -112,22 +120,23 @@ profile patch 示例：
     reviewIntervalTurns: 6
 ```
 
-即使 `autoReview` 为 `false`，Memory Agent 监听器也会注册——`autoReview` 只提供初始默认值，装完即用，无需改 profile。使用 `/evolve resume` 立即开启成功回合 snapshot，使用 `/evolve pause` 抑制新 snapshot 与模型调用，使用 `/evolve status` 查看配置默认值与运行时状态。开关保存在 `evolve/runtime.json`；手动 `evolve_*` 工具和 `/evolve` 命令不受暂停影响。自动运行只有 Memory Agent：通用 review/planner、prompt/skill 写入与 local fate 都不由该 listener 触达。Memory 触发采用 ZCode 的轻量 eligibility：单个直接用户文本至少包含 `memoryMinUserWords` 个词（使用 CJK 分词）；空增量、内部 Agent、直接 memory 写入会跳过，压缩不会额外触发 memory-only 管线。
+即使 `autoReview` 为 `false`，Memory Agent 监听器也会注册——`autoReview` 只提供初始默认值，装完即用，无需改 profile。使用 `/evolve resume` 立即开启成功回合 snapshot，使用 `/evolve pause` 抑制新 snapshot 与模型调用，使用 `/evolve status` 查看配置默认值与运行时状态。开关保存在 `evolve/runtime.json`；手动 `evolve_*` 工具和 `/evolve` 命令不受暂停影响。自动运行只有 Memory Agent：通用 review/planner、prompt/skill 写入与 local fate 都不由该 listener 触达。Memory 触发采用 ZCode 的轻量 eligibility：单个直接用户文本至少包含 `memoryMinUserWords` 个词（使用 CJK 分词）；空增量、内部 Agent、直接 memory 写入会跳过，压缩不会额外触发 memory-only 管线。每次提取都在 `reviews.jsonl` 留统一审计回执（`noop`/`applied`/`declined` + 耗时与轮次/检索统计）；只有实际沉淀才排队前台通知，关闭的会话让在途提取在 `sessionCloseDrainMs` 内收尾再 abort。
 
 ## 开发
 
 ```bash
 pnpm install && pnpm build   # 依赖 + tsc -> lib/
-pnpm test                    # vitest（742 例）
+pnpm test                    # vitest（1031 例）
 pnpm test:coverage           # v8 覆盖率，CI 强制阈值
+pnpm coverage:gaps           # 定位各文件未覆盖行（只读）
 pnpm lint                    # oxlint src test
 ```
 
 目录结构：
 
 ```
-├── src/                   # 引擎、工具、命令、memory Agent、门禁、fate、benchmark、注入 + token 用量…
-├── test/                  # vitest 测试套件（44 个文件）
+├── src/                   # 引擎、工具、命令、memory Agent、召回、投影、门禁、fate、benchmark、注入 + token 用量…
+├── test/                  # vitest 测试套件（50 个文件）
 ├── lib/                   # 构建产物（tsc）
 ├── docs/
 │   ├── design.md          # 完整设计文档（硬化矩阵）

package/lib/auto.d.ts

@@ -4,6 +4,7 @@ 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 ReviewScheduler } from "./review-scheduler.js";
 import { type TurnSnapshot } from "./turn-snapshot.js";
 import type { PromotionPolicy } from "./promotion.js";
 import type { PlannerPrefixCacheMode } from "./prefix-cache.js";
@@ -78,6 +79,12 @@ export interface AutoReviewConfig {
      * window, not the full past).
      */
     reviewsRetain?: number;
+    /**
+     * Session-close bounded drain (P1): how long a disposed session's
+     * in-flight extraction may settle before its owner signal aborts.
+     * Absent → 15s; 0 restores the legacy immediate abort.
+     */
+    sessionCloseDrainMs?: number;
 }
 export interface GateState {
     turns: number;
@@ -114,14 +121,36 @@ export interface GateState {
 }
 /** Turns a rejected skill candidate stays silent before being offered again. */
 export declare const SKILL_CONSULT_COOLDOWN_TURNS = 10;
+/** Default session-close drain budget: an in-flight extraction gets 15s to settle. */
+export declare const SESSION_CLOSE_DRAIN_MS_DEFAULT = 15000;
+/**
+ * Resolve the session-close drain budget: absent/invalid → default, 0 →
+ * immediate abort (legacy). Negative or non-finite values fail back to the
+ * default rather than silently disabling the drain.
+ */
+export declare function resolveSessionCloseDrainMs(raw?: number): number;
+/**
+ * Bounded session-close drain for one scheduler: wait for in-flight work up
+ * to drainMs, then abort the owner signal and drop pending captures. Never
+ * rejects — disposal must not hang the host on a stuck model call, and the
+ * abort below is idempotent when the drain already settled.
+ */
+export declare function drainSchedulerOnDispose(scheduler: Pick<ReviewScheduler<TurnSnapshot>, "drain" | "shutdown">, drainMs: number): Promise<void>;
 export interface ReviewRecord {
     timestamp: string;
     sessionId: string;
     reason: AutoRefineReason;
     turnsSinceLastReview: number;
-    outcome: "approved" | "declined" | "failed" | "assessed" | "deferred" | "skipped" | "armed";
+    outcome: "approved" | "declined" | "failed" | "assessed" | "deferred" | "skipped" | "armed" | "applied" | "noop";
     rationale?: string;
     refinementId?: string;
+    /** P1 extraction stats (§6.7): wall time of the memory phase. */
+    durationMs?: number;
+    /** Extractor loop turns / manifest searches behind this row. */
+    memoryTurns?: number;
+    memorySearches?: number;
+    /** Applied edit count carried by an applied row. */
+    appliedEdits?: number;
 }
 export declare function registerAutoReview(ctx: Context, engine: EvolutionEngine, config: AutoReviewConfig): void;
 /**
@@ -167,7 +196,7 @@ export declare function runGoalBlockedFate(ctx: Context, engine: EvolutionEngine
  * 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>;
+export declare function runMemoryExtractionPhase(ctx: Context, engine: EvolutionEngine, agent: Agent, config: AutoReviewConfig, state: GateState, snapshot: TurnSnapshot, record: (entry: Omit<ReviewRecord, "timestamp">) => void, signal?: AbortSignal): Promise<void>;
 /** True when the general planner returned only edits owned by the memory phase. */
 export declare function isDedicatedMemoryOnlyProposal(proposal: RefinementProposal): boolean;
 /**

package/lib/auto.js

@@ -23,7 +23,7 @@ import { slug } from "./types.js";
 import { planWithLlm } from "./planner.js";
 import { reviewAutoRefine } from "./review.js";
 import { goalServiceOf } from "./goal.js";
-import { notifyAutoReview } from "./notify.js";
+import { notifyAutoReview, notifyMemoryExtraction } from "./notify.js";
 import { runLocalFatePhase } from "./fate.js";
 import { mergeHarnessStates } from "./state.js";
 import { projectKeyOf } from "./project.js";
@@ -38,6 +38,52 @@ import { applyMemoryExtractionProposal, buildMemoryManifest, runMemoryAgent, } f
 import { asLlmSessionId } from "./llm-text.js";
 /** Turns a rejected skill candidate stays silent before being offered again. */
 export const SKILL_CONSULT_COOLDOWN_TURNS = 10;
+/** Default session-close drain budget: an in-flight extraction gets 15s to settle. */
+export const SESSION_CLOSE_DRAIN_MS_DEFAULT = 15000;
+/**
+ * Resolve the session-close drain budget: absent/invalid → default, 0 →
+ * immediate abort (legacy). Negative or non-finite values fail back to the
+ * default rather than silently disabling the drain.
+ */
+export function resolveSessionCloseDrainMs(raw) {
+    if (raw === undefined)
+        return SESSION_CLOSE_DRAIN_MS_DEFAULT;
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0)
+        return SESSION_CLOSE_DRAIN_MS_DEFAULT;
+    return Math.floor(raw);
+}
+/**
+ * Bounded session-close drain for one scheduler: wait for in-flight work up
+ * to drainMs, then abort the owner signal and drop pending captures. Never
+ * rejects — disposal must not hang the host on a stuck model call, and the
+ * abort below is idempotent when the drain already settled.
+ */
+export function drainSchedulerOnDispose(scheduler, drainMs) {
+    if (drainMs <= 0) {
+        try {
+            scheduler.shutdown();
+        }
+        catch {
+            // shutdown is flag-setting plus abort: nothing observable to do
+        }
+        return Promise.resolve();
+    }
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(resolve, drainMs);
+    });
+    const settle = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        try {
+            scheduler.shutdown();
+        }
+        catch {
+            // same as above — the abort is best-effort by design
+        }
+    };
+    return Promise.race([scheduler.drain(), timeout]).then(settle, settle);
+}
 export function registerAutoReview(ctx, engine, config) {
     const perSession = new Map();
     const schedulers = new Map();
@@ -82,7 +128,7 @@ export function registerAutoReview(ctx, engine, config) {
             }
             try {
                 if (config.memoryOnly) {
-                    await runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, signal);
+                    await runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, record, signal);
                 }
                 else {
                     await runGate(ctx, engine, agent, config, state, snapshot, record, signal);
@@ -193,10 +239,17 @@ export function registerAutoReview(ctx, engine, config) {
         if (!agent)
             return;
         disposedSessions.add(agent.id);
-        schedulers.get(agent.id)?.shutdown();
+        const scheduler = schedulers.get(agent.id);
         schedulers.delete(agent.id);
         captureTails.delete(agent.id);
         perSession.delete(agent.id);
+        if (scheduler) {
+            // Bounded drain (P1): an in-flight extraction gets drainMs to
+            // settle so its result is not lost on session close; afterwards
+            // the owner signal aborts. Fire-and-forget — disposal must never
+            // hang the host, and the helper never rejects.
+            void drainSchedulerOnDispose(scheduler, resolveSessionCloseDrainMs(config.sessionCloseDrainMs));
+        }
     });
     ctx.on("session/event", (session, event) => {
         // ZCode schedules extraction from successful turns, not from compaction.
@@ -295,7 +348,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 runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, record, 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
@@ -343,14 +396,27 @@ export async function runGoalBlockedFate(ctx, engine, agent, config, state, _rea
  * 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) {
+export async function runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, record, signal) {
+    const sessionId = agent.id;
+    const turnsSinceLastReview = state.turns - state.lastReviewAt;
+    const startedAt = Date.now();
     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`);
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "noop",
+            rationale: `memory no-op (${snapshot.reason}): no new eligible evidence after checkpoint`,
+            durationMs: Date.now() - startedAt,
+            memoryTurns: 0,
+            memorySearches: 0,
+            appliedEdits: 0,
+        });
         return;
     }
-    const sessionId = agent.id;
     const projectKey = snapshot.projectKey ?? projectKeyOf(agent);
     const baselines = {
         local: engine.load("local", sessionId),
@@ -393,6 +459,17 @@ export async function runMemoryExtractionPhase(ctx, engine, agent, config, state
     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}`);
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "noop",
+            rationale: `memory no-op (${snapshot.reason}) after ${run.turns} turn(s): ${run.proposal.rationale}`,
+            durationMs: Date.now() - startedAt,
+            memoryTurns: run.turns,
+            memorySearches: run.searches,
+            appliedEdits: 0,
+        });
         return;
     }
     const source = { sessionId, ...(memorySnapshot.sourceSeqs.length > 0 ? { seqs: [...memorySnapshot.sourceSeqs] } : {}) };
@@ -413,7 +490,48 @@ export async function runMemoryExtractionPhase(ctx, engine, agent, config, state
     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(",")}` : "";
+    const durationMs = Date.now() - startedAt;
+    for (const result of application.results) {
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "applied",
+            rationale: `memory applied (${snapshot.reason}) after ${run.turns} turn(s): ${run.proposal.rationale}${declined}`,
+            refinementId: result.id,
+            durationMs,
+            memoryTurns: run.turns,
+            memorySearches: run.searches,
+            appliedEdits: result.appliedEdits.filter((edit) => edit.applied).length,
+        });
+    }
+    if (application.declinedScopes.length > 0) {
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "declined",
+            rationale: `memory scopes declined (${snapshot.reason}): ${application.declinedScopes.join(",")}`,
+            durationMs,
+            memoryTurns: run.turns,
+            memorySearches: run.searches,
+            appliedEdits: 0,
+        });
+    }
     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}`);
+    // Visibility (P1 unified receipt): only applied outcomes wake the agent
+    // with a follow-up — and only on the turn path, never mid-compaction.
+    // No-op and declined-only runs stay audit-only (reviews.jsonl).
+    if (config.notifyOnAutoReview && snapshot.reason === "turn_snapshot" && applied > 0) {
+        notifyMemoryExtraction(ctx, agent, {
+            outcome: "applied",
+            results: application.results,
+            ...(application.declinedScopes.length > 0 ? { declinedScopes: [...application.declinedScopes] } : {}),
+            turns: run.turns,
+            searches: run.searches,
+            durationMs,
+        });
+    }
 }
 async function runReviewPhase(ctx, engine, agent, config, state, snapshot, record, signal) {
     const sessionId = agent.id;

package/lib/benchmark-command.js

@@ -106,7 +106,7 @@ export async function executeBenchmarkCommand(ctx, engine, invocation, rest, run
             for (const d of board.decisions) {
                 lines.push(`decision: ${d.accepted ? "ACCEPTED" : "rejected"} ${d.candidateLabel} — ${d.reasons.join("; ") || "ok"}`);
             }
-            return success(lines.join("\n") || "(empty scoreboard)");
+            return success(lines.join("\n"));
         }
         case "run": {
             const bid = stripAngleBrackets(args[0] ?? "");

package/lib/command.js

@@ -1,5 +1,6 @@
-import { ARCHIVED_AT_KEY } from "./types.js";
+import { ARCHIVED_AT_KEY, MEMORY_TYPE_KEY } from "./types.js";
 import { formatHarnessStateForPrompt, historyForPrompt } from "./render.js";
+import { compactText } from "./render.js";
 import { planWithLlm } from "./planner.js";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -18,6 +19,7 @@ import { projectKeyOf } from "./project.js";
 import { loadUsage, getUsageCount } from "./usage.js";
 import { loadGateRuntime, saveGateRuntime } from "./runtime.js";
 import { planConsolidation } from "./consolidate.js";
+import { formatRecallResult, recallMemories, RECALL_MEMORY_TYPES } from "./recall.js";
 import { loadTokenUsage, renderTokenUsageReport } from "./token-usage.js";
 const USAGE = `Usage:
   /evolve                  show this help and the current local store
@@ -30,6 +32,12 @@ const USAGE = `Usage:
   /evolve archive <id> [global]   hide an entry from injection (data kept, restorable)
   /evolve unarchive <id> [global] restore an archived entry
   /evolve demote <id>             hide a (global) entry from injection, keep data
+  /evolve recall <query...> [scope] targeted memory recall: full content with version,
+                                   source, and staleness (same engine as the evolve_recall tool)
+  /evolve remember <type> [scope] <text...>
+                                   immediately persist one memory (type = user|feedback|project|reference;
+                                   feedback/project text must carry Why + How; default scope local)
+  /evolve forget [scope] <query...> locate one memory by query and archive it (restorable via /evolve unarchive)
   /evolve consolidate [apply] [merge]
                                   report (or apply) a batch archive of conflict-hinted
                                   and stale zero-use global entries; "merge" folds
@@ -206,6 +214,90 @@ async function executeEvolveCommand(ctx, engine, invocation, opts, runtime) {
                 }, { scope });
                 return success(renderResult(result));
             }
+            case "recall": {
+                // Human counterpart of the evolve_recall tool: same engine,
+                // same filters (memory kind, one scope or all three).
+                const { scope, rest: after } = scopeArg(rest);
+                const explicitScope = rest.length > 0 && (rest[0] === "global" || rest[0] === "project" || rest[0] === "local");
+                const query = after.join(" ");
+                const result = recallMemories(engine, { sessionId, projectKey: projectKeyOf(invocation.agent) ?? undefined }, { kinds: ["memory"], ...(explicitScope ? { scopes: [scope] } : {}), ...(query ? { query } : {}), limit: 10 });
+                return success(formatRecallResult(result, query || undefined));
+            }
+            case "remember": {
+                // Immediate manual memory path (P1 §6.6): one fact, explicit
+                // type, straight into the engine — validation, snapshot,
+                // versioning, and approval behave exactly like any other
+                // write. feedback/project text must already carry Why + How;
+                // the engine rejects it loudly otherwise.
+                const type = rest[0] ?? "";
+                if (!RECALL_MEMORY_TYPES.includes(type)) {
+                    return error(`remember requires a memory type: user|feedback|project|reference.\nExample: /evolve remember feedback local 对方偏好深色主题。Why：…… How to apply：……\n${USAGE}`);
+                }
+                const maybeScope = rest[1] ?? "";
+                const scoped = maybeScope === "global" || maybeScope === "project" || maybeScope === "local";
+                const scope = scoped ? maybeScope : "local";
+                const text = (scoped ? rest.slice(2) : rest.slice(1)).join(" ").trim();
+                if (!text) {
+                    return error(`remember requires the memory text after the type.\n${USAGE}`);
+                }
+                const storeId = storeIdForCommand(scope, invocation);
+                if ((scope === "global" || scope === "project") && opts.requireGlobalApproval) {
+                    await requireGlobalApproval(ctx, invocation.agent, invocation.signal, `/evolve remember ${type} → ${scope} store: ${compactText(text, 120)}`);
+                }
+                const result = engine.apply(scope, storeId, {
+                    summary: `remember: ${compactText(text, 80)}`,
+                    rationale: "Human-invoked immediate memory via /evolve remember.",
+                    expectedOutcome: "The fact is persisted as a typed memory entry.",
+                    edits: [{
+                            action: "create",
+                            kind: "memory",
+                            title: compactText(text, 80),
+                            content: text,
+                            metadata: { [MEMORY_TYPE_KEY]: type },
+                        }],
+                }, { scope });
+                return success(renderResult(result));
+            }
+            case "forget": {
+                // Manual forget path (P1 §6.6): locate by query, archive the
+                // single match (restorable via unarchive). An ambiguous query
+                // lists candidates instead of archiving — a silent multi-
+                // archive would look like success while hiding too much.
+                const { scope, rest: after } = scopeArg(rest);
+                const explicitScope = rest.length > 0 && (rest[0] === "global" || rest[0] === "project" || rest[0] === "local");
+                const query = after.join(" ").trim();
+                if (!query) {
+                    return error(`forget requires a query to locate the memory.\n${USAGE}`);
+                }
+                const recalled = recallMemories(engine, { sessionId, projectKey: projectKeyOf(invocation.agent) ?? undefined }, { query, kinds: ["memory"], ...(explicitScope ? { scopes: [scope] } : {}), limit: 6, includeArchived: false });
+                if (recalled.hits.length === 0) {
+                    return error(`no memory matches "${query}"${recalled.notes.length > 0 ? ` (${recalled.notes.join("; ")})` : ""} — try fewer words, or /evolve list to browse.`);
+                }
+                if (recalled.hits.length > 1) {
+                    const list = recalled.hits.map((hit) => `- [${hit.scope}:${hit.id}] ${hit.title}`).join("\n");
+                    return success(`"${query}" matches ${recalled.hits.length} memories — refine the query so exactly one matches, then forget archives it:\n${list}`);
+                }
+                const hit = recalled.hits[0];
+                const state = engine.load(hit.scope, hit.scope === "local" ? sessionId : hit.scope === "project" ? (projectKeyOf(invocation.agent) ?? undefined) : undefined);
+                const entry = state.entries.memory[hit.id];
+                if (!entry) {
+                    return error(`memory ${hit.scope}:${hit.id} vanished since recall — run /evolve forget again.`);
+                }
+                const result = engine.apply(hit.scope, hit.scope === "local" ? sessionId : hit.scope === "project" ? (projectKeyOf(invocation.agent) ?? undefined) : undefined, {
+                    summary: `forget: archive memory ${hit.scope}:${hit.id}`,
+                    rationale: `Human-invoked forget via /evolve forget "${query}".`,
+                    expectedOutcome: "The entry is hidden from injection (data kept; restorable via /evolve unarchive).",
+                    edits: [{
+                            action: "update",
+                            kind: "memory",
+                            id: hit.id,
+                            title: entry.title,
+                            content: entry.content,
+                            metadata: { ...entry.metadata, [ARCHIVED_AT_KEY]: new Date().toISOString() },
+                        }],
+                }, { scope: hit.scope });
+                return success(`forgot [${hit.scope}:${hit.id}] ${hit.title} (archived — restore with /evolve unarchive ${hit.id}${hit.scope === "local" ? "" : ` ${hit.scope}`})\n${renderResult(result)}`);
+            }
             case "consolidate": {
                 // R3: deterministic global-store hygiene. Report by default;
                 // `apply` re-scans fresh state and lands the whole batch as ONE

package/lib/fate.js

@@ -241,7 +241,10 @@ export async function runLocalFatePhase(ctx, engine, agent, config, state, reaso
     const plan = planLocalFates(assessment.items, candidates, globalState, config.promotionPolicy);
     const needsDialog = plan.promotable.length + plan.splits.length + plan.reviewArchives.length > 0;
     let consent = { approved: false, asked: false, reason: "nothing-to-ask" };
-    if (reason !== "compact" && needsDialog) {
+    // Turn-path tightening (2026-09-25): turn_snapshot/turn_interval never open
+    // a dialog — governed actions are deferred to `/evolve wrapup`. Only an
+    // explicit goal_blocked signal (own streak counter) may consult.
+    if (reason === "goal_blocked" && needsDialog) {
         consent = await consultLocalFates(ctx, agent, plan, state);
     }
     if (consent.approved) {
@@ -255,9 +258,6 @@ export async function runLocalFatePhase(ctx, engine, agent, config, state, reaso
             rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
             refinementId: results.map((result) => result.id).join(","),
         });
-        if (config.notifyOnAutoReview && (reason === "turn_snapshot" || reason === "turn_interval") && applied.length > 0) {
-            notifyFateApplied(ctx, agent, applied);
-        }
         return;
     }
     if (consent.reason === "declined" || consent.reason === "unavailable" || consent.reason === "error") {
@@ -273,18 +273,18 @@ export async function runLocalFatePhase(ctx, engine, agent, config, state, reaso
         });
         return;
     }
-    if (reason === "compact" && needsDialog) {
-        // Compaction: no dialog. Only deterministic silent archives apply;
-        // governed actions are deferred with an audit record.
+    if (needsDialog && reason !== "goal_blocked") {
+        // Turn/compact path: no dialog. Only deterministic silent archives apply;
+        // governed actions are deferred with an audit record pointing at wrapup.
         const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "silent-only");
         if (applied.length > 0) {
-            logger.info(`auto-review local-fate (compact) [${sessionId}]: silent-archived ${applied.length} — ${assessment.rationale}`);
+            logger.info(`auto-review local-fate (${reason}) [${sessionId}]: silent-archived ${applied.length} — ${assessment.rationale}`);
             record({
                 sessionId,
                 reason,
                 turnsSinceLastReview: turnsSinceFate,
                 outcome: "approved",
-                rationale: `fate (compact): ${assessment.rationale} (${applied.join("; ")})`,
+                rationale: `fate (${reason}): ${assessment.rationale} (${applied.join("; ")})`,
                 refinementId: results.map((result) => result.id).join(","),
             });
         }
@@ -293,7 +293,7 @@ export async function runLocalFatePhase(ctx, engine, agent, config, state, reaso
             reason,
             turnsSinceLastReview: turnsSinceFate,
             outcome: "deferred",
-            rationale: `fate (compact): ${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives deferred — run /evolve wrapup for a full session exit`,
+            rationale: `fate (${reason}): ${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives deferred — run /evolve wrapup for a full session exit`,
         });
         return;
     }