dsh-plugin-tool-management 0.14.0 → 0.16.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) },
             });
         }
     }
@@ -1487,12 +1493,118 @@ export function createMcpManager(deps) {
         if (!id || (level !== 'global' && level !== 'project'))
             return { ok: false, error: '缺少 id 或 level' };
         const abs = level === 'global' ? p.globalPatch : p.projectPatch;
-        return withWriteLock(async () => {
+        const removedScenes = [];
+        const skippedLockedScenes = [];
+        await withWriteLock(async () => {
+            // serverName 在锁内取：场景档案（mcp / mcpNotes）与两张工具侧车表都按它键，
+            // 补丁条目 id 是另一套；锁外读会和并发写竞态。
+            const known = (await collectAll()).rows.find((r) => r.id === id);
+            const serverName = known ? known.serverName : '';
             let c = await readPatch(abs);
             c = removeEntryAll(c, id);
             await writePatch(abs, c);
-            return { ok: true };
+            // ── 同步清引用（best-effort，口径与 mcpm-edit 的改名同步一致）─────────────
+            // 只删补丁行的话，引用它的档案/侧车全是死键：场景页会显示一台不存在的服务器，
+            // 进/退场景还会去切换一个空条目；界面上则短暂残留宿主 loader 的 include:* 行。
+            if (serverName) {
+                try {
+                    const slice = await memoriesService.readArchiveSlice();
+                    let mode = slice.mode;
+                    // 运行时快照的 mcp 同样按 serverName 键：进场景时引擎按它关停/恢复，
+                    // 死键会在退场景回写时被无害地跳过 —— 但删了就该摘，与改名的 F-025 同口径。
+                    const snapMcp = mode && mode.snapshot && mode.snapshot.mcp;
+                    if (snapMcp && Object.prototype.hasOwnProperty.call(snapMcp, serverName)) {
+                        const rest = Object.assign({}, snapMcp);
+                        delete rest[serverName];
+                        mode = Object.assign({}, mode, { snapshot: Object.assign({}, mode.snapshot, { mcp: rest }) });
+                    }
+                    // 场景档案：被**锁定**的场景档案是用户显式冻结的，跳过并如实上报，
+                    // 不绕开门禁偷偷写；解锁后重新保存一次档案即可清掉死键。
+                    let locks = {};
+                    try {
+                        if (typeof memoriesService.sceneLocks === 'function')
+                            locks = (await memoriesService.sceneLocks()) || {};
+                    }
+                    catch { /* 锁态读不到时按未锁处理，与修复前的行为一致 */ }
+                    const archives = {};
+                    let archivesTouched = false;
+                    for (const [name, archive] of Object.entries(slice.archives || {})) {
+                        const a = archive || {};
+                        const hasMcp = !!(a.mcp && Object.prototype.hasOwnProperty.call(a.mcp, serverName));
+                        const hasNote = !!(a.mcpNotes && Object.prototype.hasOwnProperty.call(a.mcpNotes, serverName));
+                        if (!hasMcp && !hasNote) {
+                            archives[name] = archive;
+                            continue;
+                        }
+                        if (locks[name] === true) {
+                            skippedLockedScenes.push(name);
+                            archives[name] = archive;
+                            continue;
+                        }
+                        const copy = Object.assign({}, a);
+                        if (hasMcp) {
+                            const rest = Object.assign({}, a.mcp);
+                            delete rest[serverName];
+                            copy.mcp = rest;
+                        }
+                        if (hasNote) {
+                            const rest = Object.assign({}, a.mcpNotes);
+                            delete rest[serverName];
+                            // mcpNotes 全空 → null：与档案保存（"全空 = 未定义"）同一口径。
+                            copy.mcpNotes = Object.keys(rest).length ? rest : null;
+                        }
+                        archives[name] = copy;
+                        archivesTouched = true;
+                        removedScenes.push(name);
+                    }
+                    if (archivesTouched || mode !== slice.mode) {
+                        const patch = {};
+                        if (archivesTouched)
+                            patch.archives = archives;
+                        if (mode !== slice.mode)
+                            patch.mode = mode;
+                        await memoriesService.patchIndex(patch);
+                    }
+                }
+                catch { /* 清理失败不拦删除本身；死键无行为影响，与修复前一致 */ }
+                try {
+                    // 停用表与「已知工具」也按 serverName 键：整台没了，键留着只会喂出错的口径
+                    // （补集里多出一台永远凑不上的服务器的旧工具名）。
+                    const toolMap = Object.assign({}, await readDisabledTools(true));
+                    if (Object.prototype.hasOwnProperty.call(toolMap, serverName)) {
+                        delete toolMap[serverName];
+                        await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), toolMap);
+                        disabledToolsCache = { at: Date.now(), value: toolMap };
+                        await applyToolRestrictions();
+                    }
+                    const knownMap = Object.assign({}, await readKnownMcpTools(true));
+                    if (Object.prototype.hasOwnProperty.call(knownMap, serverName)) {
+                        delete knownMap[serverName];
+                        await writeKnownMcpTools(knownMap);
+                    }
+                }
+                catch { /* non-fatal */ }
+                try {
+                    // 备注按 loader id 键：条目删了备注就该走（writeNoteUnderLock 约定在写锁内调用）。
+                    await writeNoteUnderLock(id, '');
+                }
+                catch { /* non-fatal */ }
+            }
         });
+        // 等 loader 把条目摘掉。等待放在**写锁外**（同 mcpm-restart：锁内等待会卡住其他写）。
+        // 宿主清单偶尔停在上一帧，等不到**不算失败** —— 补丁条目确实已经删了，宿主侧收敛有
+        // 自己的节奏；但要说出来，否则用户对着残留的 include:* 行只会以为插件没删干净。
+        const warnings = [];
+        if (pluginInventory) {
+            const gone = await waitFor(async () => (await liveEntry(id)) === null, LOADER_STATE_WAIT_MS, LOADER_STATE_POLL_MS);
+            if (!gone)
+                warnings.push(`宿主 loader 清单未在 ${LOADER_STATE_WAIT_MS / 1000} 秒内摘除该条目，列表可能短暂残留它的行（宿主收敛后自动消失）`);
+        }
+        if (removedScenes.length)
+            warnings.push(`已同步摘掉 ${removedScenes.length} 个场景档案里对它的引用（${removedScenes.join('、')}）`);
+        if (skippedLockedScenes.length)
+            warnings.push(`场景 ${skippedLockedScenes.join('、')} 已锁定，档案里对它的引用保留未动（解锁后重新保存档案即可清掉）`);
+        return warnings.length ? { ok: true, warning: warnings.join('；') } : { ok: true };
     }
     /**
      * 收敛补丁文件里的启停覆盖块（用户显式点「整理补丁」才走这里）。
@@ -1543,6 +1655,189 @@ export function createMcpManager(deps) {
             return { ok: true, removed: total, ids: removed, files };
         });
     }
+    // ---------- 配置体检（0.15.0 B1；0.16.1 起 streamable-http 含端点探测）--------------
+    // 对补丁文件**只读**：不写盘、不拉起子进程。对外调用两处 ——
+    //   · `where` / `which` 查 PATH：只查「这个命令名能不能找到」，绝不执行配置里的命令本身；
+    //   · streamable-http 行对配置地址发一次 GET 连通性探测（带配置的鉴权头、5 秒超时、
+    //     不读响应体 —— 与宿主连接该服务走的是同一地址同一头部，只是更轻）。
+    //
+    // 为什么单独读补丁而不复用 `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');
+            });
+        });
+    }
+    /** streamable-http 连通性探测的超时：再长，「全部检查」就会被一台挂掉的服务拖住。 */
+    const INSPECT_PROBE_TIMEOUT_MS = 5000;
+    /** 探测失败的原因短语（进词典模板的 {reason}）：认得出常见错误码就说人话，认不出给原文截断。 */
+    function describeProbeFailure(e) {
+        const err = e;
+        if (err && (err.name === 'TimeoutError' || err.name === 'AbortError')) {
+            return '探测超时（' + Math.round(INSPECT_PROBE_TIMEOUT_MS / 1000) + ' 秒无响应）';
+        }
+        const code = err && err.cause && err.cause.code;
+        if (code === 'ENOTFOUND' || code === 'EAI_AGAIN')
+            return '域名解析失败（' + code + '）';
+        if (code === 'ECONNREFUSED')
+            return '连接被拒绝（' + code + '）';
+        if (code === 'ETIMEDOUT')
+            return '连接超时（' + code + '）';
+        if (code === 'ECONNRESET')
+            return '连接被重置（' + code + '）';
+        if (typeof code === 'string' && /CERT|SSL|TLS/.test(code))
+            return 'TLS 证书校验失败（' + code + '）';
+        const text = String((err && err.cause && err.cause.message) || (err && err.message) || e || '');
+        return text.length > 80 ? text.slice(0, 77) + '…' : text;
+    }
+    /**
+     * streamable-http 的连通性探测：对配置地址 GET 一次，**任何** HTTP 响应（含 404/405）
+     * 都算「可达」—— 探测只回答"这个地址现在连不连得上"，不校验它是不是 MCP 服务。
+     * 不读响应体：streamable-http 对 GET 常回一条 SSE 长连接，拿到状态行就取消。
+     */
+    async function probeHttpEndpoint(url, headers) {
+        const extra = {};
+        if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
+            for (const [k, v] of Object.entries(headers)) {
+                if (typeof v === 'string' && v)
+                    extra[k] = v;
+            }
+        }
+        try {
+            const res = await fetch(url, { method: 'GET', headers: extra, redirect: 'follow', signal: AbortSignal.timeout(INSPECT_PROBE_TIMEOUT_MS) });
+            try {
+                await res.body?.cancel();
+            }
+            catch { /* 取消失败不影响「可达」结论 */ }
+            return { reachable: true };
+        }
+        catch (e) {
+            return { reachable: false, reason: describeProbeFailure(e) };
+        }
+    }
+    /** 一行配置 → 检查项。`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 } });
+            else {
+                // 格式对了再做一次真实探测（0.16.1）：此前的体检止步于格式校验，一条编造的
+                // 地址也能拿绿点 —— 绿点承诺的「没发现问题」其实只覆盖了一半（2026-09-29 实测）。
+                const probe = await probeHttpEndpoint(url, row.headers);
+                if (!probe.reachable)
+                    checks.push({ id: 'httpUnreachable', level: 'warn', params: { url, reason: probe.reason } });
+            }
+            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) : '';
+        // 逐行检查并行跑：体检含 streamable-http 的端点探测（每次至多 5 秒超时），串行会让
+        // 「全部检查」在多台同时连不上时按行数翻倍地慢。Promise.all 保序，与旧实现一致。
+        const targets = rows.filter((r) => (!onlyId || String(r.id) === onlyId) && (!onlyLevel || String(r.level) === onlyLevel));
+        const results = await Promise.all(targets.map(async (r) => ({
+            id: r.id,
+            serverName: r.serverName,
+            level: r.level,
+            transport: r.transport || null,
+            checks: await inspectChecks(r, (idsByName[String(r.serverName || '')] || new Set()).size),
+        })));
+        return { ok: true, results, errors };
+    }
     async function mcpmExport() {
         const p = await ensurePaths();
         const list = await mcpmList();
@@ -1789,6 +2084,7 @@ export function createMcpManager(deps) {
             'mcpm-compact': mcpmCompact,
             'mcpm-export': mcpmExport,
             'mcpm-import': mcpmImport,
+            'mcpm-inspect': mcpmInspect,
         },
         readDisabledTools,
         readKnownMcpTools,
@@ -1799,13 +2095,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/memories/service.js

@@ -696,6 +696,15 @@ export function createMemoriesService(ctx, deps) {
         refresh,
         patchIndex,
         readArchiveSlice,
+        sceneLocks: async () => {
+            const index = await readIndex(stateDir);
+            const out = {};
+            for (const [name, rec] of Object.entries(index.scenes || {})) {
+                if (rec && rec.locked === true)
+                    out[name] = true;
+            }
+            return out;
+        },
     };
     return service;
 }

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 },
     // 模型工具表（哪些工具根本不发给模型）也写侧车，改的是每轮请求的内容 —— 同上按写门禁。