dsh-continual-evolve 0.7.5 → 0.8.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-738%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-783%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,14 +19,15 @@ 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**: when `autoReview: true`, 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
+- **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
 
 ## How it works
 
-1. **Sediment** — the model creates entries via `evolve_add`, or (only when `autoReview: true`) the automatic Memory Agent consumes incremental snapshots after successful turns (plus compaction checkpoints). Generic review/planner remains manual unless separately invoked.
+1. **Sediment** — the model creates entries via `evolve_add`, or the automatic Memory Agent consumes incremental snapshots after successful turns. Generic review/planner remains manual unless separately invoked.
 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), use the lowest advertised enabled reasoning effort (falling back to a closing effort only when no enabled level exists), and forward the host session id for provider routing; 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.
@@ -56,6 +57,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,27 +70,28 @@ 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
 
 | Key | Default | Meaning |
 |---|---|---|
 | `baseDir` | resolved DSH home | root for the `evolve/` stores |
-| `autoReview` | `false` | explicit opt-in for the dedicated Memory Agent listener; when true, generic review/planner/fate are not run |
+| `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 |
 | `notifyOnAutoReview` | `true` | visible follow-up notice after an applied gate run |
 | `requireGlobalApproval` | `true` | global and project edits ask for explicit approval |
-| `localFate` | `false` | optional local-entry promote/archive fate assessment; requires `autoReview: true` and an explicit `localFate: true` |
+| `localFate` | `false` | optional local-entry promote/archive fate assessment; unreachable while the listener runs memory-only, so it only affects direct/full callers |
 | `fateIntervalTurns` | follows `reviewIntervalTurns` | minimum turns between fate assessments |
 | `goalBlockedWrapupTurns` | `3` | consecutive blocked-goal gate runs trigger one fate assessment (`0` disables) |
 | `promotionBlockPatterns` | POSIX paths, session ids, `~/.dsh` | content matching these is project-scoped and never promoted to global |
@@ -112,23 +117,29 @@ Example profile patch:
     reviewIntervalTurns: 6
 ```
 
-Automatic evolution is an explicit source-level opt-in. With the default
-`autoReview: false`, the plugin does not register turn/compaction listeners.
-With `autoReview: true`, it registers only the dedicated Memory Agent listener;
-the generic review/planner, prompt/skill writes, and local-fate phases are not
-run automatically. 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. Manual
-`evolve_*` tools and `/evolve` commands remain available. `/evolve pause`,
-`/evolve resume`, and `/evolve status` control or report the Memory Agent
-listener.
+The Memory Agent listener is registered even when `autoReview` is `false` —
+`autoReview` only supplies the initial default, so an install works without
+editing the profile. Use `/evolve resume` to enable successful-turn snapshots
+immediately, `/evolve pause` to suppress new snapshots and model work, and
+`/evolve status` to inspect the configured default plus the current runtime
+state. The runtime switch is stored in `evolve/runtime.json`; manual `evolve_*`
+tools and `/evolve` commands are not paused. Only the Memory Agent runs
+automatically: the generic review/planner, prompt/skill writes, and local-fate
+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. 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 (743 tests)
+pnpm test                    # vitest (783 tests)
 pnpm test:coverage           # v8 coverage, thresholds enforced in CI
 pnpm lint                    # oxlint src test
 ```
@@ -136,8 +147,8 @@ pnpm lint                    # oxlint src test
 Project layout:
 
 ```
-├── src/                   # engine, tools, commands, memory agent, gate, fate, benchmark, injection + token usage…
-├── test/                  # vitest suites (45 files)
+├── src/                   # engine, tools, commands, memory agent, recall, projection, gate, fate, benchmark, injection + token usage…
+├── test/                  # vitest suites (47 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-738%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-783%20passing-brightgreen)]()
 
 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（`dsh`）的持续自进化插件：一套**版本化、可审计、可回滚**的 harness 状态层——提示词补充、记忆、技能、子代理规格——从会话轨迹中沉淀而来。
 
@@ -19,14 +19,15 @@ Agent 在每个会话里积累可复用经验（重复失败、持久事实、
 
 - **三作用域**与合并语义（global < project < local）：**local** 本会话暂存、**project** 本项目跨会话库、**global** 跨项目——配合机械化晋升守卫，只有可携带、有分量、非重复的知识才能进全局
 - **类型化单条记忆**：每条 memory 带召回类型（`user | feedback | project | reference`）；踩坑（`feedback`）必须含 Why + How to apply
-- **专用后台记忆 Agent**：`autoReview: true` 时，成功回合通过机械 eligibility 后才有界 ZCode 式 loop 检索冻结的 memory manifest，并经闭集工具提出纯 memory 编辑；不能调用 Agent、MCP、网络，也不能写源码。该 listener 不运行通用 review/planner/fate
+- **专用后台记忆 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` 可将近重复内容并入幸存原条目
 
 ## 工作原理
 
-1. **沉淀**——模型经 `evolve_add` 创建条目，或仅在 `autoReview: true` 时由专用 Memory Agent 消费成功回合后的增量 snapshot（以及压缩检查点）。通用 review/planner 保持手动，除非另行显式调用。
+1. **沉淀**——模型经 `evolve_add` 创建条目，或由专用 Memory Agent 消费成功回合后的增量 snapshot。通用 review/planner 保持手动，除非另行显式调用。
 2. **能力感知的辅助调用**——memory loop、review、planner、wrapup、fate 通过 [`src/llm-text.ts`](src/llm-text.ts) 解析精确 provider/model 能力并使用模型公布的最低开启 reasoning effort，同时转发 host session id 供 provider 路由；只有没有开启档时才回退关闭档，没有 reasoning 元数据时使用 provider 默认行为。
 3. **守卫**——代码强制校验：编辑 schema、blast-radius 与作用域一致性、晋升政策（项目专属标记 / 过薄内容 / 近似重复检测 / 凭据筛查保持全局库干净——密钥类内容在所有写入出口被拒，含 mount 物化）。全局 create 与既有条目高度相似（≥0.8）时写入即拒；中等重叠带 `conflictHint` 供后续合并。
 4. **审批**——全局与项目写入需明确人工批准；弹窗展示有界结构化编辑 diff 与冲突提示，弹窗丢失/响应畸形会重试，不会被误记为拒绝。
@@ -56,6 +57,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,27 +70,28 @@ 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。
 
 ## 配置
 
 | 键 | 默认 | 含义 |
 |---|---|---|
 | `baseDir` | 解析后的 DSH home | `evolve/` 存储根目录 |
-| `autoReview` | `false` | 专用 Memory Agent listener 的显式 opt-in；为 true 时也不会自动运行通用 review/planner/fate |
+| `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` | 门禁调用输出预算 |
 | `notifyOnAutoReview` | `true` | 门禁应用后发可见跟进通知 |
 | `requireGlobalApproval` | `true` | 全局与项目写入需明确批准 |
-| `localFate` | `false` | 可选的本地条目晋升/归档 fate 评估；需要同时设置 `autoReview: true` 与显式 `localFate: true` |
+| `localFate` | `false` | 可选的本地条目晋升/归档 fate 评估；listener 以 memory-only 运行时不可达，只对直接/完整调用者生效 |
 | `fateIntervalTurns` | 跟随 `reviewIntervalTurns` | 归宿评估的最小回合间隔 |
 | `goalBlockedWrapupTurns` | `3` | 连续阻塞目标的门禁轮数触发一次归宿评估（`0` 关闭） |
 | `promotionBlockPatterns` | POSIX 路径、session id、`~/.dsh` | 内容命中即判定项目专属，永不晋升全局 |
@@ -112,13 +117,13 @@ profile patch 示例：
     reviewIntervalTurns: 6
 ```
 
-自动进化是项目源码层面的显式 opt-in。默认 `autoReview: false` 时，插件不注册回合/压缩监听器。设置 `autoReview: true` 时只注册专用 Memory Agent listener，不自动运行通用 review/planner、prompt/skill 写入或 local fate。Memory 触发采用 ZCode 的轻量 eligibility：单个直接用户文本至少包含 `memoryMinUserWords` 个词（使用 CJK 分词）；空增量、内部 Agent、直接 memory 写入会跳过，压缩不会额外触发 memory-only 管线。手动 `evolve_*` 工具和 `/evolve` 命令仍可用；`/evolve pause`、`/evolve resume`、`/evolve status` 控制或报告 Memory Agent listener。
+即使 `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（743 例）
+pnpm test                    # vitest（783 例）
 pnpm test:coverage           # v8 覆盖率，CI 强制阈值
 pnpm lint                    # oxlint src test
 ```
@@ -126,8 +131,8 @@ pnpm lint                    # oxlint src test
 目录结构：
 
 ```
-├── src/                   # 引擎、工具、命令、memory Agent、门禁、fate、benchmark、注入 + token 用量…
-├── test/                  # vitest 测试套件（45 个文件）
+├── src/                   # 引擎、工具、命令、memory Agent、召回、投影、门禁、fate、benchmark、注入 + token 用量…
+├── test/                  # vitest 测试套件（47 个文件）
 ├── 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/command.d.ts

@@ -17,10 +17,11 @@ export interface CommandRuntimeOptions {
     autoCase: boolean;
     /** Mechanical promotion guards for wrapup/fate (2026-08-22 policy). */
     promotionPolicy: PromotionPolicy;
-    /** Explicit source-level opt-in for the automatic listener. `false` means no wiring. */
+    /**
+     * Initial Memory Agent default from plugin config. The listener is always
+     * registered; this is not a registration gate.
+     */
     autoReview?: boolean;
-    /** The automatic listener runs only the dedicated Memory Agent. */
-    memoryOnly?: boolean;
 }
 export declare function registerEvolveCommand(ctx: Context, engine: EvolutionEngine, opts: CommandGateOptions, runtime: CommandRuntimeOptions): void;
 /**