dsh-continual-evolve 0.15.0 → 0.15.2

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-190%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,10 +21,10 @@ 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.
+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 (opening on the host's current workspace), 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.
 
 Memory types follow the ZCode taxonomy: `user` (profile and environment facts), `feedback` (corrected or confirmed practices — bodies must carry **Why:** and **How to apply:** lines), `reference` (resource pointers). The extraction boundary is person- and environment-scoped knowledge only: decisions and trade-offs are repo-scoped by nature and belong to the repo's ADR route, never to memory.
 
@@ -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 (190 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,16 +88,17 @@ 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
 │   ├── memory-snapshot.ts  # card: read-only store projection (entries / patrol / degrade)
-│   └── card-routes.ts      # card: GET-only read API on the host webServer
+│   ├── card-routes.ts      # card: GET-only read API on the host webServer
+│   └── workspace-hint.ts   # card: the host's current workspace as the opening default
 ├── client/
 │   └── client.js          # hand-written client bundle: read-only card in the plugin manager
 ├── locale/                # host package metadata: localized display name + description (zh/en)
-├── test/                  # vitest suite (15 files)
+├── test/                  # vitest suite (16 files)
 ├── lib/                   # build output (tsc)
 ├── docs/                  # design.md (design) · FAQ.md (real-world pitfalls)
 └── .agents/               # AI collaboration layer (AGENTS.md, skills, ADR notes)

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-190%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,10 +21,10 @@ 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 语言。卡片是数据库的请求时投影，没有编辑路径。
+5. **只读卡片** —— 挂在官方插件管理的本 bundle 页面（`plugins.bundle.config` slot，老宿主自动降级为无卡片）：形态对齐市场自家设置卡，内容对齐 ZCode 设置的记忆选项卡——下拉作用域选择器列出库里的工作区分区（默认选中宿主当前工作区）、搜索框、每条记忆的相对更新时间、点击行内展开正文预览（5 MiB 上限）、巡检异常警告。显示名与描述走宿主 `locale/*.json` 通道双语；宿主主题 token、`Button` 原语、中英文案跟随 DSH 语言。卡片是数据库的请求时投影，没有编辑路径。
 
 记忆类型沿 ZCode 分类法：`user`（画像与环境事实）、`feedback`（被纠正/确认的做法——正文必带 **Why:** 与 **How to apply:**）、`reference`（资源指针）。提取边界只收"跟人与环境走的知识"：决策与取舍天然属于仓库，走仓库的 ADR 路线，不进记忆库。
 
@@ -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（190 例）
 pnpm test:coverage           # v8 覆盖率，CI 强制阈值
 pnpm lint                    # oxlint src test client
+pnpm check:pack              # 发布产物一致性（prepack 也会跑）
 ```
 
 目录结构：
@@ -88,16 +88,17 @@ 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 无损迁移
 │   ├── memory-snapshot.ts  # 卡片：记忆库只读投影（条目 / 巡检 / 错误降级）
-│   └── card-routes.ts      # 卡片：webServer 上的 GET-only 只读 API
+│   ├── card-routes.ts      # 卡片：webServer 上的 GET-only 只读 API
+│   └── workspace-hint.ts   # 卡片：宿主当前工作区作为打开时的默认选中
 ├── client/
 │   └── client.js          # 手写 client bundle：官方插件管理内只读卡片
 ├── locale/                # 宿主包元数据：显示名 + 描述双语（zh/en）
-├── test/                  # vitest 测试（15 个文件）
+├── test/                  # vitest 测试（16 个文件）
 ├── lib/                   # 构建产物（tsc）
 ├── docs/                  # design.md（设计）· FAQ.md（踩坑）
 └── .agents/               # AI 协作层（AGENTS.md、技能、ADR 笔记）

package/client/client.js

@@ -27,11 +27,13 @@
  *
  * Content (v0.14, scope selector v0.15): aligned with ZCode's Settings → Memory
  * viewer, which the .evolve store shape was itself aligned with — one workspace
- * selected at a time behind a dropdown scope selector (workspaces come from the
- * host registry, so the selector lists the same workspaces the workspace picker
- * does), a file search box, per-file relative updated times, and a
+ * selected at a time behind a dropdown scope selector (workspaces are the
+ * store's partitions, so the selector lists exactly what the read fence
+ * serves), a file search box, per-file relative updated times, and a
  * click-to-preview body served by the host's content endpoint (5 MiB cap,
- * deleted/changed guards). The drift warnings (dangling index rows / unindexed
+ * deleted/changed guards). The card opens on the server's `defaultRoot` (the
+ * host's current workspace), falling back to the first listed partition. The
+ * drift warnings (dangling index rows / unindexed
  * files) stay: they are this plugin's OBSERVATION surface and a deliberate
  * superset of ZCode's viewer.
  * Locale/theme/primitives wiring unchanged from v0.13: `ctx.locale.register`
@@ -219,7 +221,12 @@ window.__ModuleLoader__.load({
 					}
 				}),
 			);
-			return { workspaces: entries };
+			return {
+				workspaces: entries,
+				// The server's answer to "which partition is this user in", or null
+				// when it has no opinion (the card then opens on the first row).
+				defaultRoot: typeof listBody.defaultRoot === "string" ? listBody.defaultRoot : null,
+			};
 		}
 
 		/**
@@ -821,13 +828,18 @@ window.__ModuleLoader__.load({
 				inner = createElement("div", { key: "inner", className: "dce-empty" }, t("empty"));
 			} else {
 				var selected = selection.root;
-				if (
-					selected === null ||
-					!model.model.workspaces.some(function (workspace) {
-						return workspace.root === selected;
-					})
-				) {
-					selected = model.model.workspaces[0].root;
+				var listed = function (root) {
+					return model.model.workspaces.some(function (workspace) {
+						return workspace.root === root;
+					});
+				};
+				if (selected === null || !listed(selected)) {
+					// The server names the workspace to open on (the host's current
+					// one); an unknown or absent name leaves the first row, which is
+					// the pre-hint behaviour.
+					selected = typeof model.model.defaultRoot === "string" && listed(model.model.defaultRoot)
+						? model.model.defaultRoot
+						: model.model.workspaces[0].root;
 				}
 				inner = createElement(WorkspaceBlock, {
 					key: "inner",

package/lib/card-routes.d.ts

@@ -23,11 +23,23 @@ export interface CardRoute {
 export interface CardWebServer {
     register(route: CardRoute): unknown;
 }
+/**
+ * Per-request hints the mount takes from the host. Both are optional: a host
+ * without the service behind them simply leaves the default to the next source
+ * in the chain (see {@link defaultRootOf}).
+ */
+export interface CardRouteOptions {
+    /**
+     * The GUI's current workspace, resolved live on every request so a
+     * workspace attached while the card is open is picked up on refresh.
+     */
+    currentWorkspace?: (() => string | undefined) | undefined;
+}
 /**
  * Register the card routes and return a disposer that removes them.
  * Registration return values are passed through untouched: whatever disposer
  * shape the host hands back (or none, as on some host versions), the
  * disposer calls only the functions among them.
  */
-export declare function mountCardRoutes(webServer: CardWebServer, store: MemoryStore): () => void;
+export declare function mountCardRoutes(webServer: CardWebServer, store: MemoryStore, options?: CardRouteOptions): () => void;
 //# sourceMappingURL=card-routes.d.ts.map

package/lib/card-routes.js

@@ -4,14 +4,15 @@
  * Mounted through the host's `webServer` service (same registration shape
  * dshmarket uses: `kind: "exact"` routes on the profile's web server), the
  * three endpoints are GET-only projections of the central SQLite store: the
- * workspace list (active partitions whose directory still exists), the
- * memory snapshot for a known workspace, and one record's body by id. The
- * store itself is the security fence — a `root` parameter only resolves
- * when the database has rows for it, so the API cannot probe the
- * filesystem; the content endpoint takes an id, never a path. Handlers are
- * synchronous and never throw past the response.
+ * workspace list (active partitions whose directory still exists) plus the
+ * partition the card should open on, the memory snapshot for a known
+ * workspace, and one record's body by id. The store itself is the security
+ * fence — a `root` parameter only resolves when the database has rows for it,
+ * so the API cannot probe the filesystem; the content endpoint takes an id,
+ * never a path. Handlers are synchronous and never throw past the response.
  */
 import { memoryEntryContent, listCardWorkspaces, memorySnapshot } from "./memory-snapshot.js";
+import { canonicalPath } from "./workspace-hint.js";
 /** URL prefix of the card API (kind-exact routes registered under it). */
 export const CARD_API_WORKSPACES_PATH = "/dsh-continual-evolve/api/v1/workspaces";
 export const CARD_API_MEMORY_PATH = "/dsh-continual-evolve/api/v1/memory";
@@ -33,7 +34,7 @@ function isKnownRoot(store, root) {
  * shape the host hands back (or none, as on some host versions), the
  * disposer calls only the functions among them.
  */
-export function mountCardRoutes(webServer, store) {
+export function mountCardRoutes(webServer, store, options = {}) {
     const disposers = [];
     disposers.push(webServer.register({
         kind: "exact",
@@ -44,7 +45,8 @@ export function mountCardRoutes(webServer, store) {
                 response.end();
                 return;
             }
-            sendJson(response, 200, { workspaces: listCardWorkspaces(store) });
+            const workspaces = listCardWorkspaces(store);
+            sendJson(response, 200, { workspaces, defaultRoot: defaultRootOf(store, workspaces, options) });
         },
     }));
     disposers.push(webServer.register({
@@ -153,4 +155,45 @@ function idParamOf(request) {
         return null;
     }
 }
+/**
+ * The partition the card opens on: the host's current workspace when it is one
+ * the card lists, else the store's most recently active partition, else null —
+ * the client then falls back to the first row. A hint that names an unlisted
+ * root is ignored rather than trusted, because the listed set is a projection
+ * of the store and nothing outside it is readable; spelling differences
+ * (symlink vs cwd) are resolved before the comparison.
+ */
+function defaultRootOf(store, workspaces, options) {
+    const listed = (candidate) => {
+        if (typeof candidate !== "string" || candidate.length === 0) {
+            return null;
+        }
+        const exact = workspaces.find((workspace) => workspace.root === candidate);
+        if (exact !== undefined) {
+            return exact.root;
+        }
+        const canonical = canonicalPath(candidate);
+        return workspaces.find((workspace) => canonicalPath(workspace.root) === canonical)?.root ?? null;
+    };
+    const candidates = [];
+    try {
+        candidates.push(options.currentWorkspace?.());
+    }
+    catch {
+        // A failing hint is simply no hint; the store still answers.
+    }
+    try {
+        candidates.push(store.mostRecentlyActiveWorkspace());
+    }
+    catch {
+        // A failing query leaves the default to the client's first row.
+    }
+    for (const candidate of candidates) {
+        const root = listed(candidate);
+        if (root !== null) {
+            return root;
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=card-routes.js.map

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.
  *
@@ -32,6 +33,7 @@ import { createFrozenMemorySection, cwdOf, DEFAULT_MAX_CHARS, DEFAULT_MEMORY_SEC
 import { registerMemoryTools } from "./memory-tools.js";
 import { importWorkspaceMd } from "./import-md.js";
 import { openMemoryStore } from "./store.js";
+import { newestRegistryPath } from "./workspace-hint.js";
 export const name = "continual-evolve";
 export const inject = ["systemPrompt"];
 export const Config = z.object({
@@ -48,13 +50,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,13 +111,17 @@ 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 });
     });
 }
 /**
  * Mount the card routes on the host web server through a nested inject, so
  * the plugin stays mountable on hosts without that service. Called once the
  * store is ready — the routes are projections of the store, not of files.
+ *
+ * The card's opening workspace comes from the host registry, read through
+ * `ctx.get` on every request (the FAQ #2 sibling-service rule — the service is
+ * optional, so it must not join the inject list, which would gate the mount).
  */
 function mountCardWhenAvailable(host, store) {
     const nested = host;
@@ -126,12 +130,15 @@ function mountCardWhenAvailable(host, store) {
         return;
     }
     nested.inject(["webServer"], (scoped) => {
-        const webServer = scoped.webServer;
+        const context = scoped;
+        const webServer = context.webServer;
         if (webServer === undefined) {
             host.logger("continual-evolve").warn("webServer service present but empty — memory card routes not mounted (memory section unaffected)");
             return;
         }
-        mountCardRoutes(webServer, store);
+        mountCardRoutes(webServer, store, {
+            currentWorkspace: () => newestRegistryPath(context.get?.("workspaceRegistry")),
+        });
     });
 }
 export function apply(host, config) {

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[];
@@ -82,6 +86,15 @@ export interface MemoryStore {
     state(workspaceId: string, key: string): string | undefined;
     setState(workspaceId: string, key: string, value: string): void;
     listWorkspaces(): WorkspaceSummary[];
+    /**
+     * The partition with the most recent session activity: the newest ledger
+     * instant against the newest memory write, whichever is later. The ledger
+     * carries a row for every run — including skips and explicit writes — so it
+     * tracks "a session worked here", while the memory write is the durable
+     * fallback for a partition whose ledger rows were pruned. Undefined only
+     * when the store holds neither.
+     */
+    mostRecentlyActiveWorkspace(): string | undefined;
     /** Hygiene pass: orphan FTS cleanup + secret quarantine. */
     patrol(): PatrolResult;
     /** Ledger rows older than the cutoff, removed (the one unbounded table). */

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,13 +126,15 @@ 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"),
         cursorGet: database.prepare("SELECT CAST(value AS INTEGER) AS seq FROM state WHERE workspace_id = ? AND key = ?"),
         workspaces: database.prepare("SELECT workspace_id, COUNT(*) AS n, MAX(updated_at) AS u FROM memories WHERE status = 'active' GROUP BY workspace_id ORDER BY u DESC"),
+        recentLedger: database.prepare("SELECT workspace_id, MAX(ts) AS ts FROM extraction_log " +
+            "WHERE workspace_id IS NOT NULL AND workspace_id <> '' GROUP BY workspace_id ORDER BY ts DESC LIMIT 1"),
+        recentMemory: database.prepare("SELECT workspace_id, MAX(updated_at) AS ts FROM memories " +
+            "WHERE status = 'active' AND workspace_id <> '' GROUP BY workspace_id ORDER BY ts DESC LIMIT 1"),
         ledger: database.prepare("INSERT INTO extraction_log (run_id, ts, session_id, workspace_id, trigger, decision, skip_reason, status, duration_ms, model, usage, files) " +
             "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
         prune: database.prepare("DELETE FROM extraction_log WHERE ts < ?"),
@@ -128,6 +143,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 +174,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 [];
             }
-            return stmts.fts.all(ftsPhrase(trimmed), workspaceId, limit).map(recordOf);
+            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 likeSearch(workspaceId, tokens, limit);
         },
         applyProposals(ctx, proposals) {
             return applyProposals({ database, now: () => new Date().toISOString() }, ctx, proposals).outcomes;
@@ -175,6 +213,23 @@ export async function openMemoryStore(explicitPath) {
                 updatedAt: row.u,
             }));
         },
+        mostRecentlyActiveWorkspace() {
+            // Both instants are ISO-8601 UTC, so the newer one is the greater
+            // string; comparing them keeps the two sources one ordering.
+            const rows = [stmts.recentLedger.get(), stmts.recentMemory.get()];
+            let best;
+            for (const row of rows) {
+                const workspaceId = row?.workspace_id;
+                const ts = row?.ts;
+                if (typeof workspaceId !== "string" || workspaceId.length === 0 || typeof ts !== "string") {
+                    continue;
+                }
+                if (best === undefined || ts > best.ts) {
+                    best = { workspaceId, ts };
+                }
+            }
+            return best?.workspaceId;
+        },
         patrol() {
             const result = { ts: new Date().toISOString(), orphanFtsRows: 0, quarantined: [] };
             for (const row of stmts.ftsOrphans.all()) {

package/lib/workspace-hint.d.ts

@@ -0,0 +1,17 @@
+/** The slice of `ctx.workspaceRegistry` this hint consumes. */
+export interface WorkspaceRegistryLike {
+    list(): unknown;
+}
+/**
+ * Canonical comparison spelling for one path: `fs.realpath` when the directory
+ * survives, the resolved spelling otherwise. The registry stores realpath while
+ * a partition id is the session's cwd, so the two can differ by a symlink.
+ */
+export declare function canonicalPath(path: string): string;
+/**
+ * The path of the registry record with the newest `updatedAt`, or undefined
+ * when the service is absent, malformed, or holds no usable record. Never
+ * throws: a host service is untrusted input and a hint may not break a route.
+ */
+export declare function newestRegistryPath(registry: unknown): string | undefined;
+//# sourceMappingURL=workspace-hint.d.ts.map

package/lib/workspace-hint.js

@@ -0,0 +1,65 @@
+/**
+ * The card's "current workspace" hint — which partition the card selects when
+ * it opens.
+ *
+ * The card is one page in the host's plugin manager: it has no session of its
+ * own, so "current" means "most recently active", and the host's workspace
+ * registry (`ctx.workspaceRegistry`) is the freshest record of that — attaching
+ * a session is a durable mutation, so the record with the newest `updatedAt` is
+ * the workspace the user just worked in. The registry is consumed **only** as
+ * this hint: the card's read fence and the listed set both stay projections of
+ * the store (ADR `2026-10-06-sqlite-single-store`), and an absent or unusable
+ * registry degrades to the store's own activity ordering.
+ */
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+/**
+ * Canonical comparison spelling for one path: `fs.realpath` when the directory
+ * survives, the resolved spelling otherwise. The registry stores realpath while
+ * a partition id is the session's cwd, so the two can differ by a symlink.
+ */
+export function canonicalPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+/**
+ * The path of the registry record with the newest `updatedAt`, or undefined
+ * when the service is absent, malformed, or holds no usable record. Never
+ * throws: a host service is untrusted input and a hint may not break a route.
+ */
+export function newestRegistryPath(registry) {
+    if (registry === null || registry === undefined) {
+        return undefined;
+    }
+    const list = registry.list;
+    if (typeof list !== "function") {
+        return undefined;
+    }
+    let rows;
+    try {
+        rows = list.call(registry);
+    }
+    catch {
+        return undefined;
+    }
+    if (!Array.isArray(rows)) {
+        return undefined;
+    }
+    let best;
+    for (const row of rows) {
+        const path = row?.path;
+        const updatedAt = row?.updatedAt;
+        if (typeof path !== "string" || path.trim().length === 0 || typeof updatedAt !== "string") {
+            continue;
+        }
+        if (best === undefined || updatedAt > best.updatedAt) {
+            best = { path: path.trim(), updatedAt };
+        }
+    }
+    return best?.path;
+}
+//# sourceMappingURL=workspace-hint.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "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