dsh-continual-evolve 0.15.0 → 0.15.1

package/README.md

@@ -7,9 +7,9 @@ English | [中文](README.zh.md)
 [![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-168%20passing-brightgreen)]()
-[![Coverage · statements](https://img.shields.io/badge/coverage_statements-96%25-brightgreen)]()
-[![Coverage · branches](https://img.shields.io/badge/coverage_branches-90%25-green)]()
+[![Tests](https://img.shields.io/badge/tests-173%20passing-brightgreen)]()
+[![Coverage · statements](https://img.shields.io/badge/coverage_statements-97%25-brightgreen)]()
+[![Coverage · branches](https://img.shields.io/badge/coverage_branches-91%25-green)]()
 [![Coverage · functions](https://img.shields.io/badge/coverage_functions-100%25-brightgreen)]()
 
 A workspace-memory plugin for the [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (`dsh`): every memory lives in one central SQLite database (`~/.dsh/evolve/memory.db`, rows partitioned by workspace), the index is injected at session start, and the plugin's code is the literal **sole writer** — the model proposes, code gates and lands.
@@ -21,8 +21,8 @@ Reusable experience gathered in one session (user preferences, pitfalls, project
 ## How it works
 
 1. **Session-start injection** — the plugin registers a single system-prompt section: the workspace's memory index as a store query (hooks only, whole-line truncated over budget, ordered feedback > user > reference), the central-library path, and a three-line guide. The section is computed once per session and reused byte-for-byte, keeping the system prompt stable and the prompt cache warm; an empty store costs zero tokens.
-2. **Two tools, one writer** — `memory_write` (create/update/delete) is the explicit path for "remember …" / "forget …": every proposal passes the code gates (id shape, type enum, the feedback Why/How contract, secret screening carried over from v1, 64KB body cap) inside one transaction. `memory_read` fetches bodies and searches by keyword — the injected index carries hooks only. On hosts without the tools service the plugin degrades to "tell the user" phrasing and stays functional.
-3. **Proposal-based extraction** — the only background automation, audited in the `extraction_log`: every `agent/turn-stopping` rearms an idle debounce (default 10 min, `memoryIndex.debounceMin`, single-flight with burst coalescing; `compaction/start` and session close flush). A run reads the session increment since its cursor, feeds FTS-similar existing memories to one LLM call, and the model's structured proposal lands through the same gates; failures and rejections never advance the cursor. Internal agents, empty increments, turns without real user prose, and turns that already carried an explicit `memory_write` are mechanically skipped — and every skip is ledgered.
+2. **Two tools, one writer** — `memory_write` (create/update/delete) is the explicit path for "remember …" / "forget …": every proposal passes the code gates (id shape, type enum, the feedback Why/How contract, secret screening carried over from v1, 64KB body cap) inside one transaction. `memory_read` fetches bodies by id and searches by keyword — whitespace-separated terms are AND-combined, with literal substring matching for short terms and whenever the trigram index misses; the injected index carries hooks only. On hosts without the tools service the plugin degrades to "tell the user" phrasing and stays functional.
+3. **Proposal-based extraction** — the only background automation, audited in the `extraction_log`: every `agent/turn-stopping` schedules that session's boundary, with state kept **per session** (a run in flight keeps only its newest boundary — coalescing, not queueing; `compaction/start` and session close drain it) and **no idle timer**. A run reads the session increment since its cursor, feeds FTS-similar existing memories to one LLM call, and the model's structured proposal lands through the same gates; failures and rejections never advance the cursor. Internal agents, empty increments, turns without real user prose, and turns that already carried an explicit `memory_write` are mechanically skipped — and every skip is ledgered.
 4. **Rollback is a ledger, not a mechanism** — every mutation lands an `extraction_log` row with full before/after snapshots; undo means rewriting the `before` values. A hygiene pass rides on every applied run: orphan FTS rows are dropped and secret-bearing rows are quarantined (hidden, never deleted). The read-only card surfaces quarantine anomalies.
 5. **Read-only card** — mounted on the plugin's page in the official plugin manager (the `plugins.bundle.config` slot; hosts without it silently degrade to no card), shaped like the market's own settings card and aligned with ZCode's Settings → Memory viewer: a dropdown scope selector over the store's workspace partitions, a search box, per-entry relative updated times, click-to-preview bodies (5 MiB cap), and patrol warnings. Localized through the host's `locale/*.json` metadata channel; host theme tokens, the `Button` primitive, and zh/en copy that tracks the DSH language. The card is a request-time projection of the database and has no edit path.
 
@@ -54,8 +54,7 @@ No commands. On the first session after restart the index is injected automatica
 | `memoryIndex.guide` | `true` | Inject the guide (zero tokens when off and the index is empty) |
 | `memoryIndex.order` | `400` | Section order (upstream named slots start at `PLAN_POLICY=500`) |
 | `memoryIndex.maxChars` | `6000` | Hard character budget for the injected index |
-| `memoryIndex.extraction` | `true` | The proposal-based extraction run |
-| `memoryIndex.debounceMin` | `10` | Idle debounce minutes after a turn (0 = run every turn) |
+| `memoryIndex.extraction` | `true` | The proposal-based extraction run (turn-level, per-session slots, no idle timer) |
 | `memoryCard.enabled` | `true` | Read-only memory card in the official plugin manager (degrades to no card when the host lacks `webServer`/`plugins.bundle.config`) |
 
 Profile patch example:
@@ -65,16 +64,17 @@ Profile patch example:
   config:
     memoryIndex:
       maxChars: 8000
-      debounceMin: 5
+      extraction: true
 ```
 
 ## Development
 
 ```bash
-pnpm install && pnpm build   # deps + tsc -> lib/
-pnpm test                    # vitest (168 tests)
+pnpm install && pnpm build   # deps + clean build -> lib/
+pnpm test                    # vitest (173 tests)
 pnpm test:coverage           # v8 coverage, CI-enforced thresholds
 pnpm lint                    # oxlint src test client
+pnpm check:pack              # published-artifact consistency (also runs on prepack)
 ```
 
 Layout:
@@ -88,7 +88,7 @@ Layout:
 │   ├── memory-section.ts   # injection: store query / truncate / session freeze
 │   ├── memory-guide.ts     # the main-session guide (three lines)
 │   ├── memory-tools.ts     # memory_write + memory_read (host-shaped definitions)
-│   ├── extraction.ts       # runner + scheduler (debounce, single-flight, flush)
+│   ├── extraction.ts       # runner + per-session scheduler (turn-level, no idle timer)
 │   ├── extraction-surface.ts # trajectory slicing: cursor, eligibility, serialization
 │   ├── extraction-prompt.ts  # the extraction prompt + answer parsing
 │   ├── import-md.ts        # lossless legacy markdown migration

package/README.zh.md

@@ -7,9 +7,9 @@
 [![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-168%20passing-brightgreen)]()
-[![Coverage · statements](https://img.shields.io/badge/coverage_statements-96%25-brightgreen)]()
-[![Coverage · branches](https://img.shields.io/badge/coverage_branches-90%25-green)]()
+[![Tests](https://img.shields.io/badge/tests-173%20passing-brightgreen)]()
+[![Coverage · statements](https://img.shields.io/badge/coverage_statements-97%25-brightgreen)]()
+[![Coverage · branches](https://img.shields.io/badge/coverage_branches-91%25-green)]()
 [![Coverage · functions](https://img.shields.io/badge/coverage_functions-100%25-brightgreen)]()
 
 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（`dsh`）的工作区记忆插件：全部记忆住在一个中央 SQLite 库里（`~/.dsh/evolve/memory.db`，按工作区路径行分区），会话开局注入索引，插件的代码是字面意义的**唯一写者**——模型提议，代码门禁后落盘。
@@ -21,8 +21,8 @@ Agent 每个会话积累的可复用经验（用户偏好、踩坑教训、项
 ## 工作原理
 
 1. **开局注入** —— 插件只注册一个 system-prompt section：注入本工作区的记忆索引（查库结果，只含钩子，超预算按整行截断，feedback > user > reference 排序）、中央库路径、三行指南。该 section 每会话只算一次并逐字节复用，system prompt 稳定、prompt cache 持续命中；空 store 零 token。
-2. **两个工具，一个写者** —— `memory_write`（create/update/delete）承接显式的"记住……"/"忘掉……"：每条提案过代码门禁（id 规范、type 枚举、feedback 的 Why/How 契约、v1 移植的 secret 筛查、64KB 正文上限）后在一个事务内落盘。`memory_read` 按 id 取正文、按关键词检索——注入索引只有钩子。宿主没有工具服务时降级为"告诉用户"措辞，注入不受影响。
-3. **提案制提取** —— 插件唯一的后台自动化，全程 `extraction_log` 可对账：每个 `agent/turn-stopping` 重置空闲去抖计时器（默认 10 分钟，`memoryIndex.debounceMin`，单飞行合并突发；`compaction/start` 与会话收尾强制 flush）。一次运行读取该会话游标之后的轨迹增量，用 FTS 取相似既有记忆喂给一次 LLM 调用，模型的结构化提案过同一套门禁落盘；失败与被拒不推游标，下次触发重试。内部 agent、空增量、无真实用户文本的轮次、当轮已有显式 `memory_write` 的轮次机械跳过——每次跳过都记账。
+2. **两个工具，一个写者** —— `memory_write`（create/update/delete）承接显式的"记住……"/"忘掉……"：每条提案过代码门禁（id 规范、type 枚举、feedback 的 Why/How 契约、v1 移植的 secret 筛查、64KB 正文上限）后在一个事务内落盘。`memory_read` 按 id 取正文、按关键词检索——空格分隔的关键词取 AND，短词与 trigram 未命中时回退字面子串匹配；注入索引只有钩子。宿主没有工具服务时降级为"告诉用户"措辞，注入不受影响。
+3. **提案制提取** —— 插件唯一的后台自动化，全程 `extraction_log` 可对账：每个 `agent/turn-stopping` 调度**该会话自己**的边界，状态按会话隔离（运行中只保留最新边界——合并而非排队；`compaction/start` 与会话收尾触发 drain），**没有空闲计时器**。一次运行读取该会话游标之后的轨迹增量，用 FTS 取相似既有记忆喂给一次 LLM 调用，模型的结构化提案过同一套门禁落盘；失败与被拒不推游标，下次触发重试。内部 agent、空增量、无真实用户文本的轮次、当轮已有显式 `memory_write` 的轮次机械跳过——每次跳过都记账。
 4. **回滚靠账本，不靠机制** —— 每次变更落一条带 before/after 全文快照的 `extraction_log` 行；undo 就是取 before 重写。每次应用后随跑一次巡检：孤儿 FTS 行清除、含密钥条目隔离（隐藏，不物理删除）。只读卡片显形巡检异常。
 5. **只读卡片** —— 挂在官方插件管理的本 bundle 页面（`plugins.bundle.config` slot，老宿主自动降级为无卡片）：形态对齐市场自家设置卡，内容对齐 ZCode 设置的记忆选项卡——下拉作用域选择器列出库里的工作区分区、搜索框、每条记忆的相对更新时间、点击行内展开正文预览（5 MiB 上限）、巡检异常警告。显示名与描述走宿主 `locale/*.json` 通道双语；宿主主题 token、`Button` 原语、中英文案跟随 DSH 语言。卡片是数据库的请求时投影，没有编辑路径。
 
@@ -54,8 +54,7 @@ dsh plugin add ZK-Andy/dsh-continual-evolve
 | `memoryIndex.guide` | `true` | 是否注入指南（关闭且索引为空时该 section 零 token） |
 | `memoryIndex.order` | `400` | section 顺序（上游命名槽位自 `PLAN_POLICY=500` 起） |
 | `memoryIndex.maxChars` | `6000` | 注入索引的硬字符预算 |
-| `memoryIndex.extraction` | `true` | 提案制提取运行 |
-| `memoryIndex.debounceMin` | `10` | 轮末空闲去抖分钟数（0 = 每轮即跑） |
+| `memoryIndex.extraction` | `true` | 提案制提取运行（轮级、按会话分槽、无空闲计时器） |
 | `memoryCard.enabled` | `true` | 官方插件管理内的只读记忆卡片（宿主缺 `webServer`/`plugins.bundle.config` 时自动降级为无卡片） |
 
 profile patch 示例：
@@ -65,16 +64,17 @@ profile patch 示例：
   config:
     memoryIndex:
       maxChars: 8000
-      debounceMin: 5
+      extraction: true
 ```
 
 ## 开发
 
 ```bash
-pnpm install && pnpm build   # 依赖 + tsc -> lib/
-pnpm test                    # vitest（168 例）
+pnpm install && pnpm build   # 依赖 + 干净构建 -> lib/
+pnpm test                    # vitest（173 例）
 pnpm test:coverage           # v8 覆盖率，CI 强制阈值
 pnpm lint                    # oxlint src test client
+pnpm check:pack              # 发布产物一致性（prepack 也会跑）
 ```
 
 目录结构：
@@ -88,7 +88,7 @@ pnpm lint                    # oxlint src test client
 │   ├── memory-section.ts   # 注入：查库 / 截断 / 会话冻结
 │   ├── memory-guide.ts     # 主会话指南（三行）
 │   ├── memory-tools.ts     # memory_write + memory_read（宿主形状定义）
-│   ├── extraction.ts       # 运行器 + 调度器（去抖、单飞行、flush）
+│   ├── extraction.ts       # 运行器 + 按会话分槽的调度器（轮级、无空闲计时器）
 │   ├── extraction-surface.ts # 轨迹切片：游标、资格判定、序列化
 │   ├── extraction-prompt.ts  # 提取 prompt + 应答解析
 │   ├── import-md.ts        # 旧版 markdown 无损迁移

package/lib/extraction.d.ts

@@ -46,15 +46,11 @@ export interface SchedulerHost {
         warn(message: string): void;
     };
 }
-export interface SchedulerOptions {
-    /** Idle debounce in minutes (default 10); 0 fires on every turn. */
-    debounceMin?: number;
-}
 /**
  * Wire the extraction triggers onto the host context. Returns a disposer
- * that removes the listeners and clears the timer. The scheduler is the
- * only background automation the plugin runs, and it is bounded by design:
- * one timer, one in-flight run, one pending slot.
+ * that removes the listeners. The scheduler is the only background
+ * automation the plugin runs, and it is bounded by design: one boundary and
+ * one in-flight run per session.
  */
-export declare function createExtractionScheduler(host: SchedulerHost, deps: ExtractionDeps, options?: SchedulerOptions): () => void;
+export declare function createExtractionScheduler(host: SchedulerHost, deps: ExtractionDeps): () => void;
 //# sourceMappingURL=extraction.d.ts.map

package/lib/extraction.js

@@ -165,16 +165,21 @@ async function streamOnce(llm, target, prompt) {
 }
 /**
  * Wire the extraction triggers onto the host context. Returns a disposer
- * that removes the listeners and clears the timer. The scheduler is the
- * only background automation the plugin runs, and it is bounded by design:
- * one timer, one in-flight run, one pending slot.
+ * that removes the listeners. The scheduler is the only background
+ * automation the plugin runs, and it is bounded by design: one boundary and
+ * one in-flight run per session.
  */
-export function createExtractionScheduler(host, deps, options = {}) {
-    const debounceMs = Math.max(0, (options.debounceMin ?? 10) * 60_000);
+export function createExtractionScheduler(host, deps) {
     const listeners = [];
-    let timer = null;
-    let running = false;
-    let pending = null;
+    const slots = new Map();
+    const slotOf = (sessionId) => {
+        let slot = slots.get(sessionId);
+        if (slot === undefined) {
+            slot = { pending: null, running: false };
+            slots.set(sessionId, slot);
+        }
+        return slot;
+    };
     const targetOf = (agent) => {
         const id = agent?.id;
         if (typeof id !== "string" || id.length === 0) {
@@ -188,17 +193,14 @@ export function createExtractionScheduler(host, deps, options = {}) {
             model: typeof route?.model === "string" ? route.model : undefined,
         };
     };
-    const flush = (trigger) => {
-        if (timer !== null) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        if (running || pending === null) {
+    const drain = (sessionId, trigger) => {
+        const slot = slotOf(sessionId);
+        if (slot.running || slot.pending === null) {
             return;
         }
-        const target = pending;
-        pending = null;
-        running = true;
+        const target = slot.pending;
+        slot.pending = null;
+        slot.running = true;
         void runExtraction(deps, {
             workspaceId: cwdOf(target.agent),
             sessionId: target.sessionId,
@@ -208,57 +210,66 @@ export function createExtractionScheduler(host, deps, options = {}) {
         }, { trigger }).catch((error) => {
             host.logger("continual-evolve").warn(`extraction run failed unexpectedly: ${error instanceof Error ? error.message : String(error)}`);
         }).finally(() => {
-            running = false;
-            if (pending !== null) {
-                // A turn arrived mid-run and refreshed the pending slot: drain it.
-                flush("turn-debounce");
+            slot.running = false;
+            if (slot.pending !== null) {
+                // A turn landed mid-run: the newest boundary is the one to run.
+                drain(sessionId, "turn-debounce");
             }
         });
     };
-    const arm = (agent) => {
-        const target = targetOf(agent);
-        if (target === null) {
+    /**
+     * Schedule one session's boundary. Internal agents (subagents and DSH
+     * internal agents) are filtered at this entry rather than inside the run:
+     * they are not memory sources, so they never occupy a slot, never drain
+     * another session's boundary, and leave no ledger rows behind.
+     */
+    const schedule = (agent) => {
+        if (isInternalAgent(agent)) {
             return;
         }
-        pending = target; // Coalescing: the latest boundary wins, nothing queues.
-        if (debounceMs === 0) {
-            flush("turn-debounce");
+        const target = targetOf(agent);
+        if (target === null) {
             return;
         }
-        if (timer !== null) {
-            clearTimeout(timer);
-        }
-        timer = setTimeout(() => {
-            timer = null;
-            flush("turn-debounce");
-        }, debounceMs);
+        slotOf(target.sessionId).pending = target;
+        drain(target.sessionId, "turn-debounce");
     };
     listeners.push(host.on("agent/turn-stopping", (payload) => {
         if (payload.agent === undefined) {
             return;
         }
-        arm(payload.agent);
+        schedule(payload.agent);
     }));
     listeners.push(host.on("session/event", (session, event) => {
-        if (event?.type !== "compaction/start" || pending === null || pending.sessionId !== session?.id) {
+        const id = session?.id;
+        if (event?.type !== "compaction/start" || typeof id !== "string") {
+            return;
+        }
+        const slot = slots.get(id);
+        if (slot === undefined || slot.pending === null) {
             return;
         }
-        flush("compaction");
+        drain(id, "compaction");
     }));
     listeners.push(host.on("agent/disposed", (payload) => {
         const id = payload.agent?.id;
-        if (pending === null || pending.sessionId !== id) {
+        if (typeof id !== "string") {
             return;
         }
-        flush("close-drain");
+        const slot = slots.get(id);
+        if (slot === undefined) {
+            return;
+        }
+        if (slot.pending !== null) {
+            drain(id, "close-drain");
+        }
+        // The session is gone: drop its slot. A run already in flight holds
+        // its own reference and simply finds nothing left to drain.
+        slots.delete(id);
     }));
-    host.logger("continual-evolve").info(`extraction scheduler armed (debounce ${options.debounceMin ?? 10}min, single-flight with coalescing)`);
+    host.logger("continual-evolve").info("extraction scheduler armed (per-session slots, turn-level, single-flight per session)");
     return () => {
-        if (timer !== null) {
-            clearTimeout(timer);
-            timer = null;
-        }
-        pending = null;
+        slots.clear();
         for (const listener of listeners) {
             if (typeof listener === "function") {
                 listener();

package/lib/index.d.ts

@@ -11,8 +11,9 @@
  *   as the injected index, frozen per session for the prompt cache;
  * - the model tools (`memory-tools.ts`): `memory_write` for explicit
  *   "记住/忘掉" instructions, `memory_read` for bodies and search;
- * - the extraction scheduler (`extraction.ts`): turn-level, debounced,
- *   single-flight; proposals land only through the store's gates;
+ * - the extraction scheduler (`extraction.ts`): turn-level, per-session
+ *   slots, single-flight per session; proposals land only through the
+ *   store's gates;
  * - the read-only card routes (`card-routes.ts`) in the official plugin
  *   manager.
  *
@@ -59,26 +60,22 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         order: z<number, number, "plain">;
         maxChars: z<number, number, "plain">;
         /**
-         * The proposal-based extraction run (trigger: turn-level with idle
-         * debounce; writes land only through the store's gates). Off keeps
-         * the plugin injection + explicit tools only.
+         * The proposal-based extraction run (trigger: turn-level, per-session
+         * slots, no idle timer; writes land only through the store's gates).
+         * Off keeps the plugin injection + explicit tools only.
          */
         extraction: z<boolean, boolean, "plain">;
-        /** Idle debounce minutes between turn end and an extraction run (0 = per turn). */
-        debounceMin: z<number, number, "plain">;
     }>>, Schemastery.ObjectT<NoInfer<{
         enabled: z<boolean, boolean, "plain">;
         guide: z<boolean, boolean, "plain">;
         order: z<number, number, "plain">;
         maxChars: z<number, number, "plain">;
         /**
-         * The proposal-based extraction run (trigger: turn-level with idle
-         * debounce; writes land only through the store's gates). Off keeps
-         * the plugin injection + explicit tools only.
+         * The proposal-based extraction run (trigger: turn-level, per-session
+         * slots, no idle timer; writes land only through the store's gates).
+         * Off keeps the plugin injection + explicit tools only.
          */
         extraction: z<boolean, boolean, "plain">;
-        /** Idle debounce minutes between turn end and an extraction run (0 = per turn). */
-        debounceMin: z<number, number, "plain">;
     }>>, "plain">;
     /**
      * The read-only memory card in the official plugin manager
@@ -105,26 +102,22 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         order: z<number, number, "plain">;
         maxChars: z<number, number, "plain">;
         /**
-         * The proposal-based extraction run (trigger: turn-level with idle
-         * debounce; writes land only through the store's gates). Off keeps
-         * the plugin injection + explicit tools only.
+         * The proposal-based extraction run (trigger: turn-level, per-session
+         * slots, no idle timer; writes land only through the store's gates).
+         * Off keeps the plugin injection + explicit tools only.
          */
         extraction: z<boolean, boolean, "plain">;
-        /** Idle debounce minutes between turn end and an extraction run (0 = per turn). */
-        debounceMin: z<number, number, "plain">;
     }>>, Schemastery.ObjectT<NoInfer<{
         enabled: z<boolean, boolean, "plain">;
         guide: z<boolean, boolean, "plain">;
         order: z<number, number, "plain">;
         maxChars: z<number, number, "plain">;
         /**
-         * The proposal-based extraction run (trigger: turn-level with idle
-         * debounce; writes land only through the store's gates). Off keeps
-         * the plugin injection + explicit tools only.
+         * The proposal-based extraction run (trigger: turn-level, per-session
+         * slots, no idle timer; writes land only through the store's gates).
+         * Off keeps the plugin injection + explicit tools only.
          */
         extraction: z<boolean, boolean, "plain">;
-        /** Idle debounce minutes between turn end and an extraction run (0 = per turn). */
-        debounceMin: z<number, number, "plain">;
     }>>, "plain">;
     /**
      * The read-only memory card in the official plugin manager

package/lib/index.js

@@ -11,8 +11,9 @@
  *   as the injected index, frozen per session for the prompt cache;
  * - the model tools (`memory-tools.ts`): `memory_write` for explicit
  *   "记住/忘掉" instructions, `memory_read` for bodies and search;
- * - the extraction scheduler (`extraction.ts`): turn-level, debounced,
- *   single-flight; proposals land only through the store's gates;
+ * - the extraction scheduler (`extraction.ts`): turn-level, per-session
+ *   slots, single-flight per session; proposals land only through the
+ *   store's gates;
  * - the read-only card routes (`card-routes.ts`) in the official plugin
  *   manager.
  *
@@ -48,13 +49,11 @@ export const Config = z.object({
         order: z.natural(),
         maxChars: z.natural(),
         /**
-         * The proposal-based extraction run (trigger: turn-level with idle
-         * debounce; writes land only through the store's gates). Off keeps
-         * the plugin injection + explicit tools only.
+         * The proposal-based extraction run (trigger: turn-level, per-session
+         * slots, no idle timer; writes land only through the store's gates).
+         * Off keeps the plugin injection + explicit tools only.
          */
         extraction: z.boolean(),
-        /** Idle debounce minutes between turn end and an extraction run (0 = per turn). */
-        debounceMin: z.natural(),
     }),
     /**
      * The read-only memory card in the official plugin manager
@@ -111,7 +110,7 @@ function mountExtractionWhenAvailable(host, store, config) {
             log.warn("sessionQuery service present but empty — extraction not armed (injection and tools unaffected)");
             return;
         }
-        createExtractionScheduler(events, { store, surface, llm }, { debounceMin: config.memoryIndex?.debounceMin ?? 10 });
+        createExtractionScheduler(events, { store, surface, llm });
     });
 }
 /**

package/lib/store.d.ts

@@ -71,7 +71,11 @@ export interface MemoryStore {
     list(workspaceId: string): MemoryRecord[];
     /** Every non-archived record regardless of status (the card's projection). */
     listAll(workspaceId: string): MemoryRecord[];
-    /** FTS search (trigram, workspace-scoped); <3-char queries fall back to LIKE. */
+    /**
+     * Keyword search, workspace-scoped: whitespace-separated tokens are
+     * AND-combined — trigram FTS when every token is ≥3 chars, literal LIKE
+     * substrings otherwise, and a LIKE fallback whenever FTS finds nothing.
+     */
     search(workspaceId: string, query: string, limit?: number): MemoryRecord[];
     /** The sole write gate: validate all proposals, apply atomically, ledger. */
     applyProposals(ctx: ProposalContext, proposals: readonly MemoryProposal[]): ProposalOutcome[];

package/lib/store.js

@@ -87,9 +87,22 @@ function recordOf(row) {
     };
 }
 const LIST_ORDER = "ORDER BY CASE type WHEN 'feedback' THEN 0 WHEN 'user' THEN 1 ELSE 2 END, updated_at DESC";
-/** Quote a user query as an FTS5 phrase (trigram needs ≥3 chars to match). */
-function ftsPhrase(query) {
-    return `"${query.replaceAll('"', '""')}"`;
+/** Quote one token as an FTS5 phrase (trigram needs ≥3 chars to match). */
+function ftsPhrase(token) {
+    return `"${token.replaceAll('"', '""')}"`;
+}
+/**
+ * Split a query into keyword tokens on ASCII or full-width whitespace. Each
+ * token is matched on its own and AND-combined: trigram FTS can only match
+ * ≥3-char runs, so a keyword pair like `中文 交接` is unrepresentable as one
+ * FTS phrase and silently returns nothing under a phrase match.
+ */
+function queryTokens(query) {
+    return query.split(/[\s\u3000]+/).filter((token) => token.length > 0);
+}
+/** `%token%` with LIKE metacharacters escaped — keywords match literally. */
+function likePattern(token) {
+    return `%${token.replaceAll(/[\\%_]/g, "\\$&")}%`;
 }
 /** Open (creating on first use) the central store. */
 export async function openMemoryStore(explicitPath) {
@@ -113,8 +126,6 @@ export async function openMemoryStore(explicitPath) {
         fts: database.prepare(`SELECT m.* FROM memories m WHERE (m.workspace_id, m.id) IN (
 				 SELECT workspace_id, id FROM memories_fts WHERE memories_fts MATCH ? AND workspace_id = ?
 				) AND m.status = 'active' ${LIST_ORDER} LIMIT ?`),
-        like: database.prepare(`SELECT * FROM memories WHERE workspace_id = ? AND status = 'active'
-			 AND (title LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\' OR body LIKE ? ESCAPE '\\') ${LIST_ORDER} LIMIT ?`),
         stateGet: database.prepare("SELECT value FROM state WHERE workspace_id = ? AND key = ?"),
         stateSet: database.prepare("INSERT INTO state (workspace_id, key, value) VALUES (?, ?, ?) " +
             "ON CONFLICT (workspace_id, key) DO UPDATE SET value = excluded.value"),
@@ -128,6 +139,24 @@ export async function openMemoryStore(explicitPath) {
         activeRows: database.prepare("SELECT * FROM memories WHERE status = 'active'"),
         quarantine: database.prepare("UPDATE memories SET status = 'quarantined' WHERE workspace_id = ? AND id = ?"),
     };
+    // LIKE fallback: one OR-triplet per token, every token required. Statements
+    // are cached by token count — the query set repeats, the counts don't grow.
+    const likeStmts = new Map();
+    const likeSearch = (workspaceId, tokens, limit) => {
+        let stmt = likeStmts.get(tokens.length);
+        if (stmt === undefined) {
+            const clause = tokens
+                .map(() => "(title LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\' OR body LIKE ? ESCAPE '\\')")
+                .join(" AND ");
+            stmt = database.prepare(`SELECT * FROM memories WHERE workspace_id = ? AND status = 'active' AND ${clause} ${LIST_ORDER} LIMIT ?`);
+            likeStmts.set(tokens.length, stmt);
+        }
+        const patterns = tokens.flatMap((token) => {
+            const pattern = likePattern(token);
+            return [pattern, pattern, pattern];
+        });
+        return stmt.all(workspaceId, ...patterns, limit).map(recordOf);
+    };
     const store = {
         path,
         get(workspaceId, id) {
@@ -141,12 +170,17 @@ export async function openMemoryStore(explicitPath) {
             return stmts.listAll.all(workspaceId).map(recordOf);
         },
         search(workspaceId, query, limit = 20) {
-            const trimmed = query.trim();
-            if (trimmed.length < 3) {
-                const like = `%${trimmed.replaceAll(/[\\%_]/g, "\\$&")}%`;
-                return stmts.like.all(workspaceId, like, like, like, limit).map(recordOf);
+            const tokens = queryTokens(query);
+            if (tokens.length === 0) {
+                return [];
+            }
+            if (tokens.every((token) => token.length >= 3)) {
+                const hits = stmts.fts.all(tokens.map(ftsPhrase).join(" AND "), workspaceId, limit);
+                if (hits.length > 0) {
+                    return hits.map(recordOf);
+                }
             }
-            return stmts.fts.all(ftsPhrase(trimmed), workspaceId, limit).map(recordOf);
+            return likeSearch(workspaceId, tokens, limit);
         },
         applyProposals(ctx, proposals) {
             return applyProposals({ database, now: () => new Date().toISOString() }, ctx, proposals).outcomes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "ZCode-style workspace memory for DeepSeek Harness: one central SQLite store partitioned by workspace, index injection, and sole-writer gated writes.",
   "license": "MIT",
   "repository": {
@@ -53,18 +53,20 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepare": "tsc -p tsconfig.json",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "prepack": "npm run build && npm run check:pack",
     "dev": "tsc -p tsconfig.json --watch",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.scripts.json --noEmit",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "lint": "oxlint src test client",
-    "clean": "rm -rf lib",
+    "clean": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\"",
     "check:docs": "tsx scripts/run-gates.ts docs",
     "check:handoff": "tsx scripts/verify-handoff-structure.ts --self-test && tsx scripts/verify-handoff-structure.ts",
-    "check:governance": "tsx scripts/verify-governance.ts"
+    "check:governance": "tsx scripts/verify-governance.ts",
+    "check:pack": "tsx scripts/verify-pack-contents.ts"
   },
   "peerDependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"

package/lib/known-workspaces.d.ts

@@ -1,22 +0,0 @@
-/** One known workspace: the resolved root and when it was last served. */
-export interface KnownWorkspace {
-    root: string;
-    /** ISO timestamp of the most recent section assembly seen for this root. */
-    lastSeen: string;
-}
-/** The allowlist the card routes read through. */
-export interface KnownWorkspaces {
-    /**
-     * Record (or refresh) a workspace root. A relative or blank cwd is a
-     * silent no-op — the caller is the injection path, where a bad cwd
-     * already renders an empty section and must not turn into a throw.
-     */
-    remember(cwd: string): void;
-    /** Known roots, most recently served first. */
-    list(): KnownWorkspace[];
-}
-/** How many recent workspaces the card tracks. */
-export declare const DEFAULT_KNOWN_WORKSPACE_LIMIT = 8;
-/** Create the in-memory allowlist; `limit` is the LRU bound. */
-export declare function createKnownWorkspaces(limit?: number): KnownWorkspaces;
-//# sourceMappingURL=known-workspaces.d.ts.map

package/lib/known-workspaces.js

@@ -1,42 +0,0 @@
-/**
- * The workspace roots the card may look at, in memory only.
- *
- * Populated as a side effect of section assembly (the plugin already knows
- * each session's cwd there), this list is the card's read allowlist: the
- * memory API refuses any root the running process has not served a session
- * in, so the endpoint cannot be used to probe the filesystem. Bounded LRU,
- * never persisted — a restart starts empty and one session in a workspace
- * puts it back. No second store on disk.
- */
-import { isAbsolute, resolve } from "node:path";
-/** How many recent workspaces the card tracks. */
-export const DEFAULT_KNOWN_WORKSPACE_LIMIT = 8;
-/** Create the in-memory allowlist; `limit` is the LRU bound. */
-export function createKnownWorkspaces(limit = DEFAULT_KNOWN_WORKSPACE_LIMIT) {
-    const max = Math.max(1, limit);
-    // Insertion order encodes recency: the most recently served root is last.
-    const recent = new Map();
-    return {
-        remember(cwd) {
-            const trimmed = cwd.trim();
-            if (trimmed.length === 0 || !isAbsolute(trimmed)) {
-                return;
-            }
-            recent.delete(resolve(trimmed));
-            recent.set(resolve(trimmed), new Date().toISOString());
-            while (recent.size > max) {
-                const oldest = recent.keys().next();
-                if (oldest.done === true) {
-                    break;
-                }
-                recent.delete(oldest.value);
-            }
-        },
-        list() {
-            return [...recent.entries()]
-                .reverse()
-                .map(([root, lastSeen]) => ({ root, lastSeen }));
-        },
-    };
-}
-//# sourceMappingURL=known-workspaces.js.map

package/lib/workspace-catalog.d.ts

@@ -1,30 +0,0 @@
-import type { KnownWorkspaces } from "./known-workspaces.js";
-/** One workspace the card knows: canonical root plus its display label. */
-export interface CatalogEntry {
-    root: string;
-    /** Display title from the registry, else the directory name. */
-    label: string;
-}
-/** The read fence (`known`) and the listed set (`list`). */
-export interface WorkspaceCatalog {
-    /** Every workspace the card may read, in registry order. */
-    known(): CatalogEntry[];
-    /** The known workspaces that currently have a memory directory. */
-    list(): CatalogEntry[];
-}
-/** The slice of `ctx.workspaceRegistry` this plugin consumes. */
-export interface WorkspaceRegistryLike {
-    list(): unknown;
-}
-/** Where the catalog gets its workspace records, in precedence order. */
-export interface WorkspaceCatalogOptions {
-    /** Live registry lookup; undefined when the host exposes no registry. */
-    registry?: (() => WorkspaceRegistryLike | undefined) | undefined;
-    /** The roots this process served — the last-resort source. */
-    served: KnownWorkspaces;
-    /** Harness home; enables the `storages/workspace.json` fallback when set. */
-    homeDir?: string | undefined;
-}
-/** Create the catalog over the given sources. */
-export declare function createWorkspaceCatalog(options: WorkspaceCatalogOptions): WorkspaceCatalog;
-//# sourceMappingURL=workspace-catalog.d.ts.map

package/lib/workspace-catalog.js

@@ -1,149 +0,0 @@
-/**
- * The card's workspace catalog — which workspaces the card may read, and which
- * of them it lists.
- *
- * The list comes from the host's workspace registry (`ctx.workspaceRegistry`,
- * the durable records the workspace picker itself renders), not from the
- * sessions this process happened to serve: a card that only knows its own
- * session history can never offer ZCode's workspace switching — with one
- * served root the selector has nothing to switch to. The served-roots map
- * stays as a source (a session in a workspace the registry does not know about
- * still shows up), and `storages/workspace.json` is read only when the
- * registry service yields nothing: that file is an internal format, so it is a
- * fallback, never the primary.
- *
- * Two questions, deliberately answered by two methods. `known()` is the read
- * fence: can this root be read at all? `list()` is the display projection:
- * which workspaces have a memory directory right now? ZCode's viewer lists
- * only workspaces that have one, but the fence cannot be that filter — a store
- * deleted between listing and read must degrade to the empty state on its own
- * entry, not turn the read into a 404.
- */
-import { lstatSync, readFileSync, realpathSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
-import { memoryDirFor } from "./memory-section.js";
-/** The registry stores `fs.realpath` already; resolve the rest the same way. */
-function canonicalPath(path) {
-    try {
-        return realpathSync(path);
-    }
-    catch {
-        // A vanished or unreadable directory keeps its resolved spelling: the
-        // registry itself never rewrites a record when its directory disappears.
-        return resolve(path);
-    }
-}
-/** One catalogue entry from a path/title pair, or undefined when unusable. */
-function entryOf(path, title) {
-    if (typeof path !== "string" || path.trim().length === 0) {
-        return undefined;
-    }
-    const root = canonicalPath(path);
-    const label = typeof title === "string" && title.trim().length > 0 ? title.trim() : basename(root);
-    return { root, label };
-}
-/** Records from the live registry service. */
-function registryEntries(registry) {
-    if (registry === undefined) {
-        return [];
-    }
-    let records;
-    try {
-        records = registry.list();
-    }
-    catch {
-        // A registry that throws is a host fault the card must not inherit:
-        // the next source still fills the list.
-        return [];
-    }
-    if (!Array.isArray(records)) {
-        return [];
-    }
-    const entries = [];
-    for (const record of records) {
-        if (typeof record !== "object" || record === null) {
-            continue;
-        }
-        const entry = entryOf(record.path, record.title);
-        if (entry !== undefined) {
-            entries.push(entry);
-        }
-    }
-    return entries;
-}
-/** Records from the registry's own durable file, for hosts without the service. */
-function fileEntries(homeDir) {
-    if (homeDir === undefined || homeDir.trim().length === 0) {
-        return [];
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(join(homeDir, "storages", "workspace.json"), "utf8"));
-    }
-    catch {
-        // Missing or unreadable file: no workspaces from this source, no throw.
-        return [];
-    }
-    const table = parsed?.tables?.workspaces;
-    if (typeof table !== "object" || table === null || Array.isArray(table)) {
-        return [];
-    }
-    const entries = [];
-    for (const record of Object.values(table)) {
-        if (typeof record !== "object" || record === null) {
-            continue;
-        }
-        const entry = entryOf(record.path, record.title);
-        if (entry !== undefined) {
-            entries.push(entry);
-        }
-    }
-    return entries;
-}
-/** Records from the roots this process served, most recent first. */
-function servedEntries(served) {
-    return served.list().map(({ root }) => {
-        const canonical = canonicalPath(root);
-        return { root: canonical, label: basename(canonical) };
-    });
-}
-/** ZCode's memory-directory rule: a plain directory, never a symlink. */
-function hasMemoryDirectory(root) {
-    try {
-        const stat = lstatSync(memoryDirFor(root));
-        return stat.isDirectory() && !stat.isSymbolicLink();
-    }
-    catch {
-        return false;
-    }
-}
-/** Deduplicate by canonical root, keeping the first (highest-precedence) entry. */
-function dedupe(entries) {
-    const seen = new Set();
-    const unique = [];
-    for (const entry of entries) {
-        if (seen.has(entry.root)) {
-            continue;
-        }
-        seen.add(entry.root);
-        unique.push(entry);
-    }
-    return unique;
-}
-/** Create the catalog over the given sources. */
-export function createWorkspaceCatalog(options) {
-    const known = () => {
-        const live = registryEntries(options.registry?.());
-        if (live.length > 0) {
-            return dedupe([...live, ...servedEntries(options.served)]);
-        }
-        return dedupe([...fileEntries(options.homeDir), ...servedEntries(options.served)]);
-    };
-    return {
-        known,
-        list() {
-            return known().filter((entry) => hasMemoryDirectory(entry.root));
-        },
-    };
-}
-//# sourceMappingURL=workspace-catalog.js.map