dsh-plugin-tool-management 0.14.0 → 0.15.0

package/lib/mcp/manager.js

@@ -1,4 +1,4 @@
-// MCP 管理域 —— 侧车读写（备注 / 设置 / 停用表）+ 补丁文件行编辑 + 16 个 op 的实现。
+// MCP 管理域 —— 侧车读写（备注 / 设置 / 停用表）+ 补丁文件行编辑 + 17 个 op 的实现。
 //
 // 2026-09-19 从 index.ts 的 apply 闭包原样抽出（块 A 1795-1913 + 块 B 1920-3100）。
 // 为什么单独一个文件：这 1300 行只做一件事 —— 把「MCP 配置」翻译成补丁文件的改动与
@@ -18,6 +18,9 @@
 // 其余 14 项（ensurePaths / withWriteLock / readPatch / pluginInventory / memoriesService 等）
 // 由 deps 显式传入。
 import { clearRuntimeNote, noteRuntime } from '../compat/runtime-notes.js';
+// 配置体检查 PATH 用（见 mcpmInspect）：execFile 不走 shell，参数是数组 —— 体检只查询
+// 命令名，**绝不执行**配置里的命令本身。
+import { execFile } from 'node:child_process';
 import { MCP_CLIENT_MODULE } from '../host-names.js';
 import { hubPath } from '../hub.js';
 import { planOverrideCompaction } from './override-blocks.js';
@@ -524,6 +527,7 @@ export function createMcpManager(deps) {
                 kind: 'write',
                 fallback: 'inform-only',
                 detail: 'agent scope 上没有可用的 tools.restrict（官方接口变了或该 scope 未暴露 tools）：停用的 MCP 工具与兼容页关掉的本插件工具仍会出现在模型可见的工具表里，执行侧拦截仍然生效。',
+                detailKey: 'mcp-tool-visibility.no-restrict',
             });
             return;
         }
@@ -550,6 +554,8 @@ export function createMcpManager(deps) {
                 kind: 'write',
                 fallback: 'inform-only',
                 detail: '有工具没能从模型可见的工具表里摘掉（' + message(e) + '）：执行侧拦截仍然生效，模型仍能看到该工具的名字。',
+                detailKey: 'mcp-tool-visibility.partial',
+                params: { reason: message(e) },
             });
         }
     }
@@ -1543,6 +1549,132 @@ export function createMcpManager(deps) {
             return { ok: true, removed: total, ids: removed, files };
         });
     }
+    // ---------- 配置体检（0.15.0 B1）--------------------------------------------------
+    // 只读、零副作用：不拉起子进程、不连网、一个字节都不写盘。唯一的对外调用是 `where` /
+    // `which` 查询 PATH —— 它查的是「这个命令名能不能找到」，绝不执行配置里的命令本身。
+    //
+    // 为什么单独读补丁而不复用 `mcpmList()`：那个函数顺带回写「已知工具」缓存、还要问一次
+    // schema 注册表。体检的承诺是「点了什么都不变」，所以这里只走 readPatch + parseRows。
+    const INSPECT_PATH_TIMEOUT_MS = 3000;
+    /** 命令是否在 PATH 上：`unknown`（查不了）与 `missing`（确认没有）必须分开 —— 前者不是问题。 */
+    async function probeCommandOnPath(command) {
+        if (!command)
+            return 'unknown';
+        const finder = process.platform === 'win32' ? 'where' : 'which';
+        return await new Promise((resolve) => {
+            execFile(finder, [command], { timeout: INSPECT_PATH_TIMEOUT_MS, windowsHide: true }, (error, stdout) => {
+                if (!error) {
+                    resolve(String(stdout || '').trim() ? 'ok' : 'missing');
+                    return;
+                }
+                // ENOENT = 连 where/which 自己都没跑到；killed = 超时。两种都是「无法确认」，
+                // 剩下的（退出码非 0）才是「PATH 上没有这条命令」。
+                const code = error.code;
+                if (code === 'ENOENT' || error.killed === true)
+                    resolve('unknown');
+                else
+                    resolve('missing');
+            });
+        });
+    }
+    /** 一行配置 → 检查项。`level: 'warn'` 才点黄；`info` 是「查不了 / 不算问题」那类说明。 */
+    async function inspectChecks(row, duplicateIds) {
+        const checks = [];
+        const declared = String(row.transport || '');
+        const url = String(row.url || '');
+        const command = String(row.command || '');
+        // transport 缺失/不认识时按字段形状推：历史上手工改过补丁文件的行会绕过 normalize，
+        // 直接判「没有 transport」会把一条其实能用的配置说成坏的。
+        const transport = declared === 'stdio' || (!declared && command && !url) ? 'stdio'
+            : declared === 'streamable-http' || (!declared && url) ? 'streamable-http'
+                : declared;
+        if (!declared && transport)
+            checks.push({ id: 'transportMissing', level: 'info' });
+        /** 值必须是字符串映射：非对象整片算坏，对象里逐个挑出非字符串的键。 */
+        const badKv = (map) => {
+            if (map == null)
+                return [];
+            if (typeof map !== 'object' || Array.isArray(map))
+                return ['*'];
+            return Object.keys(map).filter((k) => typeof map[k] !== 'string');
+        };
+        if (transport === 'stdio') {
+            if (!command)
+                checks.push({ id: 'noCommand', level: 'warn' });
+            else {
+                // 唯一一次外部调用。npx / uvx 这类 shim 找不到时界面给的下半句是「shim 属正常可忽略」，
+                // 不让用户以为命令坏了。
+                const found = await probeCommandOnPath(command);
+                if (found === 'missing')
+                    checks.push({ id: 'cmdMissing', level: 'warn', params: { command } });
+                else if (found === 'unknown')
+                    checks.push({ id: 'cmdUnknown', level: 'info', params: { command } });
+            }
+            if (row.args != null && !Array.isArray(row.args))
+                checks.push({ id: 'argsNotArray', level: 'warn' });
+            const badEnv = badKv(row.env);
+            if (badEnv.length)
+                checks.push({ id: 'kvNotString', level: 'warn', params: { where: 'env', keys: badEnv.join('、') } });
+        }
+        else if (transport === 'streamable-http') {
+            if (!url)
+                checks.push({ id: 'noUrl', level: 'warn' });
+            else if (!/^https?:\/\//.test(url))
+                checks.push({ id: 'badUrl', level: 'warn', params: { url } });
+            const badHeaders = badKv(row.headers);
+            if (badHeaders.length)
+                checks.push({ id: 'kvNotString', level: 'warn', params: { where: 'headers', keys: badHeaders.join('、') } });
+        }
+        else if (!command && !url) {
+            checks.push({ id: 'noEndpoint', level: 'warn' });
+        }
+        else {
+            checks.push({ id: 'badTransport', level: 'warn', params: { transport } });
+        }
+        if (duplicateIds > 1)
+            checks.push({ id: 'nameDup', level: 'warn', params: { name: String(row.serverName || ''), count: duplicateIds } });
+        return checks;
+    }
+    async function mcpmInspect(args) {
+        const p = await ensurePaths();
+        const rows = [];
+        const errors = [];
+        for (const level of ['project', 'global']) {
+            const abs = level === 'project' ? p.projectPatch : p.globalPatch;
+            let content = '';
+            try {
+                content = await readPatch(abs);
+            }
+            catch (e) {
+                errors.push(level + ': ' + message(e));
+                continue;
+            }
+            const { rows: fileRows } = parseRows(content);
+            for (const r of fileRows)
+                rows.push(normalizeRow(r, level, abs));
+        }
+        // 重名判据：同一个 serverName 挂在**不同 id** 下。同 id 跨层是正常遮蔽（界面已有「重复 id」标签），
+        // 而按名字注册的 `mcp__<serverName>__*` 会撞车 —— 那才是配置问题。
+        const idsByName = {};
+        for (const r of rows) {
+            const n = String(r.serverName || '');
+            if (!idsByName[n])
+                idsByName[n] = new Set();
+            idsByName[n].add(String(r.id));
+        }
+        const onlyId = args && String(args.id || '') ? String(args.id) : '';
+        const onlyLevel = args && String(args.level || '') ? String(args.level) : '';
+        const results = [];
+        for (const r of rows) {
+            if (onlyId && String(r.id) !== onlyId)
+                continue;
+            if (onlyLevel && String(r.level) !== onlyLevel)
+                continue;
+            const checks = await inspectChecks(r, (idsByName[String(r.serverName || '')] || new Set()).size);
+            results.push({ id: r.id, serverName: r.serverName, level: r.level, transport: r.transport || null, checks });
+        }
+        return { ok: true, results, errors };
+    }
     async function mcpmExport() {
         const p = await ensurePaths();
         const list = await mcpmList();
@@ -1789,6 +1921,7 @@ export function createMcpManager(deps) {
             'mcpm-compact': mcpmCompact,
             'mcpm-export': mcpmExport,
             'mcpm-import': mcpmImport,
+            'mcpm-inspect': mcpmInspect,
         },
         readDisabledTools,
         readKnownMcpTools,
@@ -1799,13 +1932,19 @@ export function createMcpManager(deps) {
         mcpmRowsWithNotes,
         readPluginSettings,
         isToolDisabled: (name) => isToolDisabledIn(disabledToolsCache ? disabledToolsCache.value : {}, name),
-        /** 停用表里的工具条数（读 TTL 缓存；功能总览用）。 */
-        disabledToolCount: () => {
+        /** 停用表的两个口径（读 TTL 缓存；功能总览用）：`*` 通配的台数 + 单独停用的工具数。 */
+        disabledToolSummary: () => {
             const map = disabledToolsCache ? disabledToolsCache.value : {};
-            let n = 0;
-            for (const list of Object.values(map))
-                n += Array.isArray(list) ? list.length : 0;
-            return n;
+            let servers = 0;
+            let tools = 0;
+            for (const list of Object.values(map)) {
+                if (!Array.isArray(list))
+                    continue;
+                if (list.indexOf('*') >= 0)
+                    servers += 1;
+                tools += list.filter((name) => name !== '*').length;
+            }
+            return { servers, tools };
         },
         warmUp,
         scheduleToolRestrictions,

package/lib/memories/archive-engine.js

@@ -108,6 +108,11 @@ export function createArchiveEngine(deps) {
                 await deps.applySubagentSwitches(personasOn.map((n) => ({ name: n, enabled: true })));
             }
         }
+        // 模型工具表（C1）：按快照原值整体回写。老快照没有这一栏 → 一个字都不动（与进场景前一致）。
+        if (snapshot.toolTableHidden) {
+            await deps.applyToolTableHidden(snapshot.toolTableHidden);
+        }
+        deps.audit?.('scene-restore', '');
     }
     /**
      * 失败回滚：运行时还原 + 切片写回；每步失败都记下来，绝不谎报「已回滚」。
@@ -172,6 +177,15 @@ export function createArchiveEngine(deps) {
             if (entries.length)
                 await deps.applyMcpNotes(entries);
         }
+        // 工具表方案（C1）：改档案 = 立刻生效，这一域也得跟上。快照里的原值**不动** ——
+        // 退出场景仍然回到「进场景前」那份名单，而不是回到上一次档案的方案。
+        const reapplyPreset = (archive && archive.toolTablePreset) || '';
+        if (reapplyPreset) {
+            const target = await deps.toolTablePresetHidden(reapplyPreset);
+            if (target)
+                await deps.applyToolTableHidden(target);
+        }
+        deps.audit?.('scene-apply', '');
         return { mcpServers: mcpPlan.serverSwitches, skillSources: skillsPlan.sourceSwitches };
     }
     const ops = {
@@ -343,6 +357,21 @@ export function createArchiveEngine(deps) {
             for (const s of skillsPlan.sourceSwitches)
                 (s.enabled ? sourcesOn : sourcesOff).push(s.root);
             const stale = [...mcpPlan.stale, ...skillsPlan.stale];
+            // 工具表方案（C1）：绑了就说清「会切成哪一份、关几条」。方案在别处被删掉 / 换机器之后
+            // 查不到时 hiddenCount 给 null，界面那句会改成"方案已不存在，这次不会切换"——
+            // 比让预览卡继续显示一条看不懂的数字诚实。
+            const previewPreset = (archive && archive.toolTablePreset) || '';
+            let toolPreset = null;
+            if (previewPreset) {
+                let list = null;
+                try {
+                    list = await deps.toolTablePresetHidden(previewPreset);
+                }
+                catch (e) {
+                    return { ok: false, error: `读取模型工具表失败：${msg(e)}` };
+                }
+                toolPreset = { name: previewPreset, hiddenCount: list ? list.length : null };
+            }
             const notesDefined = !!(archive && archive.mcpNotes);
             const noteCount = notesDefined
                 ? Object.keys(archive.mcpNotes).filter((server) => archive.mcp && server in archive.mcp).length
@@ -375,6 +404,7 @@ export function createArchiveEngine(deps) {
                     sourcesOn: clip(sourcesOn), sourcesOff: clip(sourcesOff),
                 },
                 subagents: { on: clip(personas.on), off: clip(personas.off) },
+                toolPreset,
                 stale: clip(stale),
                 truncated,
             };
@@ -433,12 +463,29 @@ export function createArchiveEngine(deps) {
                 if (hadKeys && archive.subagents.length === 0)
                     delete archive.subagents;
             }
+            if (archive.toolTablePreset) {
+                // 方案名查不到（被删了 / 档案是从别的机器带来的）→ 丢弃这一栏并报告：
+                // 绑一个不存在的方案不该在进场景时变成一句"方案不存在"的硬失败。
+                const found = await deps.toolTablePresetHidden(archive.toolTablePreset);
+                if (!found) {
+                    stale.push('toolTable/' + archive.toolTablePreset);
+                    delete archive.toolTablePreset;
+                }
+            }
             // 记忆段（P5 已废弃）：不再写入、不再校验。记忆的开关是 `rules[*].enabled` 单一真相源，
             // 老档案里残留的 `memories` 字段被忽略（不迁移、不删除，回滚代码时仍可读）。
             // 保存档案时顺手把残留字段清掉，避免新旧语义并存造成误读。
             if (archive.memories !== undefined)
                 delete archive.memories;
             const slice = await deps.loadSlice();
+            // 工具表方案的绑定入口已改到「修改场景」表单（0.15.0 用户裁定）：档案保存的载荷
+            // 不再携带这一栏，**不带 ≠ 解绑** —— 保留现值（解绑走 rules-update-scene 的空串；
+            // 带上来的值仍走上面的 stale 校验，保留的现值由进出场景时的 stale 处理兜底）。
+            if (archive.toolTablePreset === undefined) {
+                const prev = slice.archives[scene];
+                if (prev && typeof prev.toolTablePreset === 'string' && prev.toolTablePreset)
+                    archive.toolTablePreset = prev.toolTablePreset;
+            }
             if (Object.keys(archive).length === 0)
                 delete slice.archives[scene];
             else
@@ -590,11 +637,28 @@ export function createArchiveEngine(deps) {
                     return { ok: false, error: `读取备注状态失败（未改动任何东西）：${msg(e)}` };
                 }
             }
+            // 工具表方案（C1）：**改任何东西之前**先把现状读出来 —— 读失败就等于什么都没动。
+            // 没绑定方案就完全不碰这一域（也不往快照里加栏），老场景行为逐字节不变。
+            const toolTablePreset = (archive && archive.toolTablePreset) || '';
+            let toolTableBefore = null;
+            let toolTableTarget = null;
+            if (toolTablePreset) {
+                try {
+                    toolTableBefore = await deps.currentToolTableHidden();
+                    toolTableTarget = await deps.toolTablePresetHidden(toolTablePreset);
+                }
+                catch (e) {
+                    return { ok: false, error: `读取模型工具表现状失败（未改动任何东西）：${msg(e)}` };
+                }
+                if (!toolTableTarget) {
+                    return { ok: false, error: `场景绑定的工具表方案「${toolTablePreset}」已不存在，未进入场景（先在场景档案里换一份或取消绑定）` };
+                }
+            }
             // 快照**恒拍**：三个域都按「与勾选集完全一致」应用（未定义 = 全关），所以任何场景
             // 进入都可能改动运行时（哪怕只是停掉几台服务器 / 几个技能），退出都得能精确还原。
             // 上层两行传**现状全量**（上面的 mcpServerStates / skillSources 就是进场景前的值），
             // 不是计划里那几行 —— 退出按「现状 ≠ 记录值」回写（见 mcpServerRowsToRestore）。
-            const snapshot = snapshotRuntime(await deps.currentMcpRaw(), await deps.currentSkills(), mcpServerStates.map((s) => ({ id: s.id, level: s.level, disabled: s.disabled })), skillSources.map((s) => ({ root: s.root, enabled: s.enabled })), personaRestore, personaRestoreOn, noteBefore, personaStates);
+            const snapshot = snapshotRuntime(await deps.currentMcpRaw(), await deps.currentSkills(), mcpServerStates.map((s) => ({ id: s.id, level: s.level, disabled: s.disabled })), skillSources.map((s) => ({ root: s.root, enabled: s.enabled })), personaRestore, personaRestoreOn, noteBefore, personaStates, toolTableBefore);
             const entered = { ...slice, mode: { scene: target, snapshot }, active: [target] };
             try {
                 await deps.saveSlice({ ...slice, mode: entered.mode });
@@ -629,6 +693,10 @@ export function createArchiveEngine(deps) {
                 if (noteTargets && noteTargets.length) {
                     await deps.applyMcpNotes(noteTargets.map((x) => ({ id: x.id, note: x.note })));
                 }
+                // ⑤ 模型工具表：档案绑了方案就把关停名单**整体换成**那份（省下的 token 按轮算，
+                //     所以它是"进入场景"这一动作里唯一直接改每请求内容的域）。
+                if (toolTableTarget)
+                    await deps.applyToolTableHidden(toolTableTarget);
             }
             catch (e) {
                 return await rollback(slice, snapshot, '应用档案', e);
@@ -645,7 +713,7 @@ export function createArchiveEngine(deps) {
                 mode: entered.mode,
                 // 三个域都是「按勾选集全量应用」（未定义 = 全关），所以都算已应用；
                 // 备注段未定义 = 不覆盖任何备注，如实报它是否定义。
-                applied: { mcp: true, skills: true, subagents: true, mcpNotes: !!(archive && archive.mcpNotes) },
+                applied: { mcp: true, skills: true, subagents: true, mcpNotes: !!(archive && archive.mcpNotes), toolTable: !!toolTableTarget },
                 // 上层实际切换了几个（0 = 本来就已经是目标状态，界面不必提示"已停用 N 台"）。
                 switched: {
                     mcpServers: mcpPlan.serverSwitches.length,

package/lib/memories/archive.js

@@ -66,6 +66,10 @@ export function normalizeArchive(raw) {
         out.subagents = normalizeStringList(obj.subagents);
     if (obj.memories != null)
         out.memories = normalizeStringList(obj.memories);
+    // 工具表方案是**标量**不是集合：空串 / 非字符串一律视为未绑定（段不存在）。
+    const toolTablePreset = typeof obj.toolTablePreset === 'string' ? obj.toolTablePreset.trim() : '';
+    if (toolTablePreset)
+        out.toolTablePreset = toolTablePreset;
     return out;
 }
 export function hasSection(archive, section) {
@@ -202,7 +206,9 @@ mcpNotes = [],
  * 进入模式时**全部**人设的开关状态（名字 → 是否开着）。给了就写进 `subagentsAll`：
  * 退出时按它精确还原（场景里手动开过的人设也会被还原回进场景前的状态）。
  */
-subagentStates = null) {
+subagentStates = null, 
+/** 进场景前的模型工具表关停名单（null = 这次不进快照，退出也就不动工具表）。 */
+toolTableHidden = null) {
     return {
         mcp: Object.fromEntries(Object.entries(mcpRaw).map(([k, v]) => [k, v.slice()])),
         skills: { ...skills },
@@ -212,6 +218,7 @@ subagentStates = null) {
         ...(subagentsOn.length ? { subagentsOn: subagentsOn.slice() } : {}),
         ...(subagentStates ? { subagentsAll: { ...subagentStates } } : {}),
         ...(mcpNotes.length ? { mcpNotes: mcpNotes.map((x) => ({ id: x.id, note: x.note })) } : {}),
+        ...(toolTableHidden ? { toolTableHidden: toolTableHidden.slice() } : {}),
     };
 }
 // ── 记忆勾选（v3）──────────────────────────────────────────────────────────

package/lib/memories/index-io.js

@@ -157,6 +157,11 @@ export function parseModeState(raw) {
         .filter((x) => !!x && typeof x === 'object')
         .map((x) => ({ id: String(x.id || ''), note: typeof x.note === 'string' ? x.note : null }))
         .filter((x) => x.id !== '');
+    // v0.15 的模型工具表原值名单：**同样必须原样透传**（剥掉它 = 退出场景后工具表停在方案那份，
+    // 与历史上 mcpServers / mcpNotes 被剥掉是同一类 bug）。老快照没有这一栏 → null = 不还原。
+    const toolTableHidden = Array.isArray(snapshotRaw.toolTableHidden)
+        ? snapshotRaw.toolTableHidden.map((x) => String(x))
+        : null;
     return {
         scene,
         snapshot: scene
@@ -169,6 +174,7 @@ export function parseModeState(raw) {
                 ...(subagentsOn.length ? { subagentsOn } : {}),
                 ...(Object.keys(subagentsAll).length ? { subagentsAll } : {}),
                 ...(mcpNotes.length ? { mcpNotes } : {}),
+                ...(toolTableHidden ? { toolTableHidden } : {}),
             }
             : null,
     };

package/lib/op-registry.js

@@ -31,7 +31,7 @@
 // "会不会改宿主或外部系统的状态"，而上面那些写的是插件自己的侧车（丢了可重建）。
 // 想要它们也带令牌就显式改成 write，别靠"读操作带副作用"这句话推。
 export const OP_REGISTRY = Object.freeze({
-    // ── MCP 域（16）────────────────────────────────────────────────────────────
+    // ── MCP 域（17）────────────────────────────────────────────────────────────
     'mcpm-list': { annotatesLock: true },
     // reveal 返回**未打码**的凭据。它是读操作，但按写门禁 —— 局域网暴露的端口上，令牌对
     // 明文凭据必须是最后一道防线，而不只对着写操作。
@@ -55,6 +55,9 @@ export const OP_REGISTRY = Object.freeze({
     // 会停在启用态 —— 是写不是读。（0.6.0 / 0.7.0 各有漏列前科，见文件头。）
     'mcpm-tools-refresh': { write: true },
     'mcpm-tools': { readonly: true },
+    // 配置体检：只读补丁文件 + 一次 PATH 查询（`where`/`which`，不执行配置里的命令）。
+    // 返回的是检查项 id，不回任何字段值 —— 与 `mcpm-list` 同档，不带令牌。
+    'mcpm-inspect': { readonly: true },
     // ── 技能域（22，含内联的 skill-open）───────────────────────────────────────
     'skill-state': { annotatesLock: true },
     'skill-detail': { readonly: true },
@@ -164,15 +167,26 @@ export const OP_REGISTRY = Object.freeze({
     'bundle-export': { write: true },
     // 新增一条宿主工作区登记 —— 改的是宿主侧的登记，不是插件自己的侧车。
     'history-workspace-register': { write: true },
-    // ── 兼容 / 注入 / 备份域（7）───────────────────────────────────────────────
+    // ── 兼容 / 注入 / 备份 / 流水 / 迁移快照（11）────────────────────────────────
     'compat-status': { readonly: true },
+    // 「最近改动」流水的读侧：只读 hub 里的 `audit.jsonl`（内容只有对象名，见 audit-log.ts 第 ① 条）。
+    'audit-list': { readonly: true },
+    // 清空流水：删的是插件自己的文件，但它是**一次改动**（清完还会留下一条 `audit-clear`），按写门禁。
+    'audit-clear': { write: true },
+    // 整机迁移快照（0.15.0 C2）。export 标 sensitive 与 `mcpm-export` 同档：`includeSecrets` 时
+    // 它交出的就是明文凭据；不配令牌时不设防（判据见 http-fence.ts 的 secretOpRejection）。
+    'snapshot-export': { write: true, sensitive: true },
+    'snapshot-preview': { readonly: true },
+    // 逐域调各域自己的 import op —— 那些 op 本来就被场景冻结挡着，这里不重复标 frozen，
+    // 免得两道锁口径分家（预览与执行都走同一套门禁）。
+    'snapshot-import': { write: true },
     'feature-overview': { readonly: true },
     'preset-reach': { readonly: true },
-    // 五个域当前正文的**全文**都从这里出去。今天不带令牌就能读，是这批只读里披露面最大的一条；
+    // 全部注入域的当前正文**全文**都从这里出去。今天不带令牌就能读，是这批只读里披露面最大的一条；
     // 要不要上门禁是产品决定，登记在这里是为了让它可数。
     'injection-live': { readonly: true },
     'backups-list': { readonly: true },
-    // 注入设置（五域开关 / 压制型预设口径）写侧车。它是"配置"不是"宿主状态"，但改的是
+    // 注入设置（各域开关 / 压制型预设口径）写侧车。它是"配置"不是"宿主状态"，但改的是
     // 投递语义，按写操作门禁。
     'inject-settings': { write: true },
     // 模型工具表（哪些工具根本不发给模型）也写侧车，改的是每轮请求的内容 —— 同上按写门禁。

package/lib/ops/compat.js

@@ -129,15 +129,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 +169,106 @@ 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 ?? '?'}）`);
+                push({
+                    key: 'host-identity', label: '宿主身份与模块', tab: 'compat',
+                    state: assessment === undefined ? 'unknown' : identityIssue ? 'degraded' : 'ok',
+                    detail: assessment === undefined ? '能力探测不可用（归档服务未挂载）'
+                        : identityIssue ? '存在阻塞项：' + (identity?.blockers ?? []).join('；')
+                            : `模块与宿主同源（宿主 DSH ${identity?.version ?? '?'}）`,
+                    ...(assessment === undefined ? {} : { version: identity?.version ?? '?', blockers: identity?.blockers ?? [] }),
+                });
                 // 无独立装配点的域：没有上报就是正常（如实说明依据是"没有降级上报"）。
                 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 +304,7 @@ export function buildCompatOps(deps) {
                 ...(r.failed.length ? { failedCount: r.failed.length, failedNames: r.failed } : {}),
             };
         },
-        // 注入实况（只读）：最近活跃会话里模型**真正看到**的五域文本 + 那一段对话的投递统计。
+        // 注入实况（只读）：最近活跃会话里模型**真正看到**的各域文本 + 那一段对话的投递统计。
         // 回答"勾了开关到底送没送到"——界面配置与实际注入不一致时，这里一眼可见。
         'injection-live': async () => {
             const live = deps.getContextInjectorLive();