dsh-plugin-tool-management 0.11.0 → 0.12.1

package/lib/ops/compat.js

@@ -6,8 +6,10 @@
 //
 // 边界纪律：本文件只负责「op 的实现」，不负责 ops 表之外的接线（MCP 写后刷新、场景锁定
 // 守卫仍作用在组装后的整张表上，见 index.ts）。
-import { EXPECTED_MIN_HOST_VERSION, EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, summarize, } from '../compat/probe.js';
+import { EXPECTED_MIN_HOST_VERSION, EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, routeFor, summarize, } from '../compat/probe.js';
+import { INJECT_DOMAIN_KEYS } from '../context-inject.js';
 import { assessPresetReach } from '../compat/preset-reach.js';
+import { runtimeNotes } from '../compat/runtime-notes.js';
 import { pluginLog } from '../skills/service.js';
 export function buildCompatOps(deps) {
     return {
@@ -29,13 +31,30 @@ export function buildCompatOps(deps) {
                     };
                 }
                 const summary = summarize(assessment);
+                // 运行时降级（A1 的补丁校验、A2 的投影缓存适配、B3 的装配层…）统一在这里并进
+                // findings/degraded：它们不是宿主能力，但必须各占一行 —— 否则用户只能在事故之后
+                // 才知道某道保险没生效。上报口径见 compat/runtime-notes.ts。
+                const extraFindings = runtimeNotes().map((note) => ({
+                    id: note.id,
+                    label: note.label,
+                    kind: note.kind,
+                    owner: 'plugin',
+                    fallback: note.fallback,
+                    state: 'not-available',
+                    missing: [],
+                    detail: note.detail,
+                }));
+                const findings = [...assessment.findings, ...extraFindings];
+                const degraded = [...assessment.degraded, ...extraFindings];
+                const merged = { ...assessment, findings, degraded };
+                const summaryMerged = extraFindings.length === 0 ? summary : summarize(merged);
                 // 每次刷新都留一条结构化日志：升级当天就能在日志里看到降级发生。
                 if (force || !deps.compatLog.version || deps.compatLog.version !== assessment.identity.version) {
                     deps.compatLog.version = assessment.identity.version;
                     void pluginLog()('compat/probe', {
                         hostVersion: assessment.identity.version,
-                        summary,
-                        degraded: assessment.degraded.map((item) => ({ id: item.id, state: item.state, detail: item.detail })),
+                        summary: summaryMerged,
+                        degraded: degraded.map((item) => ({ id: item.id, state: item.state, detail: item.detail })),
                         blockers: assessment.identity.blockers,
                         sameAsHost: assessment.identity.sameAsHost,
                     }).catch(() => { });
@@ -45,15 +64,15 @@ export function buildCompatOps(deps) {
                     host: { version: assessment.identity.version, modules: assessment.identity.modules },
                     sameAsHost: assessment.identity.sameAsHost,
                     unverified: assessment.identity.unverified,
-                    findings: assessment.findings,
-                    degraded: assessment.degraded,
+                    findings,
+                    degraded,
                     blockers: assessment.identity.blockers,
                     mayDelete: assessment.mayDelete,
                     verifiedVersion: VERIFIED_HOST_VERSION,
                     expectedPeerRange: EXPECTED_PEER_RANGE,
                     minHostVersion: EXPECTED_MIN_HOST_VERSION,
                     generatedAt: assessment.generatedAt,
-                    summary,
+                    summary: summaryMerged,
                 };
             }
             catch (e) {
@@ -91,6 +110,77 @@ export function buildCompatOps(deps) {
         },
         // 注入设置（读 / 写）：压制型预设下是否仍然注入 + 各域开关。界面在「兼容」页。
         'inject-settings': (args) => deps.injectSettingsOp(args),
+        // 功能总览（B6）：**按功能点**回答"现在每一项到底能不能用"，三层合成 ——
+        //   ① 装配层（listener / provider / 适配是否真的挂上，来自运行时上报通道）
+        //   ② 宿主能力层（compat 探测的路由判定）
+        //   ③ 用户配置层（开关 / 令牌 / 场景锁定）
+        // 数据全部来自已有的缓存状态与运行时上报，**不新增宿主探测**（避免哨兵真调一类的开销）。
+        // 行内 `tab` 供界面跳转到对应页签；`state` 取值见下方约定。
+        'feature-overview': async () => {
+            try {
+                const registry = deps.getSessionsRegistry();
+                const assessment = registry && typeof registry.capabilities === 'function' ? registry.capabilities() : undefined;
+                const notes = new Map(runtimeNotes().map((note) => [note.id, note]));
+                const settings = await deps.readInjectSettings();
+                const domainsOn = INJECT_DOMAIN_KEYS.filter((key) => settings.domains[key] !== false);
+                const token = await deps.readTokenState();
+                const lockedScenes = await deps.lockedSceneNames();
+                const disabledTools = deps.disabledToolCount();
+                const routeOf = (operation) => assessment === undefined ? undefined : routeFor(assessment, operation);
+                /** 一行一个功能点：状态三层合成，`detail` 写明依据。 */
+                const rows = [];
+                const push = (key, label, tab, state, detail) => rows.push({ key, label, tab, state, detail });
+                // 前置项：插件挂载（这一行本身说明 12 个 inject 都解析了 —— 否则 apply 根本不会跑）；
+                // 启动期那段 `!!js` 表达式若抛错，插件同样不会挂上（它的 try/catch 就是为了不抛）。
+                const mountNote = notes.get('cordis-original-symbol');
+                push('mount', '插件挂载', 'compat', mountNote === undefined ? 'ok' : 'degraded', mountNote === undefined ? '12 个 inject 服务全部解析，插件已挂载（详见 doctor 的挂载心跳）' : mountNote.detail);
+                // 装配层：有上报就是降级，附上报里的原因；没有就是正常。
+                const assemblyRows = [
+                    ['patch-write-guard', '宿主配置写入（补丁校验）', 'mcp'],
+                    ['context-injection', '上下文注入通道', 'compat'],
+                    ['official-suppression', '官方注入的关域拦截', 'compat'],
+                    ['skills-provider', '技能 provider 装配', 'skills'],
+                    ['projection-cache-adapter', '投影缓存删除屏障', 'sessions'],
+                    ['mcp-tool-visibility', '停用工具的可见性', 'mcp'],
+                ];
+                for (const [noteId, label, tab] of assemblyRows) {
+                    const note = notes.get(noteId);
+                    push(noteId, label, tab, note === undefined ? 'ok' : 'degraded', note === undefined ? '装配正常，无降级上报' : note.detail);
+                }
+                // 宿主能力层：删除 / 归档 / 恢复 / 批量各自由路由判定回答（与服务端执行同源）。
+                const deleteRoute = routeOf('delete');
+                push('session-delete', '会话删除', 'sessions', deleteRoute === undefined ? 'unknown' : deleteRoute.via === 'none' ? 'unavailable' : 'ok', deleteRoute === undefined ? '能力探测不可用（归档服务未挂载）'
+                    : deleteRoute.via === 'none' ? '宿主缺少该路径所需能力：' + deleteRoute.refusals.map((item) => item.label).join('、')
+                        : `可用（路径：${deleteRoute.via}）`);
+                for (const [operation, label] of [['archive', '归档'], ['unarchive', '恢复'], ['batch', '批量操作'], ['list', '历史列表']]) {
+                    const decision = routeOf(operation);
+                    push('session-' + operation, `会话${label}`, 'sessions', decision === undefined ? 'unknown' : decision.via === 'none' ? 'unavailable' : 'ok', decision === undefined ? '能力探测不可用（归档服务未挂载）'
+                        : decision.via === 'none' ? '宿主缺少该路径所需能力：' + decision.refusals.map((item) => item.label).join('、')
+                            : `可用（路径：${decision.via}）`);
+                }
+                // 用户配置层：注入域 / 令牌 / 场景锁定 / 停用工具数。
+                push('injection-domains', '注入域开关', 'compat', domainsOn.length === 0 ? 'disabled' : 'ok', domainsOn.length === 0 ? '五个注入域全部关闭（用户设置）' : `${domainsOn.length}/5 个域开启：${domainsOn.join('、')}`);
+                push('token', '访问令牌', 'compat', !token.active ? 'disabled' : token.accepted ? 'ok' : 'locked', !token.active ? '未启用（宿主没配令牌，或令牌功能被关掉）'
+                    : token.accepted ? '已生效且本次启动已通过验证' : '已生效，本次启动尚未验证：写操作与对话会被拦住，到本页下方填写令牌');
+                push('scene-lock', '场景锁定', 'scenes', lockedScenes.length === 0 ? 'ok' : 'locked', lockedScenes.length === 0 ? '无锁定场景' : `锁定中：${lockedScenes.join('、')}（写门禁按锁定场景生效）`);
+                push('mcp-tools', 'MCP 工具停用', 'mcp', disabledTools === 0 ? 'ok' : 'partial', disabledTools === 0 ? '没有停用的工具' : `${disabledTools} 个工具处于停用态（执行拦截 + 可见性摘除）`);
+                push('native-delete', '宿主原生删除入口', 'compat', notes.has('workspace.delete-native') ? 'partial' : 'ok', notes.get('workspace.delete-native')?.detail ?? '宿主未提供原生删除入口（本插件自有完整序列）');
+                // 身份 / 版本：与 compat-status 同一份数据。
+                const identity = assessment?.identity;
+                const identityIssue = identity !== undefined && (identity.blockers.length > 0 || Object.values(identity.sameAsHost).some((same) => same === false));
+                push('host-identity', '宿主身份与模块', 'compat', assessment === undefined ? 'unknown' : identityIssue ? 'degraded' : 'ok', assessment === undefined ? '能力探测不可用（归档服务未挂载）'
+                    : identityIssue ? '存在阻塞项：' + (identity?.blockers ?? []).join('；')
+                        : `模块与宿主同源（宿主 DSH ${identity?.version ?? '?'}）`);
+                // 无独立装配点的域：没有上报就是正常（如实说明依据是"没有降级上报"）。
+                for (const [key, label, tab] of [['memory', '记忆', 'memory'], ['prompts', '提示词', 'prompts'], ['subagents', '子智能体', 'subagents'], ['scenes', '场景档案', 'scenes']]) {
+                    push(key, label, tab, 'ok', '无降级上报（装配失败会出现在这里）');
+                }
+                return { ok: true, rows, generatedAt: Date.now() };
+            }
+            catch (e) {
+                return { ok: false, error: deps.message(e) };
+            }
+        },
         // patch 备份（改宿主配置前的整份副本）：列清单只读，清理按写门禁。
         // 每份备份里都是**明文**凭据，所以给一个显式出口让人能删掉多余的副本（理由见
         // cleanPatchBackups 的注释）。清单不带文件内容，只给名字 / 层级 / 时间 / 大小。

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/lib/skills/catalog.js

@@ -21,7 +21,7 @@
 /** 描述截断长度（与官方目录的 `catalogDescriptionMaxLength` 默认值一致）。 */
 export const SKILL_CATALOG_DESCRIPTION_MAX_LENGTH = 500;
 /** 目录最多列几条；超出只报数量（让模型去调 `skill_manager_list`）。 */
-export const SKILL_CATALOG_MAX_ENTRIES = 50;
+export const SKILL_CATALOG_MAX_ENTRIES = 60;
 /** 描述归一化 + 截断（与官方 `catalogDescription` 同款：折叠空白、超出补省略号）。 */
 function catalogDescription(value, maxLength) {
     const normalized = String(value ?? '').replaceAll(/\s+/g, ' ').trim();

package/lib/subagents/catalog.js

@@ -11,7 +11,7 @@ import { filterBySceneBinding } from './tools.js';
  */
 export const DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH = 500;
 /** 段里最多列几个人设；超出部分只报数量，让模型自己去调 subagent_manager_list。 */
-export const DEFAULT_CATALOG_MAX_ENTRIES = 40;
+export const DEFAULT_CATALOG_MAX_ENTRIES = 60;
 /** 无描述时的占位，与 `subagent_manager_list` 工具的输出保持同一口径。 */
 const NO_DESCRIPTION = '(无描述)';
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-tool-management",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "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",
@@ -33,14 +33,14 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/sync-client.mjs && node scripts/sync-profile.mjs",
-    "prepublishOnly": "npm run build && npm run lint && node --test test/client-exports.test.mjs",
+    "prepublishOnly": "npm run build && npm run lint && npm run typecheck:client && node --test test/client-exports.test.mjs",
     "lint": "node --check lib/client.js && node --check lib/index.js",
     "typecheck:client": "node scripts/sync-client.mjs && tsc -p tsconfig.client.json",
     "check:i18n": "node scripts/check-i18n.mjs lib/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": "npm run build && npm run check:i18n && npm run typecheck:client && node --test test/contracts.test.mjs test/client-exports.test.mjs",
     "sync:profile": "node scripts/sync-profile.mjs"
   },
   "keywords": [
@@ -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"
   }
 }