dsh-plugin-tool-management 0.11.0 → 0.12.0

package/lib/sessions/bridge.js

@@ -1,6 +1,7 @@
 import { symbols } from "@deepseek-ai/cordis";
 import { workspaceDomainSpec } from "@deepseek-ai/dsh-workspace";
 import { assessHost, routeFor, refusalsFor, CapabilityRefusalError } from "../compat/probe.js";
+import { noteRuntime } from "../compat/runtime-notes.js";
 export { CapabilityRefusalError };
 // No Service subclass, no ctx.provide(), no second storage-domain owner.
 // The official API lacks unarchive and a cache deletion barrier, so this file
@@ -36,16 +37,39 @@ const sameLifecycle = (a, b) => a && b && a.createdAt === b.createdAt && (a.cwd
  * @throws {CapabilityRefusalError} when the cache cannot support a safe delete.
  */
 function acquireCacheGuard(cache) {
-    let guard = cacheGuards.get(cache);
-    if (guard) {
-        guard.users += 1;
-        return guard;
+    const existing = cacheGuards.get(cache);
+    // 复用前先验「装着的确实是我们的包装器」：release 时被第三方接管过的那条路会留下一个
+    // 「在册但没装」的 guard，复用它等于墓碑拦截静默失效（缓存行可能复活）。
+    if (existing && existing.users > 0 && existing.installed()) {
+        existing.users += 1;
+        return existing;
     }
+    if (existing)
+        cacheGuards.delete(cache);
     const missing = ["put", "write", "requireTable"].filter((name) => typeof cache[name] !== "function");
     if (missing.length > 0) {
         throw new CapabilityRefusalError("delete", refusalsFor({ findings: [{ id: "projection.write", label: "投影缓存写入路径", kind: "write", owner: "projectionCache", fallback: "disable-destructive", state: "missing-member", detail: `宿主投影缓存缺少 ${missing.join(", ")}`, missing }] }, ["projection.write"]));
     }
-    const table = cache.requireTable();
+    let table;
+    try {
+        table = cache.requireTable();
+    }
+    catch (error) {
+        // 安装期就抛：此刻还没动 put/write（不可能有半状态），但必须上报 —— 删除屏障没在岗。
+        noteRuntime({
+            id: "projection-cache-adapter",
+            label: "投影缓存删除屏障",
+            kind: "delete",
+            fallback: "inform-only",
+            detail: `投影缓存适配未完成（requireTable 抛错）：${String(error?.message ?? error)}；宿主对象未被改动。`,
+        });
+        throw new CapabilityRefusalError("delete", [{
+                id: "projection.table-delete",
+                label: "投影缓存行删除",
+                detail: `宿主投影缓存的 requireTable() 抛错：${String(error?.message ?? error)}`,
+                recovery: "请更新本插件到与本机 DSH 匹配的版本（先运行 node scripts/doctor.mjs 查看差异）。",
+            }]);
+    }
     if (typeof table?.delete !== "function") {
         throw new CapabilityRefusalError("delete", [{
                 id: "projection.table-delete",
@@ -90,29 +114,46 @@ function acquireCacheGuard(cache) {
             return serial(id, async () => {
                 if (isBlocked(id, expected))
                     return;
-                await originals.put.call(cache, id, expected, detached);
-                if (isBlocked(id, expected)) {
-                    const stored = table.get(id);
-                    if (stored && sameLifecycle(stored.identity, expected))
-                        await table.delete(id);
+                try {
+                    await originals.put.call(cache, id, expected, detached);
+                    if (isBlocked(id, expected)) {
+                        const stored = table.get(id);
+                        if (stored && sameLifecycle(stored.identity, expected))
+                            await table.delete(id);
+                    }
+                }
+                catch (error) {
+                    // 形状变了才会是 TypeError（与本仓库探针同一条口径：受控 Error 不算适配失败）。
+                    // 撤掉包装、绝不让宿主留在"半个包装器"状态下，并上报 —— 下一次删除会重装。
+                    if (error instanceof TypeError)
+                        retire("failed");
+                    throw error;
                 }
             });
         },
         write(session) {
             // Track the flush await before put as well as put itself. Otherwise a
             // delayed write could outlive disposal and bypass the restored method.
+            let task;
             try {
-                return track(Promise.resolve(originals.write.call(cache, session)));
+                task = track(Promise.resolve(originals.write.call(cache, session)));
             }
             catch (error) {
+                if (error instanceof TypeError)
+                    retire("failed");
                 return Promise.reject(error);
             }
+            return task.catch((error) => { if (error instanceof TypeError)
+                retire("failed"); throw error; });
         },
     };
     cache.put = wrappers.put;
     cache.write = wrappers.write;
-    guard = {
+    const self = {
         users: 1,
+        // 两个都得是我们的才算"在岗"：只装着一个就等于另一半的写入不受墓碑约束（缓存行会复活）。
+        // 半个的情形由 acquire 的重建路径处理（覆盖掉那半个外来包装），并在退役时已上报过。
+        installed: () => cache.put === wrappers.put && cache.write === wrappers.write,
         begin(id, header) { blocked.set(id, header ?? null); },
         clearTombstone(id) { blocked.delete(id); },
         async whenIdle() { while (pending.size)
@@ -132,26 +173,55 @@ function acquireCacheGuard(cache) {
             await this.whenIdle();
             if (this.users > 0)
                 return;
-            let restored = true;
-            for (const name of ["put", "write"]) {
-                // Never overwrite a later third-party wrapper.
-                if (cache[name] !== wrappers[name]) {
-                    restored = false;
-                    continue;
-                }
-                if (descriptors[name])
-                    Object.defineProperty(cache, name, descriptors[name]);
-                else
-                    delete cache[name];
-            }
-            if (restored) {
-                blocked.clear();
-                cacheGuards.delete(cache);
-            }
+            const clean = restoreWrappers();
+            retire(clean ? "idle" : "taken-over");
         },
     };
-    cacheGuards.set(cache, guard);
-    return guard;
+    let retired = false;
+    /** 撤包装：第三方装了的话**不动它**（返回 false 表示没撤干净）。 */
+    function restoreWrappers() {
+        let clean = true;
+        for (const name of ["put", "write"]) {
+            // Never overwrite a later third-party wrapper.
+            if (cache[name] !== wrappers[name]) {
+                clean = false;
+                continue;
+            }
+            if (descriptors[name])
+                Object.defineProperty(cache, name, descriptors[name]);
+            else
+                delete cache[name];
+        }
+        return clean;
+    }
+    /**
+     * 退役这个 guard：摘出 WeakMap（之后 acquire 会重建）、撤包装、清墓碑；非正常退役要上报。
+     *
+     * 三种退役理由对应三条真实路径：`idle` = 引用归零的正常释放（不上报）；
+     * `taken-over` = 第三方在我们的包装器之上又包了一层（release 撤不干净，下次删除重建）；
+     * `failed` = 首次使用抛 TypeError（宿主形状变了，已恢复原方法）。
+     */
+    function retire(reason) {
+        if (retired)
+            return;
+        retired = true;
+        if (cacheGuards.get(cache) === self)
+            cacheGuards.delete(cache);
+        blocked.clear();
+        if (reason === "idle")
+            return;
+        noteRuntime({
+            id: "projection-cache-adapter",
+            label: "投影缓存删除屏障",
+            kind: "delete",
+            fallback: "inform-only",
+            detail: reason === "taken-over"
+                ? "宿主缓存的 put/write 已被第三方包装接管：本插件的删除屏障这一轮已退役（缓存行删除少了墓碑拦截），下一次删除会重新安装。"
+                : "投影缓存适配在首次使用时抛错（宿主形状可能变了）：已恢复宿主原方法，下一次删除会重新安装并再探一次。",
+        });
+    }
+    cacheGuards.set(cache, self);
+    return self;
 }
 /**
  * Live-session members the delete sequence needs, split by branch.
@@ -301,7 +371,15 @@ export function createSessionsBridge(ctx, suppliedRegistry, onArchive) {
                     }]);
             if (typeof cache.delete === "function" && typeof cache.whenIdle === "function")
                 return;
-            guard ??= acquireCacheGuard(cache);
+            // 本地这份 guard 可能已经退役（第三方接管 / 首次使用抛错）：退役时已从 WeakMap 摘掉自己，
+            // 这里也得换掉它 —— 拿一个不在岗的屏障去挡墓碑，正是"缓存行静默复活"那条路。
+            const next = acquireCacheGuard(cache);
+            if (next !== guard) {
+                const previous = guard;
+                guard = next;
+                if (previous)
+                    await previous.release().catch(() => undefined);
+            }
             guard.begin(id, header);
         },
         cache() { return guard ?? cache; },

package/lib/sessions/workspace.js

@@ -4,6 +4,24 @@ import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { hubPath } from "../hub.js";
 import { sessionDir } from "@deepseek-ai/dsh-spill-local";
 import { trackTombstone } from "./tombstone.js";
+import { noteRuntime } from "../compat/runtime-notes.js";
+/**
+ * A3-1：宿主补上了原生删除入口时上报一次（**不切换**，理由见 deleteSessionCore）。
+ *
+ * 上报本身就够用：它说明「本插件适配的那个缺口已经被官方补上了」，人工核对过原生语义
+ * （级联 / spill / 记账 / 缓存行是否都覆盖）之后才谈切换。
+ *
+ * @param entry - 实际看到的是哪个原生入口（单删 / 批删），写进详情便于判断。
+ */
+function reportNativeDeleteAvailable(entry) {
+    noteRuntime({
+        id: "workspace.delete-native",
+        label: "宿主原生删除入口",
+        kind: "delete",
+        fallback: "inform-only",
+        detail: `宿主已提供原生 ${entry}：本插件仍走自有完整序列（级联子会话 + spill + 记账 + 缓存行），尚未切换到原生入口。`,
+    });
+}
 //#region lib/types/index.js
 /**
  * 独立归档门面：消费当前宿主服务，不注册或替换 workspaceRegistry。
@@ -923,27 +941,11 @@ var ArchiveWorkspaceRegistry = class {
      * 后续目标并把成功、并发消失和失败分别返回给客户端。
      */
     async deleteArchivedSessions(target) {
-        if (typeof this.registry.deleteArchivedSessions === "function") {
-            const result = await this.registry.deleteArchivedSessions(target);
-            await this.reconcileArchiveLedger();
-            return result;
-        }
+        // 与单删同一条纪律（A3-1）：宿主补上原生批量入口也**先不切换** —— 只上报。
+        if (typeof this.registry.deleteArchivedSessions === "function")
+            reportNativeDeleteAvailable("deleteArchivedSessions");
         // 适配路径（无宿主原生批量入口）：在任何会话被删除之前确认整条链路可用。
         this.bridge.checkWorkspace("delete");
-        if (typeof this.registry.deleteSession === "function") {
-            const requestedSessionIds = this.archivedSessionIdsForTarget(target);
-            const result = { requestedSessionIds, deletedSessionIds: [], skippedSessionIds: [], failures: [] };
-            for (const id of requestedSessionIds) {
-                try {
-                    await this.deleteSession(id);
-                    result.deletedSessionIds.push(id);
-                }
-                catch (error) {
-                    result.failures.push({ sessionId: id, message: String(error) });
-                }
-            }
-            return result;
-        }
         return this.enqueueOperation(async () => {
             const requestedSessionIds = this.archivedSessionIdsForTarget(target);
             // 批首取一次权威快照：批内每一条删除都要一次全库 `listStoredHeaders()`（含逐会话
@@ -1047,18 +1049,19 @@ var ArchiveWorkspaceRegistry = class {
      * @throws {@link ArchiveUnknownSessionError} 会话未知时抛出。
      */
     async deleteSession(sessionId) {
-        if (typeof this.registry.deleteSession === "function") {
-            const result = await this.registry.deleteSession(sessionId);
-            await this.reconcileArchiveLedger();
-            return result;
-        }
+        if (typeof this.registry.deleteSession === "function")
+            reportNativeDeleteAvailable("deleteSession");
         return this.enqueueOperation(() => this.deleteSessionCore(sessionId));
     }
     /** 串行化后的删除主体（级联路径复用：它已持有操作链，绝不能再入队）。
      * @param storedIndex - 可选的批首 `id → header` 快照，见 {@link storedHeaderIndex}。 */
     async deleteSessionCore(sessionId, storedIndex) {
+        // A3-1（第 3 版改向）：宿主补上原生 `deleteSession` 时**先不切换** —— 原生分支跳过本插件
+        // 的级联删子会话 / spill 清理 / 记账清理，等于行为静默缩水；而"切过去的代码"今天不可达，
+        // 写成即等于它会在官方补上入口的那次升级上首次运行，且无从事前验证。保持自有完整序列
+        //（＝今天的能力），只上报一次「宿主已提供原生入口」，切换留到人工核对过原生语义之后。
         if (typeof this.registry.deleteSession === "function")
-            return this.registry.deleteSession(sessionId);
+            reportNativeDeleteAvailable("deleteSession");
         if (this.deleting?.has(sessionId))
             throw new Error(`cyclic subagent lineage at "${sessionId}"`);
         this.deleting ??= new Set();
@@ -1092,6 +1095,16 @@ var ArchiveWorkspaceRegistry = class {
         const sessionRefusals = this.bridge.refusalsFor("delete", requiredSessionCapabilities(live !== void 0));
         if (sessionRefusals.length > 0)
             throw new CapabilityRefusalError("delete", sessionRefusals);
+        // A3-2：转录清理（`removeTranscriptDirectory`）还要 `readSessionHeader` 与
+        // `persistence.locate()`，而它们排在「装屏障 → flush → detach → 清缓存行」**之后**。
+        // 缺任何一个，失败点都落在中段，留下"转录还在、记账已清"的半删态 —— 与上面
+        // `sessions.get` 同一条纪律：破坏性步骤之前先把实现检查完。
+        const headerRefusals = this.bridge.refusalsFor("delete", ["workspace.read-header"]);
+        if (headerRefusals.length > 0)
+            throw new CapabilityRefusalError("delete", headerRefusals);
+        const persistence = this.ctx.get("sessionPersistence");
+        if (persistence === void 0 || typeof persistence.locate !== "function")
+            throw new Error("宿主持久化后端未暴露 locate()（官方接口已变动）；操作在改动任何数据前停止，请更新本插件");
         // 先记录被删生命周期的日志身份：目录删除后头部不可再读，
         // 冷复用探针（sessionKnown 墓碑分支）靠它区分同 id 的新生命周期。
         const deletedHeader = this.headers.get(sessionId) ?? live?.header;
@@ -1342,8 +1355,28 @@ var ArchiveWorkspaceRegistry = class {
             }));
             // 实体快照的形状由宿主 `WorkspaceEntity` 决定（`record` 是私有字段，运行时存在）。
             const entity = this.entities.get(workspaceId);
-            if (entity !== void 0)
+            if (entity === void 0)
+                continue;
+            // A3-3：官方把 `record` 改名或改成只读访问器时，这一行会**静默无效** —— 界面读到旧
+            // 快照（会话计数不动），看起来却"什么都没发生"。写完立刻读回，没写进去就上报；
+            // 仍然照写（不因为探测而少做一次更新）。
+            let applied = false;
+            try {
                 entity.record = next;
+                applied = entity.record === next;
+            }
+            catch {
+                applied = false;
+            }
+            if (!applied) {
+                noteRuntime({
+                    id: "workspace.entity-record",
+                    label: "工作区实体快照更新",
+                    kind: "write",
+                    fallback: "inform-only",
+                    detail: "工作区实体的 record 字段写不进去（宿主 WorkspaceEntity 形状可能已变）：实体快照可能停留在旧值，界面上的会话计数可能不刷新。",
+                });
+            }
         }
     }
     /** 尽力而为的级联删除：删除 `sessionId` 的 SUBAGENT 子会话。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-tool-management",
-  "version": "0.11.0",
+  "version": "0.12.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",
@@ -65,7 +65,7 @@
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/cordis": "^4.0.2",
     "@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",
@@ -92,14 +92,17 @@
     "@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-user-approval": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-workspace": "^0.1.5-rc.2",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.0.0",
     "typescript": "^6.0.0"
   },
   "license": "MIT",
   "dependencies": {
-    "fflate": "^0.8.3"
+    "fflate": "^0.8.3",
+    "js-yaml": "^4.3.2"
   }
 }