dsh-continual-evolve 0.15.1 → 0.15.3

package/README.md

@@ -7,7 +7,7 @@ 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-173%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-194%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)]()
@@ -22,9 +22,9 @@ Reusable experience gathered in one session (user preferences, pitfalls, project
 
 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 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.
+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, consecutive quiet turns of one session as a single row carrying how many wake-ups it stands for.
 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.
 
@@ -71,7 +71,7 @@ Profile patch example:
 
 ```bash
 pnpm install && pnpm build   # deps + clean build -> lib/
-pnpm test                    # vitest (173 tests)
+pnpm test                    # vitest (194 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)
@@ -93,11 +93,12 @@ Layout:
 │   ├── 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,7 +7,7 @@
 [![CI](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml/badge.svg)](https://github.com/ZK-Andy/dsh-continual-evolve/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%5E22.19%20%7C%7C%20%3E%3D24-339933)](package.json)
-[![Tests](https://img.shields.io/badge/tests-173%20passing-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-194%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)]()
@@ -22,9 +22,9 @@ 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 取正文、按关键词检索——空格分隔的关键词取 AND，短词与 trigram 未命中时回退字面子串匹配；注入索引只有钩子。宿主没有工具服务时降级为"告诉用户"措辞，注入不受影响。
-3. **提案制提取** —— 插件唯一的后台自动化，全程 `extraction_log` 可对账：每个 `agent/turn-stopping` 调度**该会话自己**的边界，状态按会话隔离（运行中只保留最新边界——合并而非排队；`compaction/start` 与会话收尾触发 drain），**没有空闲计时器**。一次运行读取该会话游标之后的轨迹增量，用 FTS 取相似既有记忆喂给一次 LLM 调用，模型的结构化提案过同一套门禁落盘；失败与被拒不推游标，下次触发重试。内部 agent、空增量、无真实用户文本的轮次、当轮已有显式 `memory_write` 的轮次机械跳过——每次跳过都记账。
+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 路线，不进记忆库。
 
@@ -71,7 +71,7 @@ profile patch 示例：
 
 ```bash
 pnpm install && pnpm build   # 依赖 + 干净构建 -> lib/
-pnpm test                    # vitest（173 例）
+pnpm test                    # vitest（194 例）
 pnpm test:coverage           # v8 覆盖率，CI 强制阈值
 pnpm lint                    # oxlint src test client
 pnpm check:pack              # 发布产物一致性（prepack 也会跑）
@@ -93,11 +93,12 @@ pnpm check:pack              # 发布产物一致性（prepack 也会跑）
 │   ├── 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.js

@@ -1,6 +1,8 @@
 import { boundaryCursorOf, evaluateSlice, eventsAfterCursor, isInternalAgent, seqOfCursor, serializeIncrement } from "./extraction-surface.js";
 import { EXTRACTION_SYSTEM_PROMPT, extractionPrompt, manifestLineOf, parseExtractionAnswer } from "./extraction-prompt.js";
 import { cwdOf } from "./memory-section.js";
+/** Head length of a failed run's raw answer kept in the ledger `files` column. */
+const FAILURE_RAW_MAX = 2048;
 /**
  * Run one extraction pass for a target. Never throws: every terminal path
  * is either a landed application, a ledgered skip, or a ledgered failure.
@@ -76,7 +78,9 @@ export async function runExtraction(deps, target, opts) {
     const parsed = parseExtractionAnswer(text);
     if (parsed.decision === "error") {
         // A malformed answer is a failed run: the increment stays unconsumed
-        // and the next trigger retries it.
+        // and the next trigger retries it. The answer's head rides in the
+        // ledger row — the stream is gone after this, so without it the
+        // failure is undiagnosable after the fact.
         store.logSkipped({
             ...ledgerBase,
             skipReason: parsed.reason,
@@ -84,6 +88,7 @@ export async function runExtraction(deps, target, opts) {
             model: target.model,
             usage,
             durationMs: Date.now() - started,
+            files: text.slice(0, FAILURE_RAW_MAX),
         });
         return { status: "failed", skipReason: parsed.reason };
     }

package/lib/index.js

@@ -33,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({
@@ -117,6 +118,10 @@ function mountExtractionWhenAvailable(host, store, config) {
  * 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;
@@ -125,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

@@ -30,7 +30,12 @@ export interface MemoryRecord {
     createdAt: string;
     updatedAt: string;
 }
-/** One ledger row (audit + rollback via embedded before/after snapshots). */
+/**
+ * One ledger row (audit + rollback via embedded before/after snapshots).
+ * Consecutive mechanical skips of the same kind share one row, whose
+ * `occurrences` column counts the wake-ups it stands for (`1` for everything
+ * else); the interface never sets it — the store owns that column.
+ */
 export interface LedgerEntry {
     runId?: string | undefined;
     sessionId?: string | undefined;
@@ -42,7 +47,7 @@ export interface LedgerEntry {
     durationMs?: number | undefined;
     model?: string | undefined;
     usage?: unknown;
-    /** Applied/attempted mutations: `{id, action, before?, after?, sourceSeqs}`. */
+    /** Applied/attempted mutations: `{id, action, before?, after?, sourceSeqs}`; a parse-failed run instead carries the raw answer's head. */
     files?: unknown;
 }
 /** Workspace rows the card's selector lists. */
@@ -86,6 +91,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

@@ -26,6 +26,15 @@ export const MD_IMPORT_STATE_KEY = "md-imported";
 export const GLOBAL_WORKSPACE = "";
 /** Preview size cap for the card's content endpoint (ZCode's viewer uses 5 MiB). */
 export const MEMORY_FILE_PREVIEW_LIMIT = 5 * 1024 * 1024;
+/** Ledger column counting the wake-ups one coalesced row stands for. */
+const LEDGER_OCCURRENCES = "occurrences";
+/**
+ * Skips a busy-but-quiet session repeats verbatim, turn after turn: the
+ * ledger keeps one counted row instead of one row per wake-up. Fault-shaped
+ * skips (`no-route`, `no-surface`, `no-workspace`) and every failure stay one
+ * row per occurrence — a persistent fault deserves a timeline, not a counter.
+ */
+const COALESCED_SKIP_REASONS = new Set(["no-user-prose", "no-new-events"]);
 const DDL = `
 PRAGMA journal_mode=WAL;
 PRAGMA busy_timeout=5000;CREATE TABLE IF NOT EXISTS memories (
@@ -58,7 +67,7 @@ CREATE TABLE IF NOT EXISTS extraction_log (
   trigger TEXT CHECK (trigger IN ('turn-debounce','compaction','close-drain','explicit','import')),
   decision TEXT, skip_reason TEXT,
   status TEXT, duration_ms INTEGER, model TEXT, usage TEXT,
-  files TEXT
+  files TEXT, occurrences INTEGER NOT NULL DEFAULT 1
 );
 CREATE TABLE IF NOT EXISTS state (
   workspace_id TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL,
@@ -119,6 +128,7 @@ export async function openMemoryStore(explicitPath) {
         throw new StoreUnavailableError(`node:sqlite unavailable (Node ≥ 22.5 required) — memory store disabled: ${error instanceof Error ? error.message : String(error)}`);
     }
     database.exec(DDL);
+    ensureLedgerOccurrences(database);
     const stmts = {
         get: database.prepare("SELECT * FROM memories WHERE workspace_id = ? AND id = ?"),
         list: database.prepare(`SELECT * FROM memories WHERE workspace_id = ? AND status = 'active' ${LIST_ORDER}`),
@@ -131,8 +141,15 @@ export async function openMemoryStore(explicitPath) {
             "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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
+        latestSkip: database.prepare("SELECT rowid AS rid, skip_reason AS reason, status FROM extraction_log " +
+            "WHERE workspace_id IS ? AND session_id IS ? ORDER BY ts DESC, rowid DESC LIMIT 1"),
+        bumpSkip: database.prepare(`UPDATE extraction_log SET ts = ?, ${LEDGER_OCCURRENCES} = ${LEDGER_OCCURRENCES} + 1 WHERE rowid = ?`),
         prune: database.prepare("DELETE FROM extraction_log WHERE ts < ?"),
         ftsOrphans: database.prepare("SELECT f.rowid AS rid FROM memories_fts f LEFT JOIN memories m ON m.workspace_id = f.workspace_id AND m.id = f.id WHERE m.id IS NULL"),
         ftsDrop: database.prepare("DELETE FROM memories_fts WHERE rowid = ?"),
@@ -157,6 +174,27 @@ export async function openMemoryStore(explicitPath) {
         });
         return stmt.all(workspaceId, ...patterns, limit).map(recordOf);
     };
+    /**
+     * Fold a repeat of the previous row's mechanical skip into that row: the
+     * quiet turns of one session are one cursor position, so they are one
+     * ledger row carrying how many wake-ups it stands for. Only a
+     * *consecutive* repeat coalesces — anything in between (a model decision,
+     * an applied batch, a different reason, another session) starts a new row,
+     * which is exactly what "the same cursor position" means here. The bumped
+     * row takes the newest `ts`, so recency queries still see the session as
+     * active.
+     */
+    const coalesceSkip = (entry) => {
+        if (entry.status !== "skipped" || entry.skipReason === undefined || !COALESCED_SKIP_REASONS.has(entry.skipReason)) {
+            return false;
+        }
+        const latest = stmts.latestSkip.get(entry.workspaceId ?? null, entry.sessionId ?? null);
+        if (latest === undefined || latest.status !== "skipped" || latest.reason !== entry.skipReason) {
+            return false;
+        }
+        stmts.bumpSkip.run(new Date().toISOString(), latest.rid);
+        return true;
+    };
     const store = {
         path,
         get(workspaceId, id) {
@@ -186,6 +224,9 @@ export async function openMemoryStore(explicitPath) {
             return applyProposals({ database, now: () => new Date().toISOString() }, ctx, proposals).outcomes;
         },
         logSkipped(entry) {
+            if (coalesceSkip(entry)) {
+                return;
+            }
             writeLedger(stmts.ledger, entry);
         },
         cursor(workspaceId, sessionId) {
@@ -209,6 +250,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()) {
@@ -234,6 +292,18 @@ export async function openMemoryStore(explicitPath) {
     };
     return store;
 }
+/**
+ * Add the ledger's `occurrences` column to a store created before coalescing
+ * existed. The DDL only covers fresh files, and the plugin is the sole writer
+ * of an existing user database — the one migration the ledger needs.
+ */
+function ensureLedgerOccurrences(database) {
+    const columns = database.prepare("SELECT name FROM pragma_table_info('extraction_log')").all();
+    if (columns.some((column) => column.name === LEDGER_OCCURRENCES)) {
+        return;
+    }
+    database.exec(`ALTER TABLE extraction_log ADD COLUMN ${LEDGER_OCCURRENCES} INTEGER NOT NULL DEFAULT 1`);
+}
 /** JSON-encode the optional ledger fields and insert the row (never throws past a warn). */
 function writeLedger(stmt, entry) {
     stmt.run(entry.runId ?? null, new Date().toISOString(), entry.sessionId ?? null, entry.workspaceId ?? null, entry.trigger, entry.decision ?? null, entry.skipReason ?? null, entry.status ?? null, entry.durationMs ?? null, entry.model ?? null, entry.usage === undefined ? null : JSON.stringify(entry.usage), entry.files === undefined ? null : JSON.stringify(entry.files));

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.1",
+  "version": "0.15.3",
   "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": {