dsh-plugin-tool-management 0.16.6 → 0.18.0

package/lib/mcp/manager.js

@@ -18,15 +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 { MCP_CLIENT_MODULE, MCP_TOOL_PREFIX, ambiguousServerNames, looksLikeMcpPrefixDrift, serverNameCandidates, splitMcpToolName } from '../host-names.js';
 import { hubPath } from '../hub.js';
 import { planOverrideCompaction } from './override-blocks.js';
+// 配置体检的探测（PATH 查询 / 端点连通性 / 检查清单 + mcpm-inspect op），2026-10-01 剥出。
+import { createInspectProbe } from './inspect-probe.js';
 import { createMcpStateCatalog } from './state-section.js';
-import { appendBlock, buildDisableBlock, buildInsertBlock, parseRows, removeEntryAll, removeMarked, spliceRanges, splitLines, } from './patch-yaml.js';
-import { describeMaskedOutcome, maskUrlQuery, maskedKeysIn, resolveMaskedKv, resolveMaskedUrl } from './secret-guard.js';
+import { createToolVisibility } from './tool-visibility.js';
+import { appendBlock, buildDisableBlock, buildInsertBlock, insertEntryIds, parseRows, removeEntryAll, removeMarked, spliceRanges, splitLines, } from './patch-yaml.js';
+import { describeMaskedOutcome, maskSecretValue, maskUrlQuery, maskedKeysIn, resolveMaskedKv, resolveMaskedUrl } from './secret-guard.js';
 /**
  * 归一化「已知工具」侧车的一行值。
  *
@@ -71,6 +71,41 @@ export function countEnabledTools(known, disabled) {
             n++;
     return n;
 }
+/**
+ * 单工具停用判定（含整服务器通配 `*`——场景档案的"MCP 工具集=整台"写的就是它）。
+ *
+ * 切分走 `splitMcpToolName`（`host-names.ts`）—— **全插件唯一的一套切分规则**（2026-09-30 审查 N1）。
+ *
+ * 改之前的两代口径（免得下次又退回老路）：
+ *   * 0.16.6 及以前用 `indexOf('__')`（取**第一个**）：serverName 含 `__` 时被截成 `a` → 查表
+ *     未命中 → **返回 false（不拦）** → 被停用的工具仍可调用。这是**执行侧**守卫失效，不只是
+ *     显示问题：调用链是 `tools.guard`（`index.ts`）→ `mcp.isToolDisabled`（本文件的出口，
+ *     喂的就是本函数），而文件头承诺 disabled = invisible AND uncallable。
+ *   * 0.16.7 改成「最长已知 serverName 前缀匹配」（候选 = 停用表的键），守卫这一侧修对了；但
+ *     显示侧（`index.ts` 的 `toolKeyParts`）当时改成了「取最后一个 `__`」——**两套规则并存**，
+ *     于是「工具名含 `__`」时守卫与界面键仍会给出不同的 `(server, tool)`。
+ *   * 现在两侧共用 `splitMcpToolName`（最长候选命中，一个都不命中才退回最后一个 `__`）。
+ *
+ * 候选集合取**停用表的键**，不是「全部已配置服务器」—— 理由见 `splitMcpToolName` 的文档：
+ * 设 `a` 的 `b__c` 被停用、而 `a__b` 只是配置了、没停用任何工具，全名 `mcp__a__b__c` 在放宽后
+ * 最长匹配取 `a__b`（tool 只剩 `c`）→ 查 `a__b` 未命中 → **放行一个真的被停用的工具**
+ * （fail-open）。候选只有 `{a}` 时切出 `a`/`b__c` → 命中 → 拦住。
+ * 歧义时偏向「停用表里有的那个服务器」才是守卫该有的方向。
+ *
+ * 本函数是**纯函数**（不读闭包状态），因此提到模块作用域并导出：既是"两侧同源"的可测接缝，
+ * 也让 `createMcpManager` 不再需要为它保留一个闭包内定义。
+ */
+export function isToolDisabledIn(map, fullName) {
+    const parts = splitMcpToolName(fullName, Object.keys(map));
+    if (parts === null)
+        return false;
+    const list = map[parts.server];
+    if (!list)
+        return false;
+    if (list.indexOf('*') >= 0)
+        return true;
+    return list.indexOf(parts.tool) >= 0;
+}
 export function createMcpManager(deps) {
     // 外部能力一次解构成局部名：块内代码是逐字搬来的，保持原样最不容易出错。
     const { readJsonFile, writeJsonFile, ensurePaths, withWriteLock, message, tools, pluginInventory, settings, readPatch, writePatch, memoriesService, wait, } = deps;
@@ -83,11 +118,13 @@ export function createMcpManager(deps) {
     // are reported on read and new ones are refused before any write.
     function duplicateIdsOf(content) {
         const counts = new Map();
-        for (const row of parseRows(content).rows) {
-            if (!row.id)
-                continue;
-            counts.set(row.id, (counts.get(row.id) || 0) + 1);
-        }
+        // 扫**全部** insert 子条目的 id，不只 MCP 行（2026-09-30 审查 P1-5）。原实现走
+        // `parseRows`，而它只收 `name === MCP_CLIENT_MODULE` 的行 —— 于是导入一条非 MCP 的
+        // loader（例如 `{"id":"dsh-plugin-tool-management", ...}`）能撞出第二条同 id 条目，
+        // 守卫看不见、直接 `appendBlock` 落盘。而按本仓一贯记载（`:229-231`），同 id 的两条
+        // insert 会让插件组装失败、**DSH 下次起不来**。这个约束对任何 loader 都成立。
+        for (const id of insertEntryIds(content))
+            counts.set(id, (counts.get(id) || 0) + 1);
         return [...counts.entries()].filter(([, n]) => n > 1).map(([id]) => id);
     }
     function duplicateGuard(before, after) {
@@ -117,7 +154,11 @@ export function createMcpManager(deps) {
                 ids.add(r.id);
                 const sn = r.config && r.config.serverName ? String(r.config.serverName) : r.id;
                 serverNames.add(sn);
-                rows.push({ id: r.id, serverName: sn, level, disabled: !!r.disabled });
+                // `config` 一并带出（2026-09-30 审查 F4）：`mcpm-import` 的覆盖模式要靠它拿**旧真值**
+                // 顶替表单里的打码值（URL 的 userinfo/查询串/片段、env/headers 的整串 `•`）。
+                // 此前这里只带 id/serverName/level/disabled，于是 `prevRow.url` 恒为 `undefined` ——
+                // 覆盖模式也走"没有原值"分支，把打码值丢弃并报一句"没有原值可保留"（诊断也是错的）。
+                rows.push({ id: r.id, serverName: sn, level, disabled: !!r.disabled, config: (r.config || {}) });
             }
         }
         return { ids, serverNames, rows };
@@ -342,294 +383,18 @@ export function createMcpManager(deps) {
             return { ok: true, settings: next };
         });
     }
-    // ---------- per-tool enable/disable (execution + visibility boundary) ----------
-    // dsh-mcp-client has no per-tool config, but the DSH tool runtime exposes
-    // two official seams: `tools.restrict({ deny })` removes a global tool from
-    // every scope's model-visible schema list, and `tools.guard` denies the call
-    // before the body runs. Disabled tools therefore become invisible AND
-    // uncallable — no patch rewrite, no DSH restart.
-    let disabledToolsCache = null;
-    async function readDisabledTools(force = false) {
-        if (disabledToolsCache && !force && Date.now() - disabledToolsCache.at < SIDECAR_TTL_MS)
-            return disabledToolsCache.value;
-        const p = await ensurePaths();
-        const raw = await readJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE));
-        const out = {};
-        if (raw && typeof raw === 'object') {
-            for (const serverName of Object.keys(raw)) {
-                const list = raw[serverName];
-                if (Array.isArray(list)) {
-                    // `*` 必须原样保留：它是「整台服务器停用」的通配（场景档案未勾选的服务器写的就是它），
-                    // 被这里过滤掉的话 guard / restrict / 快照三条链路一起失效——整台停用变成空转。
-                    const names = list.map((name) => String(name)).filter((name) => name === '*' || /^[A-Za-z0-9_-]{1,128}$/.test(name));
-                    if (names.length)
-                        out[serverName] = names;
-                }
-            }
-        }
-        disabledToolsCache = { at: Date.now(), value: out };
-        return out;
-    }
-    /** Fully-qualified model-facing names (`mcp__<serverName>__<tool>`) of every disabled tool. */
-    function disabledToolNames(map) {
-        const out = [];
-        for (const serverName of Object.keys(map)) {
-            for (const tool of map[serverName])
-                out.push('mcp__' + serverName + '__' + tool);
-        }
-        return out;
-    }
-    // ---------- 「已知工具」侧车（v0.8.1）-----------------------------------
-    // MCP 工具名只在服务器**运行**时可见（tools.schemas() 里才有）。未运行的服务器在
-    // 场景档案里既显示 0 工具、工具明细也空空如也 —— 用户没法给未运行服务器挑工具。
-    // 每次枚举到 live 工具时按 serverName 记一份「最后见过的工具名」，未运行时用它兜底：
-    // 场景档案能列出/勾选，进入场景后按实际注册的工具生效（restrict 会过滤掉不存在的名字）。
-    let knownMcpToolsCache = null;
-    async function readKnownMcpTools(force = false) {
-        if (knownMcpToolsCache && !force && Date.now() - knownMcpToolsCache.at < SIDECAR_TTL_MS)
-            return knownMcpToolsCache.value;
-        const p = await ensurePaths();
-        const raw = await readJsonFile(mcpSidecar(MCP_KNOWN_TOOLS_FILE));
-        const out = {};
-        if (raw && typeof raw === 'object') {
-            for (const serverName of Object.keys(raw)) {
-                const list = normalizeKnownTools(raw[serverName]);
-                if (list.length)
-                    out[serverName] = list;
-            }
-        }
-        knownMcpToolsCache = { at: Date.now(), value: out };
-        return out;
-    }
-    async function writeKnownMcpTools(value) {
-        const p = await ensurePaths();
-        await writeJsonFile(mcpSidecar(MCP_KNOWN_TOOLS_FILE), value);
-        knownMcpToolsCache = { at: Date.now(), value: value };
-    }
-    /** 单工具停用判定（含整服务器通配 `*`——场景档案的"MCP 工具集=整台"写的就是它）。 */
-    function isToolDisabledIn(map, fullName) {
-        if (!fullName.startsWith('mcp__'))
-            return false;
-        const rest = fullName.slice(5);
-        const i = rest.indexOf('__');
-        if (i <= 0)
-            return false;
-        const list = map[rest.slice(0, i)];
-        if (!list)
-            return false;
-        if (list.indexOf('*') >= 0)
-            return true;
-        return list.indexOf(rest.slice(i + 2)) >= 0;
-    }
-    async function mcpmToolEnabled(args) {
-        const serverName = String((args && args.serverName) || '').trim();
-        const tool = String((args && args.tool) || '').trim();
-        if (!/^[A-Za-z0-9_-]{1,32}$/.test(serverName))
-            return { ok: false, error: 'serverName 不合法' };
-        if (!/^[A-Za-z0-9_-]{1,128}$/.test(tool))
-            return { ok: false, error: 'tool 名称不合法' };
-        const enabled = (args && args.enabled) !== false;
-        const p = await ensurePaths();
-        return withWriteLock(async () => {
-            // Force re-read so an externally edited disabled-tools file is merged, not clobbered.
-            const map = Object.assign({}, await readDisabledTools(true));
-            const disabled = new Set(map[serverName] || []);
-            if (enabled)
-                disabled.delete(tool);
-            else
-                disabled.add(tool);
-            if (disabled.size)
-                map[serverName] = [...disabled].sort();
-            else
-                delete map[serverName];
-            try {
-                await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), map);
-            }
-            catch (e) {
-                return { ok: false, error: '保存失败: ' + message(e) };
-            }
-            disabledToolsCache = { at: Date.now(), value: map };
-            await applyToolRestrictions();
-            return { ok: true, serverName, disabled: map[serverName] || [] };
-        });
-    }
-    // Visibility seam: keep one active restriction per **agent scope**, refreshed whenever
-    // the tool set / the disabled set / this agent's carrier set changes. Three facts decide
-    // this design（都读过官方源码 dsh-tools 0.1.5-rc.2）：
-    //   · `restrict()` **要求 scoped context** —— 插件级 ctx 调用必抛 "requires a scoped
-    //     context"，这正是「停用工具从模型可见 schema 消失」这半边此前从未生效的原因（V1）；
-    //   · 每次 layer 变化（restriction 就是一次 layer effect）官方都会 emit `tools/change`
-    //     （`layers = new ScopedLayers(…, () => this.ctx.emit("tools/change"))`），而重放正挂在
-    //     `tools/change` 上 —— 名单没变还重放就是自激；
-    //   · 表要取自**不受限**的插件级视图：在 agent scope 里取 `schemas()`，第一次限制生效后
-    //     表里就没有被停用的工具了，第二次重放会把它从 deny 名单里筛掉 —— 停用静默复活。
-    // （2026-09-23：名单有三处来源，其中 `carrierHiddenTools` 逐 agent 不同，所以从"一份名单给
-    //  所有 agent"改成逐 agent 各装一层 —— 见下面 restrictAgent / appliedByAgent 的注释。）
-    let restrictTimer = null;
-    /** 已应用名单的键；相同即返回（防自激，也让每次 tools/change 变成一次廉价判等）。 */
-    let appliedNamesKey = null;
-    /** 当前期望的**全局** deny 名单（agent 晚到 / 重放时用它，再叠加该 agent 自己那份）。 */
-    let desiredNames = [];
-    /** agent → 撤掉这层限制的 disposer。 */
-    const agentRestrictions = new Map();
-    /** agent → 已应用的**合并后**名单键（名单现在与 agent 有关，不能再只记一份全局的）。 */
-    const appliedByAgent = new Map();
-    /** 见过的 agent（重放时逐个重新应用；disposed 时移除）。 */
-    const seenAgents = new Set();
-    /**
-     * 重放代数：`carrierHiddenTools` 是异步的，算名单期间可能又来了新的一轮重放（或 agent
-     * 已经下线）。每次重放自增，回来时代数对不上就作废 —— 否则会用旧名单盖掉新的那一层。
-     */
-    let epoch = 0;
-    function scopedToolsOf(agent) {
-        const scoped = agent && agent.ctx && agent.ctx.tools;
-        return scoped && typeof scoped === 'object' ? scoped : undefined;
-    }
-    /** 撤掉某个 agent 上的限制（名单变了要重装：`restrict` 是叠加层，装新的不撤旧的会越叠越多）。 */
-    function liftRestriction(agent) {
-        const release = agentRestrictions.get(agent);
-        agentRestrictions.delete(agent);
-        appliedByAgent.delete(agent);
-        if (release) {
-            try {
-                release();
-            }
-            catch (e) { /* ignore */ }
-        }
-    }
-    /** 把该 agent 该背的名单装到它 scope 上（全局那份 ∪ 它自己那份；空名单 = 不碰它）。 */
-    async function restrictAgent(agent) {
-        const mine = epoch;
-        let extra = [];
-        if (deps.carrierHiddenTools) {
-            // 判据失败一律当"没有额外要藏的"：藏错了模型就少一条路，留着只是多花 token。
-            try {
-                extra = await deps.carrierHiddenTools(agent);
-            }
-            catch (e) {
-                extra = [];
-            }
-        }
-        if (mine !== epoch)
-            return;
-        if (!seenAgents.has(agent))
-            return;
-        const names = [...new Set([...desiredNames, ...extra])];
-        const scoped = scopedToolsOf(agent);
-        if (!scoped || typeof scoped.restrict !== 'function') {
-            if (names.length === 0)
-                return;
-            // agent scope 上没有 tools 面（或它没有 restrict）：这半边做不成，如实说 ——
-            // 静默跳过会让人以为"停用工具从模型工具表里消失"已经生效。
-            noteRuntime({
-                id: 'mcp-tool-visibility',
-                label: '停用工具的可见性',
-                kind: 'write',
-                fallback: 'inform-only',
-                detail: 'agent scope 上没有可用的 tools.restrict（官方接口变了或该 scope 未暴露 tools）：停用的 MCP 工具与兼容页关掉的本插件工具仍会出现在模型可见的工具表里，执行侧拦截仍然生效。',
-                detailKey: 'mcp-tool-visibility.no-restrict',
-            });
-            return;
-        }
-        const key = names.slice().sort().join('\u0000');
-        if (appliedByAgent.get(agent) === key)
-            return;
-        liftRestriction(agent);
-        if (names.length === 0) {
-            clearRuntimeNote('mcp-tool-visibility');
-            return;
-        }
-        try {
-            const dispose = scoped.restrict({ deny: names });
-            agentRestrictions.set(agent, typeof dispose === 'function' ? dispose : () => { });
-            appliedByAgent.set(agent, key);
-            clearRuntimeNote('mcp-tool-visibility');
-        }
-        catch (e) {
-            // 这个名字在这个 scope 里认不出 / scope 已经收了：可见性半边没生效。执行侧的 guard
-            // 仍然拦住调用，所以功能不缺 —— 但必须如实上报，不能假装成功（此前正是静默吞掉）。
-            noteRuntime({
-                id: 'mcp-tool-visibility',
-                label: '停用工具的可见性',
-                kind: 'write',
-                fallback: 'inform-only',
-                detail: '有工具没能从模型可见的工具表里摘掉（' + message(e) + '）：执行侧拦截仍然生效，模型仍能看到该工具的名字。',
-                detailKey: 'mcp-tool-visibility.partial',
-                params: { reason: message(e) },
-            });
-        }
-    }
-    /** agent 上线（`agent/created` 或启动期的 agent 列表）：登记并立刻应用当前名单。 */
-    function attachAgent(agent) {
-        if (!agent || (typeof agent !== 'object' && typeof agent !== 'function'))
-            return;
-        seenAgents.add(agent);
-        void restrictAgent(agent).catch(() => { });
-    }
-    /** agent 下线（`agent/disposed`）：先撤限制再销登记。 */
-    function detachAgent(agent) {
-        seenAgents.delete(agent);
-        liftRestriction(agent);
-    }
-    async function applyToolRestrictions() {
-        if (typeof tools.restrict !== 'function')
-            return;
-        // Force re-read: this runs on the tools/change path, which is rare, so a
-        // stale cache must not keep an externally edited deny list hidden.
-        const map = await readDisabledTools(true);
-        // 通配 `*`（整服务器停用）先展开成已注册的全名，再与精确名单合并。
-        const wanted = disabledToolNames(map);
-        let registered;
-        try {
-            registered = new Set((await tools.schemas()).map((schema) => String(schema.name)));
-        }
-        catch (e) {
-            return;
-        }
-        for (const [serverName, list] of Object.entries(map)) {
-            if (list.indexOf('*') < 0)
-                continue;
-            const prefix = 'mcp__' + serverName + '__';
-            for (const fullName of registered)
-                if (fullName.startsWith(prefix))
-                    wanted.push(fullName);
-        }
-        // 兼容页「模型工具表」关掉的本插件工具并进同一份名单（理由见 deps.pluginHiddenTools）。
-        // 交给上面那个 `registered` 过滤是**必要的**而不是保险：官方对认不出的名字直接抛错，
-        // 而关掉的工具里可能有一个这次根本没注册成功（注册失败会被子智能体页的黄条报出来）。
-        if (deps.pluginHiddenTools) {
-            try {
-                for (const name of deps.pluginHiddenTools())
-                    wanted.push(name);
-            }
-            catch (e) { /* 读设置失败 = 这次不摘它们 */ }
-        }
-        const names = [...new Set(wanted)].filter((name) => registered.has(name));
-        const key = names.join('\u0000');
-        // 有 `carrierHiddenTools` 时不拿全局键短路：那份名单与"官方工具此时挂没挂"有关，
-        // 而它变了不会改全局键（官方挂载/卸载本身就发 tools/change，正是靠这条通路追上）。
-        // 代价是每次 tools/change 都重算一遍 —— 逐 agent 的键判等会把绝大多数挡在装层之前，
-        // 事实读取也有 TTL 缓存；装层本身会再发一次 tools/change，那一轮键相同即收敛，不自激。
-        if (key === appliedNamesKey && deps.carrierHiddenTools === undefined)
-            return;
-        appliedNamesKey = key;
-        desiredNames = names;
-        // 每次重放先撤掉每个 agent 上的旧层：名单变短（重新启用某个工具）时，只有撤掉这层限制
-        // 它才会重新可见；名单变了（含逐 agent 那份）也必须重装而不是叠加。
-        epoch += 1;
-        for (const agent of [...agentRestrictions.keys()])
-            liftRestriction(agent);
-        for (const agent of seenAgents)
-            void restrictAgent(agent).catch(() => { });
-    }
-    function scheduleToolRestrictions() {
-        if (restrictTimer)
-            return;
-        restrictTimer = setTimeout(() => {
-            restrictTimer = null;
-            applyToolRestrictions().catch(() => { });
-        }, 300);
-    }
+    // ---------- per-tool enable/disable + 可见性半边 → ./tool-visibility.ts ----------
+    // 那 294 行整段搬进同目录模块，靠 deps 拿这里的闭包名字（侧车读写、写锁、tools 服务、
+    // 三个侧车常量），所以母文件这一段只剩接线。
+    // 唯一被块外改写的状态是停用表缓存：改名迁移、删台、整表回写三处写它，出口两处同步读它
+    // （isToolDisabled / disabledToolSummary）—— 于是块交回两个句柄，语义与原样一致：
+    // setDisabledToolsCache(x) ≡ `disabledToolsCache = { at: Date.now(), value: x }`，
+    // disabledToolsSnapshot() ≡ `disabledToolsCache ? disabledToolsCache.value : {}`。
+    const { readDisabledTools, readKnownMcpTools, writeKnownMcpTools, mutateKnownMcpTools, mergeLiveToolsInto, mcpmToolEnabled, applyToolRestrictions, scheduleToolRestrictions, attachAgent, detachAgent, setDisabledToolsCache, disabledToolsSnapshot, disposeVisibility, } = createToolVisibility({
+        readJsonFile, writeJsonFile, ensurePaths, withWriteLock, message, tools,
+        pluginHiddenTools: deps.pluginHiddenTools, carrierHiddenTools: deps.carrierHiddenTools,
+        normalizeKnownTools, mcpSidecar, SIDECAR_TTL_MS, MCP_DISABLED_TOOLS_FILE, MCP_KNOWN_TOOLS_FILE,
+    });
     function truncateText(value, limit) {
         if (!limit || value.length <= limit)
             return value;
@@ -640,16 +405,9 @@ export function createMcpManager(deps) {
     // indirections rather than secrets, so they stay readable. URL query strings
     // are redacted because MCP credentials often ride there.
     const SENSITIVE_KEY_RE = /(token|secret|password|passwd|auth|credential|api[_-]?key|access[_-]?key|private[_-]?key|cookie|session|signature|bearer)/i;
-    function maskSecretValue(value) {
-        const text = String(value == null ? '' : value);
-        if (text === '')
-            return '';
-        if (text.startsWith('$'))
-            return text;
-        if (/^!!js\s/.test(text))
-            return text;
-        return '••••••';
-    }
+    // 单值打码（`maskSecretValue`）与 URL 打码（`maskUrlQuery`）都挪到 ./secret-guard.js ——
+    // 那里是这两条形态的唯一口径，使用方现在有三个（本文件的列表视图 + index.ts 的确认卡
+    // + ops/snapshot.ts 的整机迁移导出）。此处不再自建一份。
     function maskValueMap(map, onlySensitiveKeys) {
         if (!map || typeof map !== 'object')
             return map;
@@ -660,7 +418,7 @@ export function createMcpManager(deps) {
         return out;
     }
     // `maskUrlQuery` 已挪到 ./secret-guard.js：那里是两条打码形态的唯一口径，而使用方
-    // 现在有两个（本文件的列表视图 + index.ts 的确认卡）。
+    // 现在有三个（本文件的列表视图 + index.ts 的确认卡 + ops/snapshot.ts 的整机迁移导出）。
     /** Shared UI rows: mcpmList plus notes, secrets masked unless `reveal`. */
     async function mcpmRowsWithNotes(reveal) {
         const result = await mcpmList();
@@ -701,7 +459,7 @@ export function createMcpManager(deps) {
         const serverName = String(args && args.serverName || '').trim();
         if (!serverName)
             return { ok: false, error: 'serverName 不能为空' };
-        const prefix = 'mcp__' + serverName + '__';
+        const prefix = MCP_TOOL_PREFIX + serverName + '__';
         let schemas = [];
         try {
             schemas = await tools.schemas();
@@ -837,14 +595,17 @@ export function createMcpManager(deps) {
                             .map((x) => ({ name: String(x.name), ...(typeof x.description === 'string' && x.description ? { description: x.description } : {}) }));
                         if (known.length) {
                             try {
-                                const cache = await readKnownMcpTools();
-                                const byName = new Map((cache[serverName] || []).map((item) => [item.name, item]));
-                                for (const item of known) {
-                                    const old = byName.get(item.name);
-                                    byName.set(item.name, old && old.description && !item.description ? old : { ...old, ...item });
-                                }
-                                cache[serverName] = [...byName.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-                                await writeKnownMcpTools(cache);
+                                // 读-改-写整段在写锁内（审查 P2-15）：轮询路径也在回写同一份侧车，
+                                // 锁外两步会互相覆盖。合并规则（保留旧的描述、新的描述优先）与轮询路径同源。
+                                await mutateKnownMcpTools((cache) => {
+                                    const byName = new Map((cache[serverName] || []).map((item) => [item.name, item]));
+                                    for (const item of known) {
+                                        const old = byName.get(item.name);
+                                        byName.set(item.name, old && old.description && !item.description ? old : { ...old, ...item });
+                                    }
+                                    cache[serverName] = [...byName.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+                                    return true;
+                                });
                             }
                             catch { /* 缓存写失败不影响本次返回 */ }
                         }
@@ -879,6 +640,34 @@ export function createMcpManager(deps) {
         }
         return result;
     }
+    /**
+     * 已配置的 serverName 名单 —— 只读补丁 + `parseRows`，**不枚举工具 schema、不回写任何缓存**。
+     *
+     * 与 `configuredServers`（index.ts 的档案引擎依赖）取的是同一份东西，但那个走
+     * `mcpmListView()` → `mcpmList()`，会顺带枚举 schema 并回写「已知工具」缓存；切分的候选集合
+     * 只需要名字，不该付那份代价与副作用。顺序与 `mcpmList` 一致（project → global）。
+     */
+    async function configuredServerNames() {
+        const p = await ensurePaths();
+        const out = [];
+        for (const level of ['project', 'global']) {
+            const abs = level === 'project' ? p.projectPatch : p.globalPatch;
+            let content = '';
+            // 读不到某个层级就当它没有条目（与 `mcpmList` 的处理一致：记进 errors 但不影响另一层）。
+            try {
+                content = await readPatch(abs);
+            }
+            catch (e) {
+                continue;
+            }
+            for (const r of parseRows(content).rows) {
+                const n = String(normalizeRow(r, level, abs).serverName || '');
+                if (n && out.indexOf(n) < 0)
+                    out.push(n);
+            }
+        }
+        return out;
+    }
     async function mcpmList() {
         const p = await ensurePaths();
         const rows = [];
@@ -924,22 +713,99 @@ export function createMcpManager(deps) {
             const liveNames = {};
             const liveTools = {};
             const seen = new Set();
+            // 切分走 `splitMcpToolName` —— 与执行侧守卫、界面勾选键**同一套规则**（2026-09-30 审查 N1）。
+            //
+            // 这里以前是贪婪正则 `^mcp__([A-Za-z0-9_-]+)__(.+)$`（等价于"取最后一个 `__`"）。它不只是
+            // 第三套规则：它算出的键就是 `mcp-known-tools.json` 的键，而那个缓存又会被显示侧当候选集合
+            // 读回去 —— 规则不一致会**自证**（切错的键进候选，越切越错），所以必须一起换掉。
+            //
+            // 候选集合取补丁里的真实 serverName ∪ 停用表键 ∪ 已知缓存键：`rows` 来自补丁，是唯一与切分
+            // 结果无关的来源；另两份是插件自己写出来的（见 `configuredServerNames` 的文档）。
+            const splitCandidates = serverNameCandidates(rows.map((r) => String((r && r.serverName) || '')).filter(Boolean), disabledMap, knownCache);
+            // 前缀漂移的线索（审查 §5 F6）：判据与理由见 `host-names.ts` 的
+            // `looksLikeMcpPrefixDrift` —— 关键是**排除 `mcp_` 开头的那一族**（本插件自己的
+            // `mcp_manager_*` 就在里面，不排除的话这条上报每台机器都会误报）。
+            const mcpStemOther = [];
             for (const s of schemas) {
                 const fullName = String(s && s.name || '');
                 if (seen.has(fullName))
                     continue;
                 seen.add(fullName);
-                const m = fullName.match(/^mcp__([A-Za-z0-9_-]+)__(.+)$/);
-                if (!m)
+                if (looksLikeMcpPrefixDrift(fullName) && mcpStemOther.length < 3)
+                    mcpStemOther.push(fullName);
+                const parts = splitMcpToolName(fullName, splitCandidates);
+                // serverName 的合法形态与 `mcpm-set-tool-enabled` / `mcpm-edit` 的校验同口径：不合法的一律
+                // 不进表（旧正则的 `[A-Za-z0-9_-]+` 就是这个意思，这里保留，免得凭空多出服务器行）。
+                if (!parts || !/^[A-Za-z0-9_-]{1,32}$/.test(parts.server))
                     continue;
-                const list = liveNames[m[1]] || (liveNames[m[1]] = []);
-                if (list.indexOf(m[2]) < 0)
-                    list.push(m[2]);
+                const list = liveNames[parts.server] || (liveNames[parts.server] = []);
+                if (list.indexOf(parts.tool) < 0)
+                    list.push(parts.tool);
                 // 顺手把描述记下来：未运行时详情页就有东西可显示，不必再重复「描述暂不可用」。
-                const bucket = liveTools[m[1]] || (liveTools[m[1]] = []);
+                const bucket = liveTools[parts.server] || (liveTools[parts.server] = []);
                 const desc = typeof s.description === 'string' ? s.description : '';
-                if (!bucket.some((t) => t.name === m[2]))
-                    bucket.push({ name: m[2], ...(desc ? { description: desc } : {}) });
+                if (!bucket.some((t) => t.name === parts.tool))
+                    bucket.push({ name: parts.tool, ...(desc ? { description: desc } : {}) });
+            }
+            // 前缀契约的 inform-only 上报（审查 §5 F6）：宿主面上出现了词根后换了分隔符的 `mcp*` 工具名，
+            // 同时按本插件认的前缀一条都筛不出来 —— 大概率官方改了 MCP 工具的命名前缀。这时停用表 /
+            // 执行侧门禁 / 工具计数会**一起静默失明**（守卫认为"这工具不在我的表里"，于是放行），
+            // 而这是纯字符串契约、没有能力探测能提前发现。
+            // 证据门槛刻意收紧（见上）：`mcp_` 开头的一族不算证据，且要**至少两个**同名根的工具
+            // （改前缀会重命名全部 MCP 工具，孤零零一个像模像样的名字不足为凭）。条件不成立就清掉，
+            // 避免陈旧告警。
+            if (mcpStemOther.length >= 2 && Object.keys(liveNames).length === 0) {
+                noteRuntime({
+                    id: 'mcp-tool-prefix',
+                    label: 'MCP 工具命名前缀',
+                    kind: 'read',
+                    fallback: 'inform-only',
+                    detail: `宿主工具表里有多个以 mcp 开头、但用的不是 \`${MCP_TOOL_PREFIX}\` 的工具名（如 ${mcpStemOther.join('、')}），而按本插件认的前缀一条都筛不出来：官方可能改了 MCP 工具的命名前缀。此时停用表、执行侧门禁与工具计数都会失明（守卫会放行它以为"不在表里"的工具）。`,
+                    detailKey: 'mcp-tool-prefix.mismatch',
+                    params: { prefix: MCP_TOOL_PREFIX, samples: mcpStemOther.join('、') },
+                });
+            }
+            else {
+                clearRuntimeNote('mcp-tool-prefix');
+            }
+            // 命名歧义的 inform-only 上报（2026-09-30 审查 N2）：`mcp__<server>__<tool>` 这个契约
+            // 对 `__` 本身有歧义，而 `serverName` 的校验（`/^[A-Za-z0-9_-]{1,32}$/`）**允许含 `__`**。
+            // 两种形状会让切分变成"猜"：① 某个 serverName 自己含 `__`；② 两个 serverName 互为 `__`
+            // 前缀（`a` 与 `a__b`）—— 全名 `mcp__a__b__c` 两种归属都讲得通。
+            //
+            // **只上报、不改行为**：改校验会把存量服务器从"能管"变成"管不了"（计划 §4 未决 1 的
+            // 裁定），而这里要的只是"切不准时出声"。判据本身保证没有这两种形状时一条都不报
+            // （`ambiguousServerNames`），条件不成立就清掉，避免陈旧告警 —— 与上面那条同一条纪律。
+            // 两条互斥、取**更具体**的那条，永远只出一行：
+            // 「互为前缀」必然蕴含「含 `__`」（长的那半就是 `短名 + '__' + 余下`），两条一起报
+            // 就是同一件事说两遍。而「互为前缀」更具体 —— 它直接点名了是哪两个名字撞在一起。
+            // 反过来「含 `__`」能覆盖"一个前缀对都凑不成"的单名字情形。两边都不成立就都清掉。
+            const ambiguous = ambiguousServerNames(splitCandidates);
+            const prefixPairs = ambiguous.prefixPairs.map(([a, b]) => `${a} / ${b}`).join('、');
+            if (ambiguous.prefixPairs.length) {
+                noteRuntime({
+                    id: 'mcp-server-name-ambiguous',
+                    label: 'MCP 服务器名互为 `__` 前缀',
+                    kind: 'read',
+                    fallback: 'inform-only',
+                    detail: `这些 MCP 服务器名互为 \`__\` 前缀关系（${prefixPairs}）：例如 \`mcp__a__b__c\` 既可以读成 \`a\` 的 \`b__c\`，也可以读成 \`a__b\` 的 \`c\`，界面上的勾选可能落不到停用表里那条键上（工具本身照常可用）。改名可消除；不改也能用。`,
+                    detailKey: 'mcp-server-name-ambiguous.prefix',
+                    params: { pairs: prefixPairs },
+                });
+            }
+            else if (ambiguous.withSeparator.length) {
+                noteRuntime({
+                    id: 'mcp-server-name-ambiguous',
+                    label: 'MCP 服务器名含 `__`',
+                    kind: 'read',
+                    fallback: 'inform-only',
+                    detail: `这些 MCP 服务器名里含 \`__\`（${ambiguous.withSeparator.join('、')}）：工具全名 \`mcp__<server>__<tool>\` 因此切不唯一，界面上的勾选可能落不到停用表里那条键上（工具本身照常可用）。改名可消除；不改也能用。`,
+                    detailKey: 'mcp-server-name-ambiguous.separator',
+                    params: { names: ambiguous.withSeparator.join('、') },
+                });
+            }
+            else {
+                clearRuntimeNote('mcp-server-name-ambiguous');
             }
             // 工具数 = live ∪ 停用表里的单个工具名 ∪ 「已知工具」缓存 —— 未运行的服务器
             // 也能显示最后一次见过的工具数，而不是永远 0。
@@ -980,29 +846,11 @@ export function createMcpManager(deps) {
                 knownToolCounts[server] = list.length;
             // 回写「已知工具」：live 见到的名字与描述并入缓存（有变化才写盘，读路径上的 best-effort）。
             // 名字集合变化，或某个已知工具这次拿到了描述而缓存里没有 → 都算变化。
-            let cacheChanged = false;
-            for (const [server, list] of Object.entries(liveTools)) {
-                const prev = knownCache[server] || [];
-                const byName = new Map(prev.map((t) => [t.name, t]));
-                for (const tool of list) {
-                    const old = byName.get(tool.name);
-                    if (!old) {
-                        byName.set(tool.name, tool);
-                        cacheChanged = true;
-                        continue;
-                    }
-                    if (tool.description && old.description !== tool.description) {
-                        byName.set(tool.name, { ...old, description: tool.description });
-                        cacheChanged = true;
-                    }
-                }
-                const next = [...byName.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-                if (next.length !== prev.length)
-                    cacheChanged = true;
-                knownCache[server] = next;
-            }
+            // 先在本地这份上跑一遍只为**判断要不要写盘**；真正落盘的那次合并发生在锁内、对象是
+            // 刚读出来的新鲜表（审查 P2-15：临时启动路径也在写同一份侧车，锁外两步会互相覆盖）。
+            const cacheChanged = mergeLiveToolsInto(knownCache, liveTools);
             if (cacheChanged)
-                void writeKnownMcpTools(knownCache).catch(() => { });
+                void mutateKnownMcpTools((fresh) => mergeLiveToolsInto(fresh, liveTools)).catch(() => { });
         }
         catch (e) { /* ignore */ }
         let live = [];
@@ -1108,7 +956,14 @@ export function createMcpManager(deps) {
             const url = String(args.url || '').trim();
             if (!/^https?:\/\//.test(url))
                 return { ok: false, error: 'url 需为 http(s):// 开头的地址' };
-            row.url = url;
+            // 新增条目**没有旧值可顶替** —— 打码 URL 一律拒绝，让用户重填完整地址（判据见
+            // ./mcp/secret-guard.js）。原来这里直接 `row.url = url`，于是「把列表里那条打码 URL
+            // 复制到新增表单」就会把凭据永久写成 `%3Credacted%3E`，界面还显示成功（审查 F4）。
+            const urlGuard = resolveMaskedUrl(url, null);
+            if (urlGuard.unrecoverable) {
+                return { ok: false, error: 'URL 里的 userinfo / 查询串 / 片段是打码占位符（新增条目没有原值可恢复）：请重新填写完整 URL 后再保存。' };
+            }
+            row.url = urlGuard.value;
             row.headers = sanitize(parseKv(args.headers));
         }
         else {
@@ -1246,7 +1101,7 @@ export function createMcpManager(deps) {
                         await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), toolMap);
                     }
                     catch (e) { /* non-fatal */ }
-                    disabledToolsCache = { at: Date.now(), value: toolMap };
+                    setDisabledToolsCache(toolMap);
                 }
                 // F-025：运行时快照的 mcp 停用表同样按 serverName 键 —— 改名不跟着改，
                 // 退出场景整体回写时旧键成死键、新名工具的停用状态丢失（回到全启用）。
@@ -1395,14 +1250,17 @@ export function createMcpManager(deps) {
             return { ok: true, enabled, changed };
         });
     }
+    /** 一份补丁内容里某个 id 的**生效**启停值（insert 行自带的 flag 与顶层覆盖块合并后）。 */
+    function effectiveDisabledIn(content, id) {
+        const row = parseRows(content).rows.find((r) => r.id === id);
+        return row ? !!row.disabled : false;
+    }
     /** Effective disabled state of a patch row (insert-row flag merged with override blocks). */
     async function isRowDisabled(id, level) {
         const p = await ensurePaths();
         const abs = level === 'global' ? p.globalPatch : p.projectPatch;
         try {
-            const { rows } = parseRows(await readPatch(abs));
-            const row = rows.find((r) => r.id === id);
-            return row ? !!row.disabled : false;
+            return effectiveDisabledIn(await readPatch(abs), id);
         }
         catch (e) {
             return false;
@@ -1466,8 +1324,14 @@ export function createMcpManager(deps) {
                 }
                 let c = await readPatch(abs);
                 c = removeMarked(c, id, 'disable');
-                if (wasDisabled)
-                    c = appendBlock(c, buildDisableBlock(id, true));
+                c = removeMarked(c, id, 'enable');
+                // 覆盖块全删掉之后，生效值**回落**到 insert 行自带的 `disabled:`，而它与「重启前的
+                // 生效状态」不一定相同 —— insert 行写着 `disabled: true`、靠一条 enable 覆盖块启用，
+                // 就是这种形状。此前只在 `wasDisabled` 为真时补一条 disable，于是这种形状下重启会把
+                // 服务器**留在停用态**（2026-09-30 审查 P2-11）。所以这里比一次：不等就按 `wasDisabled`
+                // 显式补一条覆盖；相等就不补 —— 补了会让每次重启都往补丁里多留一个块，没必要。
+                if (effectiveDisabledIn(c, id) !== wasDisabled)
+                    c = appendBlock(c, buildDisableBlock(id, wasDisabled));
                 await writePatch(abs, c);
             }).catch((e) => {
                 warnings.push('恢复重启前状态失败（该服务可能停留在停用态）：' + message(e));
@@ -1574,7 +1438,7 @@ export function createMcpManager(deps) {
                     if (Object.prototype.hasOwnProperty.call(toolMap, serverName)) {
                         delete toolMap[serverName];
                         await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), toolMap);
-                        disabledToolsCache = { at: Date.now(), value: toolMap };
+                        setDisabledToolsCache(toolMap);
                         await applyToolRestrictions();
                     }
                     const knownMap = Object.assign({}, await readKnownMcpTools(true));
@@ -1655,189 +1519,14 @@ export function createMcpManager(deps) {
             return { ok: true, removed: total, ids: removed, files };
         });
     }
-    // ---------- 配置体检（0.15.0 B1；0.16.5 起 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.5）：此前的体检止步于格式校验，一条编造的
-                // 地址也能拿绿点 —— 绿点承诺的「没发现问题」其实只覆盖了一半（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 };
-    }
+    // ---------- 配置体检的探测（0.15.0 B1；0.16.5 起含端点探测）----------------------
+    // 正文 2026-10-01 整段搬到 ./inspect-probe.js（一字未改，只把闭包作用域的几个名字改走
+    // deps）。那段「对补丁只读、`where`/`which` 只查命令名绝不执行配置里的命令、复用列表结果
+    // 但不回写任何缓存」的口径连同理由一起搬过去了，见那边的文件头。
+    const { mcpmInspect } = createInspectProbe({
+        ensurePaths, readPatch, message, normalizeRow, mcpmList,
+    });
+    // ---------- 配置的导出 / 导入 ----------
     async function mcpmExport() {
         const p = await ensurePaths();
         const list = await mcpmList();
@@ -1853,11 +1542,19 @@ export function createMcpManager(deps) {
             level: r.level,
             disabled: r.disabled,
         }));
-        const json = JSON.stringify({ exportedAt: new Date().toISOString(), rows }, null, 2);
+        const payload = { exportedAt: new Date().toISOString(), rows };
+        const json = JSON.stringify(payload, null, 2);
         let savedTo = null;
         try {
             const abs = mcpSidecar(MCP_EXPORT_FILE);
-            await writePatch(abs, json);
+            // 用 `writeJsonFile`（直写 hub 侧车）而**不是** `writePatch`（2026-09-30 审查 P1-3）：
+            // `writePatch` 是宿主**补丁文件**的写口，写前会跑 `checkPatchWrite` 的官方方言校验
+            // （顶层必须是 YAML 数组），而这里写的是 hub 里一份 JSON **对象** —— 校验必然失败、
+            // 异常被下面的 catch 吞掉，于是 `savedTo` 恒为 null，界面显示"没能落盘（hub 目录写入
+            // 失败）"，**诊断是错的**（真实原因是方言校验器拒收 JSON 对象）。而且 `writePatch`
+            // 自己的调用面纪律（`index.ts`：「不写宿主配置的动作也不该调用它」）本就排除了它 ——
+            // 本处是唯一一个传 hub 路径的调用点。顺带省掉一次 `danger-full-access` 策略升级。
+            await writeJsonFile(abs, payload);
             savedTo = abs;
         }
         catch (e) { /* non-fatal */ }
@@ -1903,11 +1600,16 @@ export function createMcpManager(deps) {
                 const nameTaken = byName.has(row.serverName);
                 // 打码值不能入库（判据见 ./mcp/secret-guard.js）：覆盖模式下拿被覆盖条目在补丁里的
                 // 旧真值顶替；非覆盖模式没有旧值可比，走"丢弃"分支。
+                //
+                // `prevConfig` 同时认两种形状：`collectAll()` 出来的行把配置挂在 `config` 下，
+                // 而同一个批次里**先前刚导入**的行（`byId.set(row.id, row)`）是 `mcpmAdd` 那种扁平形状。
+                // 少认一种，同批里重复 id 的那条就拿不到旧值、被静默丢弃。
                 const prevRow = idTaken ? byId.get(row.id) : null;
+                const prevConfig = prevRow ? (prevRow.config || prevRow) : {};
                 for (const field of ['env', 'headers']) {
                     if (row[field] === undefined)
                         continue;
-                    const outcome = resolveMaskedKv(row[field], prevRow ? prevRow[field] : null);
+                    const outcome = resolveMaskedKv(row[field], prevConfig[field]);
                     row[field] = outcome.value;
                     const note = describeMaskedOutcome(outcome);
                     if (note)
@@ -1923,6 +1625,21 @@ export function createMcpManager(deps) {
                     skipped.push({ id: row.id, reason: 'id 已存在' });
                     continue;
                 }
+                // URL 与 env / headers 同一条纪律（判据见 ./mcp/secret-guard.js）：打码值绝不入库。
+                // 覆盖模式下拿被覆盖条目的旧真值顶替；没有旧真值可顶替时**跳过这一条**并给出理由 ——
+                // URL 不是可丢的键值对，写一个"能连上但鉴权失败"的地址比不导入更糟。
+                // 这条原先不存在，于是 `snapshot-export`（默认 `includeSecrets=false` 会把 URL 打码）
+                // 导到目标机后，补丁里落进 `%3Credacted%3E` 而**没有任何 warning**（审查 F4）。
+                if (row.transport === 'streamable-http') {
+                    const urlGuard = resolveMaskedUrl(row.url, prevConfig.url);
+                    if (urlGuard.unrecoverable) {
+                        skipped.push({ id: row.id, reason: 'URL 里的 userinfo / 查询串 / 片段是打码占位符，且没有原值可恢复：请重填完整 URL 后再导入' });
+                        continue;
+                    }
+                    row.url = urlGuard.value;
+                    if (urlGuard.restored)
+                        importNotes.push(row.serverName + '：URL 未改动，已保留原值');
+                }
                 // Overwrite: purge every trace of the id from BOTH patch files first,
                 // then insert the imported row at its own level. The purge is not
                 // atomic with the insert, so keep the pre-purge content of both files
@@ -2031,7 +1748,7 @@ export function createMcpManager(deps) {
         await deps.withWriteLock(async () => {
             await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), entries);
         });
-        disabledToolsCache = { at: Date.now(), value: entries };
+        setDisabledToolsCache(entries);
         scheduleToolRestrictions();
     }
     /**
@@ -2052,18 +1769,9 @@ export function createMcpManager(deps) {
         await readDisabledTools();
         await applyToolRestrictions();
     }
-    /** 卸载清理（原 index.ts 的 cleanup effect 正文）。 */
+    /** 卸载清理（那六行随可见性段搬进 tool-visibility.ts，这里只留出口接线）。 */
     function dispose() {
-        if (restrictTimer) {
-            clearTimeout(restrictTimer);
-            restrictTimer = null;
-        }
-        // 插件卸载时把挂在每个 agent scope 上的限制都撤掉（否则那些 scope 会继续背着一层名单）。
-        epoch += 1;
-        for (const agent of [...agentRestrictions.keys()])
-            liftRestriction(agent);
-        appliedByAgent.clear();
-        seenAgents.clear();
+        disposeVisibility();
     }
     return {
         stateCatalog: mcpStateCatalog,
@@ -2092,12 +1800,13 @@ export function createMcpManager(deps) {
         writeDisabledTools,
         updateNotes,
         mcpmListView,
+        configuredServerNames,
         mcpmRowsWithNotes,
         readPluginSettings,
-        isToolDisabled: (name) => isToolDisabledIn(disabledToolsCache ? disabledToolsCache.value : {}, name),
+        isToolDisabled: (name) => isToolDisabledIn(disabledToolsSnapshot(), name),
         /** 停用表的两个口径（读 TTL 缓存；功能总览用）：`*` 通配的台数 + 单独停用的工具数。 */
         disabledToolSummary: () => {
-            const map = disabledToolsCache ? disabledToolsCache.value : {};
+            const map = disabledToolsSnapshot();
             let servers = 0;
             let tools = 0;
             for (const list of Object.values(map)) {