dsh-plugin-tool-management 0.9.0 → 0.10.0

package/lib/subagents/tools.js

@@ -1,3 +1,6 @@
+// 深度探针（`subagentDepthOf`）与目录判据（`catalogInjectedAt`）都不再需要：
+// 2026-09-17 方案 A 之后，这两个工具都不再看会话深度 —— 委派由官方决定（默认能嵌套到 3 层），
+// `catalogDepth` 只管常驻目录注入到哪些会话。
 export function text(v) {
     return [{ type: 'text', text: v }];
 }
@@ -19,7 +22,7 @@ export async function filterBySceneBinding(docs, enabledSceneLists) {
 export function defineSubagentManagerListTool(subagents) {
     return {
         name: 'subagent_manager_list',
-        description: 'List available personas (pre-configured subagent profiles) with their descriptions. Call before subagent_manager_run.',
+        description: 'List available personas (pre-configured subagent profiles) with their descriptions. The same catalog is injected into your context each turn (the「可委派的子智能体」system-reminder); call this tool before subagent_manager_run for the full, always-current list.',
         parameters: {},
         output: {
             schema: { type: 'string' },
@@ -27,6 +30,10 @@ export function defineSubagentManagerListTool(subagents) {
         },
         async execute(_args, exec) {
             const { allowed, reason } = await filterBySceneBinding(await subagents.list(), await subagents.sceneLists());
+            // 这里**不再按深度过滤**（2026-09-17 用户裁定，方案 A）：`catalogDepth` 只决定常驻目录
+            // 注入到哪些会话，与"能不能委派"无关 —— 委派由官方决定（`dsh-tool-subagent` 默认能嵌套
+            // 到 3 层）。此前按深度过滤等于把可用人设藏起来：目录不注入时模型只能靠这个工具查，
+            // 而工具又不列全，结果是"明明能委派却查不到人设"。
             const lines = allowed.map((p) => '- ' + p.name + ' — ' + (p.description || '(无描述)'));
             let notice = '';
             try {
@@ -42,10 +49,21 @@ export function defineSubagentManagerListTool(subagents) {
 export function defineSubagentManagerRunTool(subagents) {
     return {
         name: 'subagent_manager_run',
-        description: 'Run a named persona as a one-shot subagent: it gets the persona as its own system prompt, works on `task` in a fresh context, and returns only its final output. Stateless — it does not see this conversation. Expensive: starts a fresh model session, so use it only for self-contained work.',
+        // 描述按「是什么 → 两种模式 → 何时用（含与官方两个委派工具的分界）→ 何时改用别的」组织。
+        // 2026-09-17 补了**分界规则**与 `inherit`：此前上下文里虽然注入了人设目录与「用
+        // subagent_manager_run 执行」，但没有任何一句话说明它和官方 `subagent` / `subagent_fork`
+        // 何时该用谁 —— 本机实测（session-ee722e23）模型读完 README 后选了官方 `subagent_fork`
+        // （fork 能继承已读内容、不必复述）。现在人设通道也有 fork（`inherit`），分界只剩
+        // 「要不要后台跑」一件事，所以规则能写成"贴合人设的一律走这里"。
+        //
+        // 「何时不用」那一段保留（2026-09-17，用户采纳的四条里的第 6 条）：参照 Claude Code 的
+        // Agent 工具（`AgentTool/prompt.ts:232-240`），把"不该用"写成**带替代工具**的具体清单
+        // （具体路径→Read；找定义→Grep/Glob），比笼统说"这个很贵"有用得多。
+        description: 'Run a named persona as a subagent: it gets the persona as its own system prompt, works on `task`, and returns only its final output.\n\nTwo modes: by default the child starts fresh — it cannot see this conversation, so `task` must be self-contained. With `inherit: true` the child is seeded with this conversation\'s finished turns (the same mechanism as the host\'s `subagent_fork`), so `task` only states what is new — use it for follow-ups on work already completed. Only **finished** turns are inherited: a delegation made during the current turn inherits nothing from that turn, so a mid-turn hand-off still needs a self-contained `task`.\n\nWrite `task` as the goal plus the context it needs — do not prescribe method or output format: those belong to the persona.\n\nWhen to use: work that matches one of the personas in the「可委派的子智能体」system-reminder injected into your context (or from subagent_manager_list) — a review, a focused investigation, a piece of writing — where the detail does not belong in your own context. Work that matches a persona belongs here, not in the host\'s `subagent` / `subagent_fork`: those take no persona. Use them only when no persona fits, or when you need a background run (this tool waits for the result).\n\nWhen NOT to use: reading a specific file (use Read), finding a definition (use Grep/Glob), or touching two or three files (use Read directly).',
         parameters: {
             agent: { type: 'string', required: true, description: 'Persona name from subagent_manager_list.' },
-            task: { type: 'string', required: true, description: 'Self-contained task, with all context the subagent needs.' },
+            task: { type: 'string', required: true, description: 'The task for the subagent: the goal plus the context it needs. Self-contained by default; with inherit: true it only needs to state what is new. Leave method and output format to the persona.' },
+            inherit: { type: 'boolean', description: 'Let the subagent inherit this conversation\'s finished turns, like the host\'s subagent_fork (default false = a fresh child that cannot see this conversation). Only finished turns are inherited — a delegation made mid-turn cannot pass the current turn\'s content, so write `task` as if it were self-contained.' },
         },
         output: {
             schema: { type: 'string' },
@@ -54,6 +72,7 @@ export function defineSubagentManagerRunTool(subagents) {
         async execute(args, exec) {
             const name = String((args && args.agent) || '').trim();
             const task = String((args && args.task) || '').trim();
+            const inherit = args && args.inherit === true;
             if (!task)
                 throw new Error('task 不能为空');
             // 官方 SubagentStartRequest.parent 必填：调用方 agent 缺失时给结构化错误，不把 undefined 透传下去。
@@ -66,12 +85,18 @@ export function defineSubagentManagerRunTool(subagents) {
                 const available = allowed.map((p) => p.name).join('、') || '(无)';
                 throw new Error('人设不可用: ' + name + (reason ? '（' + reason + '）' : '（可用: ' + available + '）'));
             }
+            // 这里**刻意没有**"深度不够就拒绝"的检查（2026-09-17 用户裁定，方案 A）。
+            // 它此前基于一个错误假设：以为传 `maxDepth: 1` 会让子会话再委派必然失败。实际上官方
+            // `dsh-tool-subagent` 的默认是 **3**、provider 只在**传了值**时才校验，所以子代理本来
+            // 就能继续嵌套。那个检查的唯一净效果是让**我们的**工具比官方严 —— 同一个子会话里官方
+            // 工具能委派、我们的被自己拦下 —— 而用户真想禁止嵌套也禁止不了（官方工具照样能）。
+            // `catalogDepth` 现在只管"目录注入到哪些会话"，不参与委派可行性判断。
             // 按当前会话的 Agent 预设算工具限制：判断不了当前预设、或名单里的工具已经不存在时，
             // 结论里会带一句实话，跟着结果一起返回——不静默改变限制的强度。
             const decision = typeof subagents.toolFilterFor === 'function'
                 ? await subagents.toolFilterFor(persona, exec.agent && exec.agent.ctx)
                 : undefined;
-            const r = await subagents.runSerial(exec.agent, persona, task, exec.signal, decision === undefined ? undefined : decision.filter);
+            const r = await subagents.runSerial(exec.agent, persona, task, exec.signal, decision === undefined ? undefined : decision.filter, inherit);
             const prefix = r.stopReason && r.stopReason !== 'completed' ? `[stopReason: ${r.stopReason}]\n` : '';
             const note = decision && decision.note ? `⚠ ${decision.note}\n\n` : '';
             return note + prefix + r.text;

package/package.json

@@ -1,102 +1,105 @@
-{
-  "name": "dsh-plugin-tool-management",
-  "version": "0.9.0",
-  "description": "DSH plugin: one settings panel for MCP servers, skills, scenes, memories, subagents, AGENTS.md presets and archived sessions — scene memory injects into the system prompt, scene lock freezes all five domains, deleted workspaces re-register with one click. Settings UI + HTTP API + 14 model tools (mcp_manager_*, skill_manager_*, prompt_manager_*, memory_manager_*, subagent_*). Install with one command: dsh plugin --profile web add dsh-plugin-tool-management@latest",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ouli-1242/dsh-plugin-tool-management"
-  },
-  "type": "module",
-  "main": "lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./client": "./lib/client.js",
-    "./workspace": "./lib/history/workspace.js",
-    "./projcache": "./lib/history/projcache.js",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "lib",
-    "cordis.patch.yml",
-    "README.md",
-    "README_EN.md",
-    "CHANGELOG.md",
-    "LICENSE",
-    "screenshots.json",
-    "docs"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/sync-client.mjs",
-    "build:client": "node scripts/sync-client.mjs",
-    "prepublishOnly": "npm run build",
-    "lint": "node --check lib/client.js && node --check lib/index.js",
-    "check:i18n": "node scripts/check-i18n.mjs src/client.js",
-    "check:host": "node scripts/host-deps.mjs && node scripts/doctor.mjs",
-    "host-deps": "node scripts/host-deps.mjs --fix",
-    "doctor": "node scripts/doctor.mjs",
-    "test": "npm run build && npm run check:i18n && node --test test/client-exports.test.mjs test/client-render.test.mjs",
-    "sync:profile": "node scripts/sync-profile.mjs"
-  },
-  "keywords": [
-    "dsh",
-    "deepseek-harness",
-    "skill",
-    "skills",
-    "mcp",
-    "mcp-server",
-    "plugin",
-    "cordis"
-  ],
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "inject": [
-        "@deepseek-ai/dsh-client-locale"
-      ]
-    }
-  },
-  "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-llm": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-session": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-session-projection-cache": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-spill-local": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-storage-domain": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-subagent-spawn-in-process": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-tools": ">=0.1.5-rc.2",
-    "@deepseek-ai/dsh-workspace": ">=0.1.5-rc.2",
-    "react": "^18.2.0"
-  },
-  "peerDependenciesMeta": {
-    "@deepseek-ai/dsh-subagent-spawn-in-process": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-session-projection-cache": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-spill-local": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-storage-domain": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-user-approval": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-workspace": "^0.1.5-rc.2",
-    "@types/node": "^24.0.0",
-    "typescript": "^6.0.0"
-  },
-  "license": "MIT",
-  "dependencies": {
-    "fflate": "^0.8.3"
-  }
-}
+{
+  "name": "dsh-plugin-tool-management",
+  "version": "0.10.0",
+  "description": "DSH plugin: one settings panel for MCP servers, skills, scenes, memories, subagents, AGENTS.md presets and archived sessions — scene memory injects into the system prompt, scene lock freezes all five domains, deleted workspaces re-register with one click. Settings UI + HTTP API + 14 model tools (mcp_manager_*, skill_manager_*, prompt_manager_*, memory_manager_*, subagent_*). Install with one command: dsh plugin --profile web add dsh-plugin-tool-management@latest",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ouli-1242/dsh-plugin-tool-management"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./workspace": "./lib/history/workspace.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "README_EN.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "screenshots.json",
+    "docs"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/sync-client.mjs",
+    "build:client": "node scripts/sync-client.mjs",
+    "prepublishOnly": "npm run build",
+    "lint": "node --check lib/client.js && node --check lib/index.js",
+    "check:i18n": "node scripts/check-i18n.mjs src/client.js",
+    "check:host": "node scripts/host-deps.mjs && node scripts/doctor.mjs",
+    "host-deps": "node scripts/host-deps.mjs --fix",
+    "doctor": "node scripts/doctor.mjs",
+    "test": "npm run build && npm run check:i18n && node --test test/contracts.test.mjs test/client-exports.test.mjs test/client-render.test.mjs",
+    "sync:profile": "node scripts/sync-profile.mjs"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "skill",
+    "skills",
+    "mcp",
+    "mcp-server",
+    "plugin",
+    "cordis"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-session-projection-cache": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-spill-local": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-storage-domain": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-subagent-fork-in-process": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-subagent-spawn-in-process": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-tools": ">=0.1.5-rc.2",
+    "@deepseek-ai/dsh-workspace": ">=0.1.5-rc.2",
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-subagent-fork-in-process": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-subagent-spawn-in-process": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-session-projection-cache": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-spill-local": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-user-approval": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-workspace": "^0.1.5-rc.2",
+    "@types/node": "^24.0.0",
+    "typescript": "^6.0.0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "fflate": "^0.8.3"
+  }
+}

package/lib/history/projcache.js

@@ -1,335 +0,0 @@
-import { createHash } from "node:crypto";
-import { Service } from "@deepseek-ai/cordis";
-import { SessionProjectionCache, checkpointIdentity, checkpointRecord, projectionCacheDomainSpec } from "@deepseek-ai/dsh-session-projection-cache";
-import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
-import { trackTombstone } from "./tombstone.js";
-/**
- * 当前投影缓存写入独立的 v2 域，避免 DSH alpha.2 将包含冒号的逻辑会话 ID
- * 直接映射为 Windows 文件名。旧名 v1 与旧名 v2 域只在启动时读取并补缺迁入，
- * 迁移不删除原始缓存，任意中断都可在后续启动继续。
- */
-const storedCheckpointRecord = checkpointRecord.extend({
-    sessionId: checkpointIdentity.shape.cwd.unwrap()
-});
-const safeDomainInput = {
-    // 旧版 DSH 不支持同名域的版本迁移。v2 改用新域名，确保升级时不会在
-    // 打开目标域之前因旧 v1 元数据而终止启动。
-    name: "session_projcache_archive_manager_v2",
-    version: 2,
-    tables: { sessions: domainTable(storedCheckpointRecord) },
-    ...(projectionCacheDomainSpec.layout === "per-record" ? { layout: "per-record" } : {})
-};
-const safeProjectionCacheDomainSpec = defineDomain(safeDomainInput);
-/** The last official whole-file cache format used by DSH rc.2. */
-const legacyOptionalIdentityFields = {};
-for (const field of ["isSeeded", "inheritedEventCount"]) {
-    // rc.2 的身份 schema 尚未定义这些字段；向 Zod 传入不存在的字段会在
-    // 首次解析历史记录时抛错，因此只能按当前运行时实际的 schema 构造掩码。
-    if (Object.hasOwn(checkpointIdentity.shape, field))
-        legacyOptionalIdentityFields[field] = true;
-}
-const legacyCheckpointRecord = checkpointRecord.extend({
-    identity: checkpointIdentity.partial(legacyOptionalIdentityFields)
-});
-const legacyStoredCheckpointRecord = legacyCheckpointRecord.extend({
-    sessionId: checkpointIdentity.shape.cwd.unwrap()
-});
-/** v0.1.24 短暂使用过的旧名 v2 安全缓存域。 */
-const legacySafeV2ProjectionCacheDomainSpec = defineDomain({
-    name: "session_projcache_archive_manager",
-    version: 2,
-    tables: { sessions: domainTable(storedCheckpointRecord) },
-    ...(projectionCacheDomainSpec.layout === "per-record" ? { layout: "per-record" } : {})
-});
-/** v0.1.23 及以前归档管理器自身使用的安全缓存域。 */
-const legacySafeProjectionCacheDomainSpec = defineDomain({
-    name: "session_projcache_archive_manager",
-    version: 1,
-    tables: { sessions: domainTable(legacyStoredCheckpointRecord) },
-    ...(projectionCacheDomainSpec.layout === "per-record" ? { layout: "per-record" } : {})
-});
-const legacyProjectionCacheDomainSpec = defineDomain({
-    name: "session_projcache",
-    version: 3,
-    tables: { sessions: domainTable(legacyCheckpointRecord) }
-});
-function projectionCacheStorageKey(sessionId) {
-    return `session_${createHash("sha256").update(sessionId, "utf8").digest("base64url")}`;
-}
-function unwrapStoredCheckpoint(stored) {
-    return { identity: stored.identity, rows: stored.rows };
-}
-/** Map the Session-id table contract onto path-safe physical keys. */
-class SafeSessionTable {
-    constructor(table) {
-        this.table = table;
-    }
-    get size() {
-        return [...this.keys()].length;
-    }
-    get(sessionId) {
-        const stored = this.table.get(projectionCacheStorageKey(sessionId));
-        if (stored === void 0 || stored.sessionId !== sessionId)
-            return void 0;
-        return unwrapStoredCheckpoint(stored);
-    }
-    has(sessionId) {
-        return this.get(sessionId) !== void 0;
-    }
-    *entries() {
-        for (const [key, stored] of this.table.entries()) {
-            if (projectionCacheStorageKey(stored.sessionId) !== key)
-                continue;
-            yield [stored.sessionId, unwrapStoredCheckpoint(stored)];
-        }
-    }
-    *keys() {
-        for (const [sessionId] of this.entries())
-            yield sessionId;
-    }
-    *values() {
-        for (const [, value] of this.entries())
-            yield value;
-    }
-    async put(sessionId, record) {
-        const key = projectionCacheStorageKey(sessionId);
-        const existing = this.table.get(key);
-        if (existing !== void 0 && existing.sessionId !== sessionId) {
-            throw new Error(`projection-cache storage-key collision for "${sessionId}"`);
-        }
-        await this.table.put(key, { sessionId, identity: record.identity, rows: record.rows });
-    }
-    async delete(sessionId) {
-        const key = projectionCacheStorageKey(sessionId);
-        const existing = this.table.get(key);
-        if (existing === void 0 || existing.sessionId !== sessionId)
-            return false;
-        return this.table.delete(key);
-    }
-}
-async function readSourceRecords(ctx, spec, label) {
-    let domain;
-    try {
-        domain = await ctx.storageDomain.open(spec);
-        return { opened: true, records: [...domain.table("sessions").entries()] };
-    }
-    catch (error) {
-        ctx.logger.warn(`archive-manager projcache: ${label} cache import skipped: ${String(error)}`);
-        return { opened: false, records: [] };
-    }
-    finally {
-        try {
-            await domain?.close();
-        }
-        catch (error) {
-            ctx.logger.warn(`archive-manager projcache: ${label} cache close failed: ${String(error)}`);
-        }
-    }
-}
-async function readLegacySafeRecords(ctx, spec, label) {
-    const source = await readSourceRecords(ctx, spec, label);
-    const records = [];
-    for (const [physicalKey, stored] of source.records) {
-        if (stored === null || typeof stored !== "object" || typeof stored.sessionId !== "string") {
-            ctx.logger.warn(`archive-manager projcache: ${label} row "${physicalKey}" import skipped because its session id is invalid`);
-            continue;
-        }
-        if (projectionCacheStorageKey(stored.sessionId) !== physicalKey) {
-            ctx.logger.warn(`archive-manager projcache: ${label} row "${physicalKey}" import skipped because its storage key does not match the session id`);
-            continue;
-        }
-        records.push([stored.sessionId, unwrapStoredCheckpoint(stored)]);
-    }
-    return { ...source, records };
-}
-/**
- * 旧版记录没有完整身份时，只能安全补齐未播种会话的零继承切点。
- * 播种会话无法从头部反推出精确切点，宁可跳过并按需重建。
- */
-function normalizeLegacyRecord(record) {
-    if (record === null || typeof record !== "object" || record.identity === null || typeof record.identity !== "object")
-        return void 0;
-    const identity = record.identity;
-    const inheritedEventCount = identity.inheritedEventCount;
-    const validOffset = Number.isSafeInteger(inheritedEventCount) && inheritedEventCount >= 0;
-    if (identity.isSeeded === true) {
-        if (!validOffset)
-            return void 0;
-        return record;
-    }
-    if (identity.isSeeded !== void 0 && identity.isSeeded !== false)
-        return void 0;
-    if (inheritedEventCount !== void 0 && inheritedEventCount !== 0)
-        return void 0;
-    return {
-        ...record,
-        identity: {
-            ...identity,
-            isSeeded: false,
-            inheritedEventCount: 0
-        }
-    };
-}
-async function importMissingRecords(ctx, target, records, label) {
-    let imported = 0;
-    for (const [sessionId, record] of records) {
-        if (target.has(sessionId))
-            continue;
-        try {
-            const normalized = normalizeLegacyRecord(record);
-            if (normalized === void 0) {
-                ctx.logger.warn(`archive-manager projcache: ${label} row "${sessionId}" import skipped because its lifecycle identity is incomplete`);
-                continue;
-            }
-            await target.put(sessionId, normalized);
-            imported += 1;
-        }
-        catch (error) {
-            ctx.logger.warn(`archive-manager projcache: ${label} row "${sessionId}" import failed: ${String(error)}`);
-        }
-    }
-    return imported;
-}
-/**
- * 合并归档管理器旧名 v2、旧名 v1、官方新版逐会话与旧版整文件缓存。目标域记录
- * 最高优先，随后按新旧顺序只补缺失记录；任一来源失败时仍继续尝试另一个来源。
- */
-async function importPreviousProjectionCache(ctx, target) {
-    const legacySafeV2 = await readLegacySafeRecords(ctx, legacySafeV2ProjectionCacheDomainSpec, "archive-manager v2");
-    const legacySafe = await readLegacySafeRecords(ctx, legacySafeProjectionCacheDomainSpec, "archive-manager v1");
-    const legacy = await readSourceRecords(ctx, legacyProjectionCacheDomainSpec, "legacy v3");
-    const sameSpec = projectionCacheDomainSpec.version === legacyProjectionCacheDomainSpec.version
-        && projectionCacheDomainSpec.layout === legacyProjectionCacheDomainSpec.layout;
-    let imported = 0;
-    if (legacySafeV2.opened)
-        imported += await importMissingRecords(ctx, target, legacySafeV2.records, "archive-manager v2");
-    if (legacySafe.opened)
-        imported += await importMissingRecords(ctx, target, legacySafe.records, "archive-manager v1");
-    if (!sameSpec) {
-        const current = await readSourceRecords(ctx, projectionCacheDomainSpec, "current");
-        if (current.opened)
-            imported += await importMissingRecords(ctx, target, current.records, "current");
-    }
-    if (legacy.opened)
-        imported += await importMissingRecords(ctx, target, legacy.records, "legacy v3");
-    return imported;
-}
-//#region lib/types/index.js
-/**
- * dsh-archive-manager projcache 半边。
- *
- * `ArchiveProjectionCache` 继承上游 `SessionProjectionCache`，保留服务名
- * `sessionProjectionCache` 与 fail-soft 写路径，但写入独立、路径安全的
- * `session_projcache_archive_manager_v2` 域。旧名 v1 与 v2 域只在启动时
- * 读取并补缺迁入；归档管理的
- * `deleteSession` 增加三处守护：
- *
- * - `delete(id)` - 永久移除兼容域中该会话经 SHA-256 映射的缓存投影行，
- *   写入前先登记墓碑。
- * - `whenIdle()` - 全部在途公开写入落定后 resolve。
- * - 墓碑挡住已删除会话的写入：迟到的写入要么被直接拦截，要么在
- *   落定后补删自己的残留行，不会复活已删除的缓存条目。守护覆盖
- *   `write()`（dispose 写后路径）与 `put()`（rc.2 的 `putSoft` 最终调用
- *   它，alpha.2 的 `coldSnapshot` 则直接调用它），两代落盘路径都纳入
- *   `whenIdle` 跟踪。
- *
- * 默认导出是 Service 子类（与上游 `@deepseek-ai/dsh-session-projection-cache`
- * 包同形），profile 补丁可直接替换 `session-projection-cache` 服务行，
- * 无需其他接线改动。
- */
-var ArchiveProjectionCache = class extends SessionProjectionCache {
-    /** 已永久删除的会话：其投影缓存行不再允许写入。 */
-    deletedSessionIds = /* @__PURE__ */ new Set();
-    /** 墓碑插入顺序，用于在上限处淘汰最旧项。 */
-    deletedSessionOrder = [];
-    deletedSessionTombstoneLimit = 4096;
-    /** 在途写入的队尾（只含已落定的 promise）。 */
-    writeTail = Promise.resolve();
-    constructor(ctx, config) {
-        super(ctx, config);
-    }
-    /**
-     * Replace the official cache domain with the path-safe compatibility
-     * domain, then preserve the upstream listener/write implementation.
-     */
-    async [Service.init]() {
-        const domain = await this.ctx.storageDomain.open(safeProjectionCacheDomainSpec);
-        this.ctx.effect(() => () => domain.close(), "sessionProjectionCache.domainClose");
-        const table = new SafeSessionTable(domain.table("sessions"));
-        this.table = table;
-        await importPreviousProjectionCache(this.ctx, table);
-        this.installWritePath();
-    }
-    /** 跟踪公开写入路径，避免依赖上游私有 `flushSoft` 的实现细节。 */
-    write(session) {
-        const task = this.writeCore(session);
-        this.writeTail = Promise.allSettled([this.writeTail, task]).then(() => void 0);
-        return task;
-    }
-    /**
-     * 墓碑正确性依赖：super.write(session) 一次整体写入，返回后不再有后续异步落盘。
-     * 若上游改成多阶段异步，(C) 补删会漏掉后续写入，deletedSessionIds 挡不住复活。
-     */
-    async writeCore(session) {
-        if (this.deletedSessionIds.has(session.id))
-            return;
-        await super.write(session);
-        if (this.deletedSessionIds.has(session.id))
-            await this.requireTable().delete(session.id);
-    }
-    /**
-     * 守住所有底层写入。rc.2 的冷读经 `putSoft -> put`，alpha.2 则
-     * 直接经 `put`；把墓碑与 whenIdle 跟踪放在这里可同时兼容两代实现。
-     */
-    put(id, identity, rows) {
-        // alpha.2 coldSnapshot unconditionally chains `.catch()` onto put().
-        // A blocked write must therefore preserve the upstream Promise contract.
-        if (this.deletedSessionIds.has(id))
-            return Promise.resolve();
-        const task = this.putCore(id, identity, rows);
-        this.writeTail = Promise.allSettled([this.writeTail, task]).then(() => void 0);
-        return task;
-    }
-    async putCore(id, identity, rows) {
-        await super.put(id, identity, rows);
-        if (this.deletedSessionIds.has(id))
-            await this.requireTable().delete(id);
-    }
-    /** rc.2 公开的 fail-soft 辅助在 alpha.2 已移除；保留同形兼容入口。 */
-    async putSoft(id, identity, rows, what) {
-        const upstream = SessionProjectionCache.prototype.putSoft;
-        if (typeof upstream === "function")
-            return upstream.call(this, id, identity, rows, what);
-        try {
-            await this.put(id, identity, rows);
-        }
-        catch (error) {
-            this.ctx.logger.warn(`session projection cache: ${what} for "${id}" failed (cache stays stale): ${String(error)}`);
-        }
-    }
-    /**
-     * 全部被跟踪的在途写入落定后 resolve（含失败）。空闲缓存上调用立即返回。
-     * @returns 跟踪写入落定后的 resolution。
-     */
-    whenIdle() {
-        return this.writeTail;
-    }
-    /**
-     * 永久移除一个会话的缓存投影行。
-     * @param id - 要删除缓存行的会话。
-     * @returns 行删除完成后的 resolution。
-     */
-    async delete(id) {
-        trackTombstone(this.deletedSessionIds, this.deletedSessionOrder, id, this.deletedSessionTombstoneLimit);
-        await this.requireTable().delete(id);
-    }
-    /** 撤销墓碑（供测试与同 id 新生命周期复用路径使用）。 */
-    clearTombstone(id) {
-        this.deletedSessionIds.delete(id);
-        const idx = this.deletedSessionOrder.indexOf(id);
-        if (idx !== -1)
-            this.deletedSessionOrder.splice(idx, 1);
-    }
-};
-//#endregion
-export { ArchiveProjectionCache, ArchiveProjectionCache as default, SafeSessionTable, importPreviousProjectionCache, legacyProjectionCacheDomainSpec, legacySafeProjectionCacheDomainSpec, legacySafeV2ProjectionCacheDomainSpec, projectionCacheStorageKey, safeProjectionCacheDomainSpec };