dsh-plugin-tool-management 0.14.0 → 0.16.0

package/lib/ops/compat.js

@@ -64,6 +64,9 @@ export function buildCompatOps(deps) {
                     host: { version: assessment.identity.version, modules: assessment.identity.modules },
                     sameAsHost: assessment.identity.sameAsHost,
                     unverified: assessment.identity.unverified,
+                    // 身份校验的说明（目前只有「宿主在 app.asar 里」一种）：不是阻塞项，界面据此
+                    // 解释那一排「无法比较」，而不是留给用户一句「两份拷贝，去 --fix」。
+                    notes: assessment.identity.notes,
                     findings,
                     degraded,
                     blockers: assessment.identity.blockers,
@@ -129,15 +132,35 @@ export function buildCompatOps(deps) {
                 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 disabledTools = deps.disabledToolSummary();
                 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 根本不会跑）；
+                const push = (row) => rows.push(row);
+                /** note 降级行的公共字段：透传 note 的 detailKey / params，没有结构化键就只带原文。 */
+                const noteFields = (note) => note === undefined ? {}
+                    : { ...(note.detailKey === undefined ? {} : { detailKey: note.detailKey }), ...(note.params === undefined ? {} : { params: note.params }) };
+                /** 路由判定行的公共字段：可用带 via；不可用带缺失能力的 id + 原始标签（客户端出各语言标签）。 */
+                const routeFields = (decision) => {
+                    if (decision === undefined)
+                        return {};
+                    return decision.via === 'none'
+                        ? { refusals: decision.refusals.map((item) => ({ id: item.id, label: item.label })) }
+                        : { via: decision.via };
+                };
+                const routeDetail = (decision) => decision === undefined ? '能力探测不可用（归档服务未挂载）'
+                    : decision.via === 'none' ? '宿主缺少该路径所需能力：' + decision.refusals.map((item) => item.label).join('、')
+                        : `可用（路径：${decision.via}）`;
+                // 前置项：插件挂载（这一行本身说明 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);
+                push({
+                    key: 'mount', label: '插件挂载', tab: 'compat',
+                    state: mountNote === undefined ? 'ok' : 'degraded',
+                    detail: mountNote === undefined
+                        ? `${deps.injectServiceCount} 个 inject 服务全部解析，插件已挂载（详见 doctor 的挂载心跳）`
+                        : mountNote.detail,
+                    ...(mountNote === undefined ? { params: { count: deps.injectServiceCount } } : noteFields(mountNote)),
+                });
                 // 装配层：有上报就是降级，附上报里的原因；没有就是正常。
                 const assemblyRows = [
                     ['patch-write-guard', '宿主配置写入（补丁校验）', 'mcp'],
@@ -149,52 +172,115 @@ export function buildCompatOps(deps) {
                 ];
                 for (const [noteId, label, tab] of assemblyRows) {
                     const note = notes.get(noteId);
-                    push(noteId, label, tab, note === undefined ? 'ok' : 'degraded', note === undefined ? '装配正常，无降级上报' : note.detail);
+                    push({
+                        key: noteId, label, tab, state: note === undefined ? 'ok' : 'degraded',
+                        detail: note === undefined ? '装配正常，无降级上报' : note.detail,
+                        ...noteFields(note),
+                    });
                 }
                 // 宿主能力层：删除 / 归档 / 恢复 / 批量各自由路由判定回答（与服务端执行同源）。
                 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}）`);
+                push({
+                    key: 'session-delete', label: '会话删除', tab: 'sessions',
+                    state: deleteRoute === undefined ? 'unknown' : deleteRoute.via === 'none' ? 'unavailable' : 'ok',
+                    detail: routeDetail(deleteRoute), ...routeFields(deleteRoute),
+                });
                 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({
+                        key: 'session-' + operation, label: `会话${label}`, tab: 'sessions',
+                        state: decision === undefined ? 'unknown' : decision.via === 'none' ? 'unavailable' : 'ok',
+                        detail: routeDetail(decision), ...routeFields(decision),
+                    });
                 }
                 // 用户配置层：注入域 / 令牌 / 场景锁定 / 停用工具数。
-                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} 个工具处于停用态（执行拦截 + 可见性摘除）`);
-                // 工具表按每个请求付钱：这一行回答"这一轮实际发出去多少"。关掉的工具整份不进请求，
-                // 但代价是模型调不到它们（本插件的面板不受影响）——所以是 partial，不是 ok。
-                // **出厂默认关掉的那几条不算**：那是插件替用户做的一个可逆选择，不是用户关出了
-                // 一个缺口。把默认态报成 partial 违背本页口径（琥珀只留给"该做却没做"），也永远
-                // 无法消掉 —— 用户打开它们反而会被罚一个 ok。
-                // 末尾那句是**逐会话**的差额：官方 `skill` 工具在场的会话里我们那份加载器会再让位
-                // 一个（见 index.ts 的 CARRIER_DUPLICATES），本表的数字是全局口径、不含它。
+                // 分母必须取自 INJECT_DOMAIN_KEYS：0.14.0 场景与记忆分家后域从 5 个变 6 个，
+                // 写死的「/5」把 6/6 报成 6/5（2026-09-28 用户实测）。
+                const domainTotal = INJECT_DOMAIN_KEYS.length;
+                push({
+                    key: 'injection-domains', label: '注入域开关', tab: 'compat',
+                    state: domainsOn.length === 0 ? 'disabled' : 'ok',
+                    detail: domainsOn.length === 0 ? `${domainTotal} 个注入域全部关闭（用户设置）` : `${domainsOn.length}/${domainTotal} 个域开启：${domainsOn.join('、')}`,
+                    domains: domainsOn, count: domainsOn.length, total: domainTotal,
+                });
+                push({
+                    key: 'token', label: '访问令牌', tab: 'compat',
+                    state: !token.active ? 'disabled' : token.accepted ? 'ok' : 'locked',
+                    detail: !token.active ? '未启用（宿主没配令牌，或令牌功能被关掉）'
+                        : token.accepted ? '已生效且本次启动已通过验证' : '已生效，本次启动尚未验证：写操作与对话会被拦住，到本页下方填写令牌',
+                });
+                push({
+                    key: 'scene-lock', label: '场景锁定', tab: 'scenes',
+                    state: lockedScenes.length === 0 ? 'ok' : 'locked-scene',
+                    detail: lockedScenes.length === 0 ? '无锁定场景' : `锁定中：${lockedScenes.join('、')}（写门禁按锁定场景生效）`,
+                    scenes: lockedScenes,
+                });
+                // 停用是用户配置或场景收窄的**事实**，不是故障：功能本身的好坏由上面「工具表可见性」
+                // 装配行报（`mcp-tool-visibility` 降级 = 拦截/摘除没装上），这一行只如实陈述停用构成，
+                // 状态恒为 ok —— 否则"只开了几台 MCP"的用户会一直看到琥珀，以为出了问题
+                // （2026-09-28 用户裁定：琥珀只留给功能出问题）。
+                // 「N 个工具」也说不清整台停用：一条 `*` 通配背后是那台服务器的全部工具，
+                // 按条目数报会把 6 台整台停用读成"6 个工具"。两个口径分开说：台数只数 `*`，工具数只数单独停用的条目。
+                const disabledPart = disabledTools.servers > 0 && disabledTools.tools > 0
+                    ? `${disabledTools.servers} 台服务器整台停用 + ${disabledTools.tools} 个工具单独停用`
+                    : disabledTools.servers > 0
+                        ? `${disabledTools.servers} 台服务器整台停用`
+                        : disabledTools.tools > 0
+                            ? `${disabledTools.tools} 个工具单独停用`
+                            : '没有停用的工具';
+                push({
+                    key: 'mcp-tools', label: 'MCP 工具停用', tab: 'mcp', state: 'ok',
+                    detail: disabledPart + (disabledTools.servers + disabledTools.tools === 0 ? '' : '（执行拦截 + 可见性摘除）'),
+                    servers: disabledTools.servers, tools: disabledTools.tools,
+                });
+                // 工具表按每个请求付钱：这一行回答"这一轮实际发出去多少"。关掉（无论出厂默认还是
+                // 用户自己关）都是**配置事实**而非故障 —— 状态恒为 ok，琥珀只留给功能出问题
+                // （口径与 MCP 工具停用一致，2026-09-28 用户裁定）。出厂默认关掉的那几条单说：
+                // 那是插件替用户做的一个可逆选择，与用户自己关的分开计数。
+                // 说明只保留一句关了多少：省多少 tok、去哪开关、面板不受影响、skill_manager_read
+                // 让位这些次级信息都不上功能总览（正常行一行读完，2026-09-28 用户反馈）；
+                // 逐会话的让位差额（index.ts 的 CARRIER_DUPLICATES）在别处自有交代。
                 const table = deps.toolTableReport();
-                const carrierNote = '；官方 `skill` 工具在场的会话，`skill_manager_read` 还会自动让位一份';
                 const userOff = table.hiddenCount - table.defaultHiddenCount;
                 const offPart = table.hiddenCount === 0
-                    ? `${table.totalCount} 个工具全部下发（≈${table.totalTok} tok/轮）`
+                    ? `${table.totalCount} 个工具全部下发`
                     : (userOff === 0
                         ? `出厂默认关掉 ${table.defaultHiddenCount}/${table.totalCount} 个`
-                        : `关掉 ${table.hiddenCount}/${table.totalCount} 个（含出厂默认 ${table.defaultHiddenCount} 个）`)
-                        + `：一轮少发 ≈${table.hiddenTok} tok（现在 ≈${table.visibleTok} tok/轮，到「兼容」页的「模型工具表」可逐条打开；面板不受影响）`;
-                push('tool-table', '模型工具表', 'compat', userOff === 0 ? 'ok' : 'partial', offPart + carrierNote);
-                push('native-delete', '宿主原生删除入口', 'compat', notes.has('workspace.delete-native') ? 'partial' : 'ok', notes.get('workspace.delete-native')?.detail ?? '宿主未提供原生删除入口（本插件自有完整序列）');
+                        : `关掉 ${table.hiddenCount}/${table.totalCount} 个（含出厂默认 ${table.defaultHiddenCount} 个）`);
+                push({
+                    key: 'tool-table', label: '模型工具表', tab: 'compat', state: 'ok', detail: offPart,
+                    hidden: table.hiddenCount, total: table.totalCount, defaults: table.defaultHiddenCount,
+                });
+                const nativeNote = notes.get('workspace.delete-native');
+                push({
+                    key: 'native-delete', label: '宿主原生删除入口', tab: 'compat',
+                    state: nativeNote ? 'partial' : 'ok',
+                    detail: nativeNote?.detail ?? '宿主未提供原生删除入口（本插件自有完整序列）',
+                    ...noteFields(nativeNote),
+                });
                 // 身份 / 版本：与 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 ?? '?'}）`);
+                // 归档宿主（桌面版）：不是阻塞项，但"模块与宿主同源"这句话对它不成立（同版本、
+                // 不同文件），所以总览那一行要换句话讲，而不是继续报一句善意的假话。
+                const asarHost = identity?.notes.find((note) => note.kind === 'asar-host');
+                push({
+                    key: 'host-identity', label: '宿主身份与模块', tab: 'compat',
+                    state: assessment === undefined ? 'unknown' : identityIssue ? 'degraded' : 'ok',
+                    detail: assessment === undefined ? '能力探测不可用（归档服务未挂载）'
+                        : identityIssue ? '存在阻塞项：' + (identity?.blockers ?? []).join('；')
+                            : asarHost !== undefined
+                                ? `官方包与宿主同版本，但宿主跑在 ${asarHost.asarName} 里（插件在归档外）`
+                                : `模块与宿主同源（宿主 DSH ${identity?.version ?? '?'}）`,
+                    ...(assessment === undefined ? {} : {
+                        version: identity?.version ?? '?',
+                        blockers: identity?.blockers ?? [],
+                        ...(asarHost === undefined ? {} : { asarHost: true, asarName: asarHost.asarName }),
+                    }),
+                });
                 // 无独立装配点的域：没有上报就是正常（如实说明依据是"没有降级上报"）。
                 for (const [key, label, tab] of [['memory', '记忆', 'memory'], ['prompts', '提示词', 'prompts'], ['subagents', '子智能体', 'subagents'], ['scenes', '场景档案', 'scenes']]) {
-                    push(key, label, tab, 'ok', '无降级上报（装配失败会出现在这里）');
+                    push({ key, label, tab, state: 'ok', detail: '无降级上报（装配失败会出现在这里）' });
                 }
                 return { ok: true, rows, generatedAt: Date.now() };
             }
@@ -230,7 +316,7 @@ export function buildCompatOps(deps) {
                 ...(r.failed.length ? { failedCount: r.failed.length, failedNames: r.failed } : {}),
             };
         },
-        // 注入实况（只读）：最近活跃会话里模型**真正看到**的五域文本 + 那一段对话的投递统计。
+        // 注入实况（只读）：最近活跃会话里模型**真正看到**的各域文本 + 那一段对话的投递统计。
         // 回答"勾了开关到底送没送到"——界面配置与实际注入不一致时，这里一眼可见。
         'injection-live': async () => {
             const live = deps.getContextInjectorLive();

package/lib/ops/scene-records.js

@@ -108,6 +108,18 @@ export function buildSceneRecordOps(rc) {
         if (name === GLOBAL_SCENE)
             next.label = GLOBAL_SCENE_LABEL;
         index.scenes[name] = next;
+        // 模型工具表方案绑定（0.15.0 用户裁定：入口改到「修改场景」表单）：绑定存**档案**，
+        // 只在真的绑了东西时才建档案存根 —— 不绑就保持「没有档案」的原语义
+        //（没有档案与有空档案在进入场景的预览提示上不等价）。
+        const toolTablePreset = args && args.toolTablePreset !== undefined ? String(args.toolTablePreset).trim() : '';
+        if (toolTablePreset.length > 64) {
+            return fail('error.rules.invalidGroup', `工具表方案名过长（≤64 字符）`);
+        }
+        if (toolTablePreset !== '') {
+            if (!index.archives)
+                index.archives = {};
+            index.archives[name] = { ...(index.archives[name] || {}), toolTablePreset };
+        }
         await writeIndex(stateDir, index);
         invalidateSnapshot();
         return { ok: true, scene: sceneRecordOf(name, next), ...(collapsed ? { collapsedActive: true } : {}) };
@@ -158,6 +170,28 @@ export function buildSceneRecordOps(rc) {
             else
                 next.prompt = prompt;
         }
+        if (args && args.toolTablePreset !== undefined) {
+            // 模型工具表方案绑定（0.15.0 用户裁定：入口改到「修改场景」表单）：绑定存**档案**，
+            // 记录与档案同在一份索引 JSON，这一次读-改-写顺带落掉。''= 解绑（删字段；档案因此
+            // 变空时整条删掉，与档案保存「空档案不落条目」的约定一致）；不传这个参数 = 完全不碰
+            // 这一域（旧调用方兼容）。绑了不存在的方案在这里不硬失败 —— 引擎在进出场景时按
+            // stale 丢弃并报告，和档案保存对悬空绑定的处理同口径。
+            const toolTablePreset = String(args.toolTablePreset).trim();
+            if (toolTablePreset.length > 64) {
+                return fail('error.rules.invalidGroup', `工具表方案名过长（≤64 字符）`);
+            }
+            if (!index.archives)
+                index.archives = {};
+            const archive = { ...((index.archives && index.archives[name]) || {}) };
+            if (toolTablePreset === '')
+                delete archive.toolTablePreset;
+            else
+                archive.toolTablePreset = toolTablePreset;
+            if (Object.keys(archive).length > 0)
+                index.archives[name] = archive;
+            else
+                delete index.archives[name];
+        }
         if (args && args.label !== undefined && name !== GLOBAL_SCENE) {
             const label = String(args.label).trim();
             if (label === '')

package/lib/ops/scene-sync.js

@@ -10,7 +10,18 @@ export function buildSceneSyncOps(deps) {
         // 的 `agentsMd` 字段（`applied` / `restored` / `unchanged` / `error`）。
         // 组装时放在 memoriesService.ops 的 spread **之后**，显式覆盖同名 op。
         'rules-set-active': async (args) => deps.withAgentsMdSync(await deps.rulesOps['rules-set-active'](args)),
-        'rules-update-scene': async (args) => deps.withAgentsMdSync(await deps.rulesOps['rules-update-scene'](args)),
+        'rules-update-scene': async (args) => {
+            const res = await deps.rulesOps['rules-update-scene'](args);
+            // 工具表方案绑定改动（0.15.0）：改的是**当前启用场景**且这次真的带了这一参数时即时生效；
+            // 改名在场景处于模式中时会被拦（rulesUpdateScene 的 sceneInMode），所以这里 args.name 就是生效场景的名字。
+            if (res && res.ok !== false && deps.onToolTablePresetChanged && args && args.toolTablePreset !== undefined) {
+                try {
+                    await deps.onToolTablePresetChanged(String(args.name || ''), String(args.toolTablePreset));
+                }
+                catch { /* 即时生效失败不拦保存；下次进/退场景会对齐 */ }
+            }
+            return deps.withAgentsMdSync(res);
+        },
         'rules-create-scene': async (args) => deps.withAgentsMdSync(await deps.rulesOps['rules-create-scene'](args)),
         'rules-remove-scene': async (args) => deps.withAgentsMdSync(await deps.rulesOps['rules-remove-scene'](args)),
     };

package/lib/ops/sessions.js

@@ -54,7 +54,27 @@ export function buildSessionOps(deps) {
                     ? (await registry.archivedSessionDetails()).items
                     : (await registry.archivedSessionMetadata()).items;
                 const archived = new Set(archivedItems.map((i) => i.sessionId));
+                // 官方契约（dsh-session-projection-cache 源码）：cachedSnapshot(meta, keys?) 两参，
+                // keys 缺省 = 全部 wire 键；keys 传非可迭代值会在 viewCheckpoint 里 new Set 抛错。
+                // 旧格式代际的缓存记录过不了 cachedSnapshot 的身份校验，官方另有只认标题的
+                // cachedPredecessorTitle 提示面（api-session-controller 的列表路径正是两者相或）。
                 const cache = deps.host('sessionProjectionCache');
+                const titleOf = (header) => {
+                    if (!cache)
+                        return undefined;
+                    try {
+                        const snap = typeof cache.cachedSnapshot === 'function' ? cache.cachedSnapshot(header, ['title']) : undefined;
+                        const current = snap && snap.values ? snap.values.title : undefined;
+                        if (typeof current === 'string')
+                            return current;
+                        const legacy = typeof cache.cachedPredecessorTitle === 'function' ? cache.cachedPredecessorTitle(header) : undefined;
+                        const legacyTitle = legacy && legacy.values ? legacy.values.title : undefined;
+                        return typeof legacyTitle === 'string' ? legacyTitle : undefined;
+                    }
+                    catch {
+                        return undefined;
+                    }
+                };
                 const items = [];
                 for (const h of headers) {
                     const sessionId = h && typeof h.id === 'string' ? h.id : undefined;
@@ -71,14 +91,9 @@ export function buildSessionOps(deps) {
                         item.cwd = h.cwd;
                     if (typeof h.createdAt === 'number' && Number.isFinite(h.createdAt))
                         item.createdAt = h.createdAt;
-                    if (cache && typeof cache.cachedSnapshot === 'function') {
-                        try {
-                            const snap = cache.cachedSnapshot(h, 0, ['title']);
-                            if (snap && snap.values && typeof snap.values.title === 'string')
-                                item.title = snap.values.title;
-                        }
-                        catch { /* title best-effort */ }
-                    }
+                    const title = titleOf(h);
+                    if (title !== undefined)
+                        item.title = title;
                     // 工作区目录可能已被删除/移动（孤儿会话）：best-effort 标记，供导出选择时识别。
                     if (item.cwd) {
                         try {