dsh-plugin-tool-management 0.13.0 → 0.15.0

package/lib/mcp/loader-token.js

@@ -9,8 +9,10 @@
 // 全部抹掉、把 `!!js` 引号风格改掉、把不认识的键重排 —— 一次"设置令牌"不该顺带重写整个
 // 文件。（这与 `override-blocks.ts` 选择"只算删除区间"是同一条理由。）
 //
-// 边界：只动**本插件 id 那条 insert 子条目**内的 `config:` / `token:` 两行，别的一概不碰。
-// 找不到那条行时如实回 `found: false`，由调用方决定怎么报错，绝不"找不到就新建一条"。
+// 边界：只动**本插件 id 那条条目**内的 `config:` / `token:` 两行，别的一概不碰。条目有两种
+// 形状（见 ROW_ID_RE 的注释）：0.1.5 补丁里嵌套的 insert 子条目、0.1.7 profile 补丁里顶层
+// 的覆盖条目 —— 同一套相对缩进逻辑都认。找不到那条行时如实回 `found: false`，由调用方
+// 决定怎么报错；唯一的"新建"路径是 0.1.7 的覆盖条目（buildLoaderOverrideEntry，见下）。
 //
 // 两个**不改写、只拒绝**的形状（2026-09-19 审计 T-28）：
 //   - `config:` 写成 flow style（`config: {token: x}`）或缩进不是 6 空格 ⇒ 本模块的
@@ -22,17 +24,15 @@
 const yq = (value) => JSON.stringify(value);
 /** 本插件 loader 行的 id（与 cordis.patch.yml 里那条 insert 子条目一致）。 */
 export const PLUGIN_LOADER_ID = 'dsh-plugin-tool-management';
-const ROW_ID_RE = /^ {4}- id:\s*(\S+)\s*$/;
-const CONFIG_RE = /^ {6}config:\s*$/;
+/**
+ * 行首 `- id:` 的缩进就是条目的几何原点：0.1.5 的补丁把条目嵌在映射里（4 空格，config
+ * 在 6、键在 8）；0.1.7 的 profile 覆盖条目在顶层（0 空格，config 在 2、键在 4）。两类形状
+ * 用同一套「相对缩进」逻辑定位，readLoaderToken / rewriteConfigKey 都按条目自己的缩进算。
+ */
+const ROW_ID_RE = /^( *)- id:\s*(\S+)\s*$/;
 /** `config:` 的任何别的写法（flow style `config: {…}`、非空值、别的缩进）—— 一律不改写。 */
 const CONFIG_OTHER_RE = /^\s*config:\s*\S/;
-const keyRe = (key) => new RegExp('^ {8}' + key + ':\\s*(.*)$');
-const TOKEN_RE = keyRe('token');
-const DISABLED_RE = keyRe('tokenDisabled');
-/** 该子条目块内的行：缩进 ≥ 6（键），或空行/注释（块间空隙，归前一块）。 */
-const inRowBlock = (line) => line.trim() === '' || /^\s*#/.test(line) || /^ {6,}\S/.test(line);
-/** config 块内的行：缩进 ≥ 8，或空行/注释。 */
-const inConfigBlock = (line) => line.trim() === '' || /^\s*#/.test(line) || /^ {8,}\S/.test(line);
+const keyRe = (indent, key) => new RegExp('^ {' + indent + '}' + key + ':\\s*(.*)$');
 const unquote = (raw) => {
     const text = raw.trim();
     if (text.length >= 2 && ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'")))) {
@@ -76,12 +76,23 @@ function parseFlag(raw) {
 /** 定位插件 loader 行及其 `config:` 块（找不到行时 `start < 0`）。 */
 function locate(content, pluginId) {
     const lines = content.split(/\r?\n/);
-    const start = lines.findIndex((line) => {
-        const m = ROW_ID_RE.exec(line);
-        return !!m && m[1] === pluginId;
-    });
+    let start = -1;
+    let indent = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const m = ROW_ID_RE.exec(lines[i]);
+        if (m && m[2] === pluginId) {
+            start = i;
+            indent = m[1].length;
+            break;
+        }
+    }
     if (start < 0)
-        return { lines, start: -1, end: -1, configAt: -1, configEnd: -1, configUnrecognised: false, configDuplicated: false };
+        return { lines, start: -1, end: -1, indent: 0, configAt: -1, configEnd: -1, configUnrecognised: false, configDuplicated: false };
+    // 该子条目块内的行：缩进 ≥ 条目+2（键），或空行/注释（块间空隙，归前一块）。
+    const inRowBlock = (line) => line.trim() === '' || /^\s*#/.test(line) || new RegExp('^\\s{' + (indent + 2) + ',}\\S').test(line);
+    // config 块内的行：缩进 ≥ 条目+4，或空行/注释。
+    const inConfigBlock = (line) => line.trim() === '' || /^\s*#/.test(line) || new RegExp('^\\s{' + (indent + 4) + ',}\\S').test(line);
+    const configRe = new RegExp('^ {' + (indent + 2) + '}config:\\s*$');
     let end = start + 1;
     while (end < lines.length && inRowBlock(lines[end]))
         end++;
@@ -89,7 +100,7 @@ function locate(content, pluginId) {
     let configCount = 0;
     let configUnrecognised = false;
     for (let i = start + 1; i < end; i++) {
-        if (CONFIG_RE.test(lines[i])) {
+        if (configRe.test(lines[i])) {
             configCount += 1;
             if (configAt < 0)
                 configAt = i;
@@ -106,24 +117,26 @@ function locate(content, pluginId) {
         while (configEnd < end && inConfigBlock(lines[configEnd]))
             configEnd++;
     }
-    return { lines, start, end, configAt, configEnd, configUnrecognised, configDuplicated: configCount > 1 };
+    return { lines, start, end, indent, configAt, configEnd, configUnrecognised, configDuplicated: configCount > 1 };
 }
 /** 读插件 loader 行里的 `config.token` / `config.tokenDisabled`（没写 / 没这条行都返回空值）。 */
 export function readLoaderToken(content, pluginId = PLUGIN_LOADER_ID) {
-    const { lines, start, end, configAt, configEnd } = locate(content, pluginId);
+    const { lines, start, configAt, configEnd, indent } = locate(content, pluginId);
     if (start < 0)
         return { found: false, token: '', disabled: false };
     if (configAt < 0)
         return { found: true, token: '', disabled: false };
+    const tokenRe = keyRe(indent + 4, 'token');
+    const disabledRe = keyRe(indent + 4, 'tokenDisabled');
     let token = '';
     let disabled = false;
     for (let i = configAt + 1; i < configEnd; i++) {
-        const t = TOKEN_RE.exec(lines[i]);
+        const t = tokenRe.exec(lines[i]);
         if (t) {
             token = unquote(t[1]);
             continue;
         }
-        const d = DISABLED_RE.exec(lines[i]);
+        const d = disabledRe.exec(lines[i]);
         // `null` = 值既不是 true 也不是 false（宿主同样不当成"已关闭"），按未关闭处理。
         if (d)
             disabled = parseFlag(d[1]) === true;
@@ -143,8 +156,8 @@ export function readLoaderToken(content, pluginId = PLUGIN_LOADER_ID) {
  *
  * @param line - 要写入的整行（含缩进）；`null` = 删除该键。
  */
-function rewriteConfigKey(content, key, line, pluginId) {
-    const { lines, start, end, configAt, configEnd, configUnrecognised, configDuplicated } = locate(content, pluginId);
+function rewriteConfigKey(content, key, value, pluginId) {
+    const { lines, start, end, indent, configAt, configEnd, configUnrecognised, configDuplicated } = locate(content, pluginId);
     if (start < 0)
         return { found: false };
     // 写之前先自检：这两种形状一旦落盘就是"DSH 下次起不来"（官方 js-yaml 对重复映射键 throw），
@@ -165,7 +178,7 @@ function rewriteConfigKey(content, key, line, pluginId) {
             refused: '本插件那条 loader 行里的 `config:` 不是插件认识的写法（flow style 或缩进不是 6 空格），自动改写会插入重复键并导致 DSH 启动失败：请手工把它改回 `      config:` + 缩进 8 空格的键值行，或在配置里手工写 token。',
         };
     }
-    const re = keyRe(key);
+    const re = keyRe(indent + 4, key);
     const keyAt = (() => {
         if (configAt < 0)
             return -1;
@@ -174,6 +187,8 @@ function rewriteConfigKey(content, key, line, pluginId) {
                 return i;
         return -1;
     })();
+    // 要写的整行（含缩进）；`value === null` = 删除该键。缩进按条目自己的原点算。
+    const line = value === null ? null : ' '.repeat(indent + 4) + key + ': ' + value;
     // 写之后的第二道自检：不管走哪条分支，产物里 `config:` 只能有一个。宁可原样退回，
     // 也不让一次界面点击产出一个"DSH 下次起不来"的补丁文件。
     const commit = (nextContent) => {
@@ -194,7 +209,7 @@ function rewriteConfigKey(content, key, line, pluginId) {
         // 这个键之外还有别的键吗？（在原行上判断，避免 splice 之后的下标漂移算错）
         const otherKeys = lines
             .slice(configAt + 1, configEnd)
-            .some((row, index) => configAt + 1 + index !== keyAt && /^ {8,}\S/.test(row));
+            .some((row, index) => configAt + 1 + index !== keyAt && new RegExp('^\\s{' + (indent + 4) + ',}\\S').test(row));
         next.splice(keyAt, 1);
         if (!otherKeys)
             next.splice(configAt, 1);
@@ -211,7 +226,7 @@ function rewriteConfigKey(content, key, line, pluginId) {
         return commit(next.join('\n'));
     }
     // 没有 config：紧跟 `- id:` 之后插入（映射键的顺序不影响 YAML 语义，位置固定才好断言）。
-    next.splice(start + 1, 0, '      config:', line);
+    next.splice(start + 1, 0, ' '.repeat(indent + 2) + 'config:', line);
     return commit(next.join('\n'));
 }
 /**
@@ -223,7 +238,7 @@ function rewriteConfigKey(content, key, line, pluginId) {
  *   否则给出新全文与"是否真的改了"。
  */
 export function applyLoaderToken(content, token, pluginId = PLUGIN_LOADER_ID) {
-    return rewriteConfigKey(content, 'token', token === null ? null : '        token: ' + yq(token), pluginId);
+    return rewriteConfigKey(content, 'token', token === null ? null : yq(token), pluginId);
 }
 /**
  * 打开（`true`）或关掉（`false`）令牌功能 —— **不动 `config.token` 本身**。
@@ -234,5 +249,15 @@ export function applyLoaderToken(content, token, pluginId = PLUGIN_LOADER_ID) {
  * @param disabled - `true` 写开关；`false` / `null` 删掉该键。
  */
 export function applyLoaderTokenDisabled(content, disabled, pluginId = PLUGIN_LOADER_ID) {
-    return rewriteConfigKey(content, 'tokenDisabled', disabled === true ? '        tokenDisabled: true' : null, pluginId);
+    return rewriteConfigKey(content, 'tokenDisabled', disabled === true ? 'true' : null, pluginId);
+}
+/**
+ * 0.1.7 bundle 挂载下的令牌落点：profile 补丁里的**覆盖条目**（官方 `applyEntryPatches`
+ * 的 id-targeted override —— 不带 name / insert、只带 id + config，宿主在 bundle 层之后
+ * 应用它，整体替换那条 loader 的 `config`；bundle 条目没有 config，替换零丢失）。
+ * 注意：同 id 的 **insert** 条目才会重复挂载、启动失败；覆盖条目是官方支持的改法，
+ * 目标不存在的树只是逐条警告跳过（一份 overlay 打多个表面，不必每棵树都命中）。
+ */
+export function buildLoaderOverrideEntry(token, pluginId = PLUGIN_LOADER_ID) {
+    return '- id: ' + pluginId + '\n  config:\n    token: ' + yq(token);
 }

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,12 +18,15 @@
 // 其余 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';
 import { createMcpStateCatalog } from './state-section.js';
 import { appendBlock, buildDisableBlock, buildInsertBlock, parseRows, removeEntryAll, removeMarked, spliceRanges, splitLines, } from './patch-yaml.js';
-import { describeMaskedOutcome, maskedKeysIn, resolveMaskedKv, resolveMaskedUrl } from './secret-guard.js';
+import { describeMaskedOutcome, maskUrlQuery, maskedKeysIn, resolveMaskedKv, resolveMaskedUrl } from './secret-guard.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) },
             });
         }
     }
@@ -653,19 +659,8 @@ export function createMcpManager(deps) {
         }
         return out;
     }
-    function maskUrlQuery(url) {
-        if (!url)
-            return url;
-        try {
-            const parsed = new URL(url);
-            if (parsed.search)
-                parsed.search = '?<redacted>';
-            return parsed.toString();
-        }
-        catch (e) {
-            return url;
-        }
-    }
+    // `maskUrlQuery` 已挪到 ./secret-guard.js：那里是两条打码形态的唯一口径，而使用方
+    // 现在有两个（本文件的列表视图 + index.ts 的确认卡）。
     /** Shared UI rows: mcpmList plus notes, secrets masked unless `reveal`. */
     async function mcpmRowsWithNotes(reveal) {
         const result = await mcpmList();
@@ -1554,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();
@@ -1800,6 +1921,7 @@ export function createMcpManager(deps) {
             'mcpm-compact': mcpmCompact,
             'mcpm-export': mcpmExport,
             'mcpm-import': mcpmImport,
+            'mcpm-inspect': mcpmInspect,
         },
         readDisabledTools,
         readKnownMcpTools,
@@ -1810,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/mcp/secret-guard.js

@@ -69,6 +69,27 @@ export function isMaskedUrl(value) {
         return false;
     }
 }
+/**
+ * 把 URL 的查询串换成 `<redacted>` 哨兵 —— 打码的**产出**侧，与上面的 `isMaskedUrl` 配对。
+ *
+ * 放在这里而不是 manager.ts 里：本模块是这两条打码形态的唯一口径，而使用方已经有两个
+ * ——MCP 列表视图（`mcpmRowsWithNotes`），以及模型调 `mcp_manager_save` 时的确认卡
+ * （卡里要回显"新 URL"，但用户批准的是「跑这个地址」，查询串里的凭据不该明文进卡片）。
+ * 两处各写一份的话，改了一处就会漂成两种打码形态，而 `isMaskedUrl` 只认其中一种。
+ */
+export function maskUrlQuery(url) {
+    if (!url)
+        return url;
+    try {
+        const parsed = new URL(url);
+        if (parsed.search)
+            parsed.search = '?' + URL_REDACTED_QUERY;
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
 /**
  * 把表单来的 URL 收敛成"可以安全写盘"的一个（与 `resolveMaskedKv` 同方向：往旧值收）。
  *

package/lib/mcp/state-section.js

@@ -21,13 +21,12 @@
 //     不列的三类：**没开**（用户明确要求）、**工具全被停用**（模型调不到，留着只会谎报数量）、
 //     **从未连上过**（缓存也空 —— 一直没成功过，不该反复打扰；这条抄的是 Claude Code 的通知
 //     策略：一直没连上的不提示，昨天还好今天挂的才提示）。
-//   - 只列 **server 名 + 工具数 + 备注**；**具体工具名绝不注入** ——
+//   - 只列 **server 名 + 状态（仅②档）+ 备注**；**具体工具名绝不注入** ——
 //     已启用 server 的工具本来就在模型自己的工具 schema 里（`mcp__<server>__<tool>`），
 //     段里再列一遍是重复；模型按前缀就能对上号。
-//   - 工具数只算**当前可用**的：被停用的那一部分不显示（它就是模型 schema 里没有的），
-//     数字必须与模型能调到的工具对得上。②档没有当前数字，所以写的是「上次连上时 N 个工具」——
-//     那是历史事实，不是现状，措辞上必须区分开。
-//   - 无备注 → 只有名字 + 工具数（正是「不写就只知道名字」）。
+//   - **工具数不列**（2026-09-23）：模型不能凭"这台有 N 个工具"做任何事（能调哪些在它自己的
+//     schema 里），而 17 B/台 × 每轮的开销是白付的。
+//   - 无备注 → 只有名字（①档）或名字 + 状态（②档）。
 //   - 不写「已启用」字样：能进段的都是可用的，标状态是废话；②档则必须标，否则就是谎报。
 //   - 两档都空 → 返回 `''`（renderPrompt 删空段，零 token 成本）。
 //
@@ -108,11 +107,14 @@ export function renderMcpStateSection(rows, opts = {}) {
     const shownOffline = [...offline].sort(byName).slice(0, cap);
     const lineOf = (r, count, isOffline) => {
         const name = String(r.serverName ?? r.id);
-        // ②档必须把状态写出来：不写就等于谎报"可用"。「上次连上时」四个字不能省 ——
-        // 那个数字是历史事实，写成"（N 个工具）"会被读成现状。
-        const head = isOffline
-            ? '- **' + name + '**（当前未连上；上次连上时 ' + count + ' 个工具）'
-            : '- **' + name + '**（' + count + ' 个工具）';
+        // ②档必须把状态写出来：不写就等于谎报"可用"。
+        //
+        // 2026-09-23：两档的**工具数都去掉了**（用户看到实际注入后要求精简）。数字对模型没有
+        // 动作价值 —— 它不能凭"这台有 8 个工具"列举出工具名（真正能调的都在它自己的工具
+        // schema 里，按 `mcp__<server>__` 前缀就能对上号），而每轮都要付 17 B/台。
+        // 顺带消掉一处隐患：②档原来写「上次连上时 N 个工具」，那个数字是**历史事实**，措辞上
+        // 必须和现状区分开；数字没了，这个歧义也就不存在了。
+        const head = isOffline ? '- **' + name + '**（当前未连上）' : '- **' + name + '**';
         const note = normalizeMcpNote(r.notes, noteMaxLength);
         return note ? head + ' — ' + MCP_NOTE_PREFIX + note : head;
     };
@@ -120,7 +122,7 @@ export function renderMcpStateSection(rows, opts = {}) {
         ...shownUsable.map((r) => lineOf(r, liveEnabledOf(r), false)),
         ...shownOffline.map((r) => lineOf(r, knownOf(r), true)),
     ];
-    // 只有清单：标题（`## 本机 MCP 服务器的当前状态`）与"该拿它做什么"由注入通道的框架承担
+    // 只有清单：标题（`# 本机 MCP 服务器的当前状态`）由注入通道的框架承担
     // （2026-09-18 起，见 context-inject.ts 的 DOMAIN_FRAME）—— 同一件事只有一个出处，
     // 框架已经写了标题，正文再写一遍就是每步多付一行 token。
     const out = [...lines];

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）──────────────────────────────────────────────────────────