dsh-plugin-tool-management 0.6.0 → 0.7.0

package/lib/index.js

@@ -18,10 +18,12 @@ import { createSkillsService, pluginLog } from './skills/service.js';
 import { createAgentsMdService } from './agents-md/service.js';
 import { createRulesService } from './rules/service.js';
 import { createArchiveEngine } from './rules/archive-engine.js';
-import { createSubagentService } from './subagents/service.js';
+import { createSubagentService, decideToolFilter } from './subagents/service.js';
 import { isApprovalNever } from './approval-policy.js';
 import { EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, summarize } from './compat/probe.js';
-import { fenceRejection } from './http-fence.js';
+import { assessPresetReach, presetRosterOf, reachNoticeForAgent } from './compat/preset-reach.js';
+import { fenceRejection, secretOpRejection } from './http-fence.js';
+import { planOverrideCompaction } from './mcp/override-blocks.js';
 import { hubPath, hubRoot, relocateEntries } from './hub.js';
 import { createScenePromptSync } from './scene-prompt-sync.js';
 import { defineSubagentListTool, defineSubagentRunTool } from './subagents/tools.js';
@@ -73,6 +75,9 @@ export default {
         const agents = ctx.get('agents');
         // pluginInventory is optional: probe at use time, degrade to no live info.
         const pluginInventory = ctx.get('pluginInventory');
+        // Agent 预设名单（@deepseek-ai/dsh-agent-presets）：同样是可选服务，按需取用。
+        // 读它只为了回答"当前预设下本插件注入的东西到不到得了模型"——只读，不挂载任何预设。
+        const presetRoster = () => presetRosterOf(ctx);
         // Package version, surfaced in the Settings pages and the HTTP API. Read
         // from the installed package.json so it always matches the release tag.
         let PKG_VERSION = 'unknown';
@@ -254,6 +259,44 @@ export default {
             // 用生效集去校验会把合法勾选判成 stale 丢掉。
             return (await skillScan()).all;
         }
+        /**
+         * 场景档案「技能集」的技能行 —— 技能名与来源名**分开**给出。
+         *
+         * 界面早先直接渲染 `key`（形如 `<来源 key>/<技能名>`），而自定义目录的来源 key 是
+         * `custom-<sha256-16>`，于是导入的技能在场景档案里显示成一串哈希（用户 2026-09-15 报的）。
+         * 这里把来源的 label / localeKey 一并带上，界面就能显示「技能名 · 来源名」。
+         *
+         * 含被覆盖的副本（`shadowed`）：场景允许勾选任意一条技能，用生效集校验会把合法勾选判成 stale。
+         */
+        async function skillRows() {
+            const rows = [];
+            try {
+                const r = await skillsService.ops['skill-state']({});
+                for (const root of ((r && r.data && r.data.roots) || [])) {
+                    const rootKey = String((root && root.key) || '');
+                    if (!rootKey)
+                        continue;
+                    for (const sk of ((root && root.skills) || [])) {
+                        const name = String((sk && (sk.declaredName || sk.name)) || '');
+                        if (!name)
+                            continue;
+                        rows.push({
+                            key: rootKey + '/' + name,
+                            name,
+                            enabled: sk.enabled === true && !sk.shadowedBy,
+                            shadowed: !!sk.shadowedBy,
+                            rootKey,
+                            rootLabel: String((root && root.label) || rootKey),
+                            ...(root && root.localeKey ? { rootLocaleKey: String(root.localeKey) } : {}),
+                            ...(root && root.kind ? { rootKind: String(root.kind) } : {}),
+                        });
+                    }
+                }
+            }
+            catch { /* 技能状态读不到 → 空列表（界面如实显示"没有可选项"） */ }
+            // 平铺列表按技能名排（同名再按来源），比按来源聚在一起更好找。
+            return rows.sort((a, b) => a.name.localeCompare(b.name) || a.rootKey.localeCompare(b.rootKey));
+        }
         const archiveService = createArchiveEngine({
             loadSlice: async () => ({ ...(await rulesService.readArchiveSlice()) }),
             saveSlice: (slice) => rulesService.patchIndex(slice),
@@ -357,6 +400,7 @@ export default {
             ...archiveService.writeOps,
             ...subagentService.writeOps,
             'mcpm-add', 'mcpm-edit', 'mcpm-remove', 'mcpm-set-enabled', 'mcpm-set-all', 'mcpm-restart',
+            'mcpm-compact',
             'mcpm-export', 'mcpm-import', 'mcpm-note', 'mcpm-settings', 'mcpm-tool-enabled',
             // mcpm-reveal returns UNMASKED secrets; even though it is a read, it is
             // token-gated like a write — on a LAN-exposed port the token must be the
@@ -365,13 +409,16 @@ export default {
             'skill-open',
             // agents-md 写操作（create/update/remove 改预设库；apply 写全局 AGENTS.md；import 从外部内容建预设）
             'agentsmd-create', 'agentsmd-update', 'agentsmd-apply', 'agentsmd-remove', 'agentsmd-import',
+            // 提示词预设的回收站（恢复 / 永久删除都是写）
+            'agentsmd-trash-restore', 'agentsmd-trash-delete',
             // history 写操作（archive/unarchive 改归档集合；delete 永久删除；retention-set 写保留期；
             // workspace-register 会新增一条宿主工作区登记，同样是写）
             'history-archive', 'history-unarchive', 'history-delete', 'history-retention-set',
             'history-unarchive-batch', 'history-delete-batch', 'history-import', 'history-export',
             'history-archive-batch', 'history-workspace-register',
         ]);
-        // 会泄露明文凭据 / 完整配置的 op：额外要求请求带同源 Origin 头（见路由内的注释）。
+        // 会泄露明文凭据 / 完整配置的 op：**必须**带对的访问令牌，没配令牌就一律拒绝
+        // （判定在 http-fence.ts 的 secretOpRejection，含两种情况的区分与理由）。
         const SENSITIVE_OPS = new Set(['mcpm-reveal', 'mcpm-export']);
         // 兼容体检的日志去重：同一宿主版本只写一条 compat/probe，避免轮询刷屏。
         let compatLoggedFor;
@@ -1941,6 +1988,55 @@ export default {
                 return { ok: true };
             });
         }
+        /**
+         * 收敛补丁文件里的启停覆盖块（用户显式点「整理补丁」才走这里）。
+         *
+         * 只删"删掉也不改变生效状态"的块（判定见 planOverrideCompaction）：insert 行、
+         * 带 config 的覆盖块、以及决定当前生效值的那一条都原样保留。删除前 writePatch
+         * 会自动备份上一版（保留最近 5 份），所以这一步是可回退的。
+         *
+         * 基准状态由 planOverrideCompaction 自己从 insert 行读（另一份文件的内容只用来补
+         * "insert 行不在本文件里"的情况）。这里**不要**喂 parseRows() 的 rows —— 那是合并
+         * 覆盖块之后的生效值，会让每个 decider 都被判成多余：第一版就是这么把 6 台 MCP
+         * 全部启用的。同理，界面不显示任何"多余块数"（那个数字也来自同一条错误口径）。
+         */
+        async function mcpmCompact() {
+            const p = await ensurePaths();
+            return withWriteLock(async () => {
+                const levels = ['project', 'global'];
+                const absOf = (level) => (level === 'project' ? p.projectPatch : p.globalPatch);
+                const contents = {};
+                for (const level of levels) {
+                    try {
+                        contents[level] = await readPatch(absOf(level));
+                    }
+                    catch (e) {
+                        contents[level] = '';
+                    }
+                }
+                const removed = {};
+                const files = [];
+                let total = 0;
+                for (const level of levels) {
+                    const content = contents[level];
+                    if (!content)
+                        continue;
+                    const others = levels.filter((other) => other !== level).map((other) => contents[other]).filter(Boolean);
+                    const plan = planOverrideCompaction(content, others);
+                    if (!plan.ranges.length)
+                        continue;
+                    await writePatch(absOf(level), spliceRanges(splitLines(content), plan.ranges));
+                    files.push(absOf(level));
+                    for (const [id, stat] of Object.entries(plan.ids)) {
+                        if (!stat.dropped)
+                            continue;
+                        removed[id] = (removed[id] || 0) + stat.dropped;
+                        total += stat.dropped;
+                    }
+                }
+                return { ok: true, removed: total, ids: removed, files };
+            });
+        }
         async function mcpmExport() {
             const p = await ensurePaths();
             const list = await mcpmList();
@@ -2289,32 +2385,24 @@ export default {
             const agentPresets = (typeof ctx.get === 'function' ? ctx.get('agentPresets') : undefined);
             if (agentPresets && typeof agentPresets.list === 'function') {
                 try {
+                    // roster 顺序 = 官方的展示顺序（preset.yml 的 order：标准 1 / PTC 2 / 极简 3 / 创造 4，
+                    // 自建预设排在其后）。人设编辑器的四行照抄这个顺序，**不要**再按 id 排序。
                     const roster = await agentPresets.list();
                     for (const p of roster || []) {
                         const id = String((p && p.id) || '');
                         if (!id)
                             continue;
-                        presets.push({ id, name: String((p && (p.name || p.id)) || id) });
-                        let scopeKey;
-                        try {
-                            // 官方说明：该调用会确保预设的 standing mount（不创建 agent/session），
-                            // 已挂载的预设直接复用；正因如此才需要这里的 60 秒缓存。
-                            scopeKey = typeof agentPresets.standingKeyFor === 'function' ? await agentPresets.standingKeyFor(id) : undefined;
-                        }
-                        catch {
-                            scopeKey = undefined;
-                        }
-                        let names = [];
-                        try {
-                            names = (await tools.schemas(scopeKey) || []).map((s) => String(s.name)).filter(Boolean);
-                        }
-                        catch {
-                            names = [];
-                        }
+                        // MCP 工具名形如 `mcp__<server>__<tool>`：面向上百个条目，噪声大于价值 → 不进候选。
+                        // 子代理照样能用当前在跑的 MCP —— 那份名单在 decideToolFilter 里运行时并进白名单。
+                        const names = (await presetToolNames(id)).filter((name) => !name.startsWith('mcp__'));
+                        presets.push({
+                            id,
+                            name: String((p && (p.name || p.id)) || id),
+                            trust: String((p && p.trust) || 'user'),
+                            broken: typeof (p && p.broken) === 'string',
+                            tools: names,
+                        });
                         for (const name of names) {
-                            // MCP 工具名形如 `mcp__<server>__<tool>`：面向上百个条目，噪声大于价值 → 不进候选。
-                            if (name.startsWith('mcp__'))
-                                continue;
                             const rec = byName.get(name) || { name, presets: new Set(), current: false };
                             rec.presets.add(id);
                             byName.set(name, rec);
@@ -2336,11 +2424,94 @@ export default {
                 tools: [...byName.values()]
                     .map((r) => ({ name: r.name, presets: [...r.presets].sort(), current: r.current }))
                     .sort((a, b) => a.name.localeCompare(b.name)),
-                presets: presets.sort((a, b) => a.id.localeCompare(b.id)),
+                // 保持 roster 顺序（官方的展示顺序），前端四行直接照用。
+                presets,
             };
             presetToolsCache = { at: Date.now(), value };
             return value;
         }
+        /**
+         * 单个预设的工具名（列表里含 MCP 与宿主平面的工具，因为子代理的可见集合是
+         * "宿主平面 ∪ 该预设"的并集）。枚举会为该预设建立 standing mount —— 官方语义：
+         * 一个预设每进程只挂一次，正常创建会话时同样会挂，所以这里按 id 缓存 60 秒；
+         * `subagent_run` 每次委派都要用它校验名单，不能每次都重新枚举。
+         */
+        const presetNamesCache = new Map();
+        async function presetToolNames(id) {
+            const hit = presetNamesCache.get(id);
+            if (hit && Date.now() - hit.at < 60000)
+                return hit.names;
+            const agentPresets = (typeof ctx.get === 'function' ? ctx.get('agentPresets') : undefined);
+            let scopeKey;
+            try {
+                scopeKey = agentPresets && typeof agentPresets.standingKeyFor === 'function'
+                    ? await agentPresets.standingKeyFor(id)
+                    : undefined;
+            }
+            catch {
+                scopeKey = undefined;
+            }
+            let names = [];
+            try {
+                names = ((await tools.schemas(scopeKey)) || []).map((s) => String(s.name)).filter(Boolean);
+            }
+            catch {
+                names = [];
+            }
+            presetNamesCache.set(id, { at: Date.now(), names });
+            return names;
+        }
+        /** 预设名单的名字投影（只读 roster，不挂载任何预设）：场景页显示模式名用。 */
+        async function presetNames() {
+            const agentPresets = (typeof ctx.get === 'function' ? ctx.get('agentPresets') : undefined);
+            if (!agentPresets || typeof agentPresets.list !== 'function')
+                return [];
+            try {
+                const roster = await agentPresets.list();
+                return (roster || [])
+                    .map((p) => ({ id: String((p && p.id) || ''), name: String((p && (p.name || p.id)) || ''), trust: String((p && p.trust) || 'user') }))
+                    .filter((p) => p.id !== '');
+            }
+            catch {
+                return [];
+            }
+        }
+        /** 调用方 agent 跑在哪个 Agent 预设上；判断不了返回 null（绝不猜）。 */
+        function currentPresetId(agentCtx) {
+            if (agentCtx === undefined || agentCtx === null)
+                return null;
+            try {
+                const roster = presetRoster();
+                if (roster === undefined || typeof roster.composedPreset !== 'function')
+                    return null;
+                const id = String(roster.composedPreset(agentCtx) ?? '');
+                return id === '' ? null : id;
+            }
+            catch {
+                return null;
+            }
+        }
+        /**
+         * 人设的工具限制：按**当前会话的预设**决定这次委派下发什么（规则见 decideToolFilter）。
+         * 已知工具名 = 宿主平面（含 MCP）∪ 当前预设的工具；枚举失败时退化成宿主平面，
+         * 于是模式名单里的预设侧工具会被如实记为"当前不存在"，而不是造成官方 restrict 抛错。
+         */
+        async function subagentToolFilterFor(persona, agentCtx) {
+            let hostNames = [];
+            try {
+                hostNames = ((await tools.schemas()) || []).map((s) => String(s.name)).filter(Boolean);
+            }
+            catch {
+                hostNames = [];
+            }
+            const mcp = hostNames.filter((name) => name.startsWith('mcp__'));
+            const known = new Set(hostNames);
+            const presetId = currentPresetId(agentCtx);
+            if (presetId !== null)
+                for (const name of await presetToolNames(presetId))
+                    known.add(name);
+            return decideToolFilter(persona, presetId, { names: known, mcp });
+        }
         /**
          * 模型候选（人设的「模型」下拉）：宿主已注册的 provider + 各 provider 能宣告的模型。
          * 只读宿主 LLM 目录，**不发起网络请求**（`discoverModels` 会打端点，这里不用）；
@@ -2400,6 +2571,7 @@ export default {
             'mcpm-set-all': mcpmSetAll,
             'mcpm-restart': mcpmRestart,
             'mcpm-remove': mcpmRemove,
+            'mcpm-compact': mcpmCompact,
             'mcpm-export': mcpmExport,
             'mcpm-import': mcpmImport,
             // 技能管理 ops（由 ./skills/service.js 提供）：skill-state / skill-detail /
@@ -2438,7 +2610,7 @@ export default {
             'model-candidates': async () => ({ ok: true, ...(await modelCandidates()) }),
             // 场景档案勾选器数据源 v2：全部 MCP 服务器（含未运行）+ 技能全集 + 人设清单。
             'scene-inventory': async () => {
-                const [rowsR, tools, skills, subs] = await Promise.all([mcpmListView(), toolStates(), skillStates(), subagentService.list()]);
+                const [rowsR, tools, skills, subs] = await Promise.all([mcpmListView(), toolStates(), skillRows(), subagentService.list()]);
                 const disabledRaw = await readDisabledTools();
                 const rows = (rowsR && rowsR.rows) || [];
                 const mcpServers = [];
@@ -2462,8 +2634,13 @@ export default {
                     ok: true,
                     mcpServers,
                     tools: Object.entries(tools).map(([key, enabled]) => ({ key, enabled })),
-                    skills: Object.entries(skills).map(([key, enabled]) => ({ key, enabled })),
-                    subagents: subs.map((p) => ({ name: p.name, description: p.description })),
+                    // 技能行：技能名与来源名分开给（早先只给 `<来源 key>/<技能名>`，自定义目录的
+                    // 来源 key 是 `custom-<hash>`，于是导入的技能在场景里显示成一串哈希）。
+                    skills,
+                    // 人设行要显示"按模式配了什么限制"，所以把按模式名单一起带上；
+                    // presets 只给名字与来源（不枚举工具，避免打开档案弹窗就挂载每个预设）。
+                    subagents: subs.map((p) => ({ name: p.name, description: p.description, toolsByPreset: p.toolsByPreset ?? null })),
+                    presets: await presetNames(),
                     // 档案编辑器第 4 段「记忆」的候选：场景 + 每个场景里的记忆条数。
                     // 记忆正文不在这里返回（勾选集只存 id，渲染时才读盘）。
                     scenes: await memorySceneCandidates(),
@@ -2540,6 +2717,11 @@ export default {
                 return agentsMdService.remove(id);
             },
             'agentsmd-import': (args) => agentsMdService.importPreset(String((args && args.id) || ''), String((args && args.content) ?? '')),
+            // 提示词预设的回收站：删预设 = 把整个预设目录移入 `hub/trash/agents-md-trash/<id>/`，
+            // 误删可从「提示词」页的回收站里恢复（同 id 已存在时拒绝恢复，绝不覆盖）。
+            'agentsmd-trash-list': () => agentsMdService.trashList(),
+            'agentsmd-trash-restore': (args) => agentsMdService.trashRestore(String((args && args.id) || '')),
+            'agentsmd-trash-delete': (args) => agentsMdService.trashDelete(String((args && args.id) || '')),
             // History（归档会话管理）ops。只读：history-list / history-retention-get；
             // 写：history-archive / history-unarchive / history-delete / history-retention-set。
             // workspaceRegistry 缺失（补丁未生效）时返回明确错误，不崩页面。
@@ -2750,6 +2932,30 @@ export default {
                     return { ok: false, error: message(e) };
                 }
             },
+            // 预设可达性矩阵：每个 Agent 预设下，本插件的注入类能力到不到得了模型。
+            // 只读预设组合文本，不挂载任何预设、不改任何数据。回答的是"面板上说注入了，
+            // 模型真的看得到吗" —— minimal 这类 persona complete 的预设会压制全部提示词段。
+            'preset-reach': async () => {
+                try {
+                    // 宿主平面的 MCP 工具数：四个官方预设都不在组合里挂 MCP，MCP 由
+                    // $DSH_HOME/cordis.patch.yml 这一层挂载，所以它对所有预设一视同仁；
+                    // 这一列要回答的只是"现在有没有 MCP 工具可用"。探测失败 → 不传该字段，
+                    // 矩阵那一格显示"判断不了"而不是猜。
+                    let mcpTools;
+                    try {
+                        const schemas = await tools.schemas();
+                        mcpTools = schemas.filter((s) => String(s && s.name || '').startsWith('mcp__')).length;
+                    }
+                    catch {
+                        mcpTools = undefined;
+                    }
+                    const report = await assessPresetReach(presetRoster(), { mcpTools });
+                    return { ok: true, ...report };
+                }
+                catch (e) {
+                    return { ok: false, error: message(e) };
+                }
+            },
             'history-unarchive': async (args) => {
                 const registry = getHistoryRegistry();
                 if (!registry)
@@ -3120,12 +3326,15 @@ export default {
             description: 'List AGENTS.md presets in the plugin preset library (id, active state).',
             parameters: {},
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
-            async execute() {
+            async execute(_args, exec) {
                 const r = await agentsMdService.list();
                 if (!r.ok)
                     throw new Error(r.error);
                 const summary = r.presets.map((p) => p.id + (p.active ? ' [active]' : ''));
-                return 'AGENTS.md presets:\n' + (summary.join('\n') || '(none)') + '\n(Applying takes effect on the next session created; the current session is unchanged.)';
+                // 同上：AGENTS.md 由 dsh-agent-instructions 行承载，预设没挂这一行（或 persona
+                // 是 complete）时文件内容不会进提示词。
+                const notice = await reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx);
+                return 'AGENTS.md presets:\n' + (summary.join('\n') || '(none)') + '\n(Applying takes effect on the next session created; the current session is unchanged.)' + notice;
             },
         }));
         tools.register(defineTool({
@@ -3153,15 +3362,18 @@ export default {
                 group: { type: 'string', description: 'Optional scene filter.' },
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
-            async execute(args) {
+            async execute(args, exec) {
                 const r = await rulesService.ops['rules-list'](args);
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || '读取规则失败');
                 const lines = (r.rules || []).map((x) => ('- ' + x.id + ' [' + (x.group || '未归属场景') + '] ' + (x.enabled ? '已启用' : '已停用') +
                     (x.description ? ' — ' + x.description : '')));
                 const scenes = (r.scenes || []).map((s) => (s.label || s.name) + (s.active ? '(启用)' : '(未启用)')).join('、');
+                // 注入边界：预设可能压制提示词段（complete persona，或未挂 agent-instructions），
+                // 此时列出的记忆**不在**模型上下文里。必须说出来，否则模型会假设自己已经看到正文。
+                const notice = await reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx);
                 return '记忆（' + (r.rules || []).length + '）：\n' + (lines.join('\n') || '(无记忆)') +
-                    '\n场景：' + (scenes || '(无)') + (r.activeMode === 'all' ? '（默认全部启用）' : '（已收窄）');
+                    '\n场景：' + (scenes || '(无)') + (r.activeMode === 'all' ? '（默认全部启用）' : '（已收窄）') + notice;
             },
         }));
         tools.register(defineTool({
@@ -3201,7 +3413,9 @@ export default {
             // 与其余 12 个工具同一条注册通道：defineTool 负责编译 parameters（object root + required），
             // 裸 register 会把未编译的参数声明直接发给模型 API。
             tools.register(defineTool(defineSubagentListTool({ list: () => subagentService.list(), sceneLists: subagentSceneLists })));
-            tools.register(defineTool(defineSubagentRunTool({ ...subagentService, sceneLists: subagentSceneLists })));
+            // 工具限制按**当前会话的 Agent 预设**下发：父会话跑在哪个预设，就用那个预设那一行的
+            // 白/黑名单（`decideToolFilter`），名单里已消失的工具名会被丢掉并在结果里如实说明。
+            tools.register(defineTool(defineSubagentRunTool({ ...subagentService, sceneLists: subagentSceneLists, toolFilterFor: subagentToolFilterFor })));
         }
         catch (e) {
             console.error('[dsh-plugin-tool-management] subagent tool registration failed:', message(e));
@@ -3377,7 +3591,6 @@ export default {
                             res.end(JSON.stringify({ ok: false, error: 'missing plugin gate header' }));
                             return;
                         }
-                        const origin = hdr('origin');
                         const tokenAccepted = TOKEN !== '' && hdr('x-dsh-token') === TOKEN;
                         if (!tokenAccepted) {
                             const fence = fenceRejection(req, connection);
@@ -3401,12 +3614,16 @@ export default {
                                 /* otherwise fall through with {} */
                             }
                             const op = String(payload.op || '');
-                            // 敏感 op（会吐明文密钥与完整配置）额外要求带 Origin 头：即使在宿主栅栏
-                            // 缺失的组合里，也不接受"无 Origin 的本机请求"直接取密钥。持有效令牌的
-                            // 本地工具不属于此类，直接放行。
-                            if (SENSITIVE_OPS.has(op) && !origin && !tokenAccepted) {
-                                res.end(JSON.stringify({ ok: false, error: '该操作仅接受同源浏览器请求（缺少 Origin 头）' }));
-                                return;
+                            // 敏感 op（会吐明文密钥与完整配置）：**必须**带对的访问令牌，没配令牌
+                            // 就没有明文（判定与理由见 http-fence.ts 的 secretOpRejection）。
+                            // 之前这里只查"有没有 Origin 头"，而 token 为空时它形同虚设 —— 任何能
+                            // 打开 GUI 的浏览器都拿得到全部密钥原文。
+                            if (SENSITIVE_OPS.has(op)) {
+                                const gate = secretOpRejection({ tokenConfigured: TOKEN !== '', tokenAccepted });
+                                if (gate) {
+                                    res.end(JSON.stringify({ ok: false, error: gate.error, code: gate.code }));
+                                    return;
+                                }
                             }
                             if (TOKEN && WRITE_OPS.has(op) && hdr('x-dsh-token') !== TOKEN) {
                                 res.end(JSON.stringify({ ok: false, error: '缺少或错误的访问令牌（x-dsh-token）' }));

package/lib/mcp/override-blocks.js

@@ -0,0 +1,195 @@
+// 补丁文件（cordis.patch.yml）里的「启停覆盖块」识别与收敛计划。
+//
+// 同一个 loader id 的启停状态有两种写法：insert 行自带的 `disabled:`，以及顶层
+// `- id: xxx` + `disabled:` 的独立覆盖块。补丁按顺序应用、**last-wins**
+// （见 @deepseek-ai/dsh-app-boot 的 applyEntryPatches：`target[key] = value`），
+// 所以覆盖块可以无限追加而每次都不报错 —— 代价是文件越用越长，生效值只能靠
+// "最后一条声明了 disabled 的块"推断。
+//
+// 这里只回答一个问题：要收敛的话，删哪些行区间**且生效值保证不变**。
+//
+// ⚠ 这个模块第一版出过一次事故：调用方把 `parseRows()` 合并覆盖块之后的**生效值**
+// 当基准传进来，而生效值恒等于 decider 的值 —— 于是"decider 的值 == 基准"永远成立，
+// 每个 decider 都被当成 no-op 删掉，6 台 MCP 全部被启用。为了从结构上杜绝这种传错，
+// 现在的接口是：`planOverrideCompaction(content, otherFileContents)` —— 基准只能由
+// 本模块自己从 **insert 行**读（`insertBaseRows`），调用方只能再补"另一份补丁文件的
+// 内容"，不能传任何现成的状态值进来。
+/**
+ * 顶层块扫描：每个 `- ` 开头的行都是新块的开始，块体延伸到下一个 `- ` 行之前。
+ *
+ * `end` 剔除块尾的注释/空行 —— 那些行属于"块与块之间"，其中就包括下一个块自己的
+ * `# dsh-…:disable:<id>` 标记注释。带上它们的话，删一个块会把下一个块的注释一起带走。
+ */
+export function scanBlockRanges(lines) {
+    const out = [];
+    let current = null;
+    const flush = () => {
+        if (!current)
+            return;
+        let end = current.start + current.lines.length;
+        while (end > current.start + 1 && (lines[end - 1].trim() === '' || /^\s*#/.test(lines[end - 1])))
+            end--;
+        out.push({ start: current.start, end, text: current.lines.slice(0, end - current.start).join('\n') });
+        current = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        if (/^- /.test(lines[i])) {
+            flush();
+            current = { start: i, lines: [lines[i]] };
+        }
+        else if (current)
+            current.lines.push(lines[i]);
+    }
+    flush();
+    return out;
+}
+/**
+ * 读一个覆盖块三件事：id、disabled、是不是"纯块"。
+ *
+ * 只看**顶层/一层缩进**的锚定写法（`- id:`、`name:`、`disabled:`）：生成器写出来的
+ * 就是这几行，而 config 里的同名键缩进更深 —— 万一手工把 `disabled` 藏进 config，
+ * 这里会判成"非纯块"（保留不删），保守方向是对的。
+ *
+ * 不筛 `name:` —— 补丁是按 **loader id** 生效的，别的模块名写同一个 id 时改的仍是
+ * 那个条目；真正决定"能不能删"的是 pure 与 decider 两条规则，不是名字。
+ */
+export function readToggleEntry(lines) {
+    let id;
+    let disabled;
+    let pure = true;
+    for (const raw of lines) {
+        const line = raw.replace(/\s+$/, '');
+        if (!line.trim() || line.trimStart().startsWith('#'))
+            continue;
+        const head = line.match(/^- id:\s*(\S+)\s*$/);
+        if (head) {
+            id = head[1];
+            continue;
+        }
+        if (/^\s{2,}name:\s*\S+\s*$/.test(line))
+            continue;
+        const flag = line.match(/^\s{2,}disabled:\s*(true|false)\s*$/);
+        if (flag) {
+            disabled = flag[1] === 'true';
+            continue;
+        }
+        pure = false;
+    }
+    return { id, disabled, pure };
+}
+/** 覆盖块自己的标记注释（紧邻上方的 `# …:disable|enable:<id>`），删块时一起删。 */
+export function markerLinesAbove(lines, start) {
+    let i = start;
+    while (i > 0 && /^# (?:dsh-plugin-tool-management|dsh-mcp-manager):(?:disable|enable):/.test(lines[i - 1]))
+        i--;
+    return i;
+}
+/** 文件里所有顶层启停覆盖块（按出现顺序）。 */
+export function scanOverrideBlocks(content) {
+    const lines = content.split(/\r?\n/);
+    const out = [];
+    for (const block of scanBlockRanges(lines)) {
+        if (/^- insert:/.test(lines[block.start]))
+            continue;
+        const entry = readToggleEntry(lines.slice(block.start, block.end));
+        if (!entry.id)
+            continue;
+        out.push({ ...block, id: entry.id, disabled: entry.disabled, pure: entry.pure });
+    }
+    return out;
+}
+/**
+ * **insert 行自带的** 启停基准（`- insert:` 里每个子条目的 `disabled`，缺失 = 启用）。
+ *
+ * 这是收敛判定的唯一合法基准来源：绝不能用 `parseRows()` 那种"合并覆盖块之后的生效值"，
+ * 因为生效值就等于最后一条覆盖块的值，"覆盖块的值 == 基准"会恒成立，decider 会被全删。
+ */
+export function insertBaseRows(content) {
+    const lines = content.split(/\r?\n/);
+    const out = [];
+    for (const block of scanBlockRanges(lines)) {
+        if (!/^- insert:/.test(lines[block.start]))
+            continue;
+        let id;
+        let disabled;
+        const flush = () => { if (id)
+            out.push({ id, disabled }); };
+        for (const line of block.text.split('\n')) {
+            const child = line.match(/^ {4}- id:\s*(\S+)\s*$/);
+            if (child) {
+                flush();
+                id = child[1];
+                disabled = undefined;
+                continue;
+            }
+            if (!id)
+                continue;
+            const flag = line.match(/^\s+disabled:\s*(true|false)\s*$/);
+            if (flag)
+                disabled = flag[1] === 'true';
+        }
+        flush();
+    }
+    return out;
+}
+/**
+ * 收敛计划：算出"删掉也不改变生效状态"的覆盖块行区间。
+ *
+ * 为什么除最后一条外都能删：补丁按顺序应用，同一 id 的多个覆盖块 last-wins，真正
+ * 决定生效值的只有**最后一个声明了 disabled 的块**（decider）。于是：
+ *   - decider 之前的纯启停块 → 删（被 decider 盖住）；
+ *   - decider 本身 → 仅当它与 insert 行的 disabled 相同（纯 no-op）**且基准已知**时删；
+ *   - decider 之后的块 → 留着（它们不声明 disabled，可能改的是别的东西）；
+ *   - 带 config 的非纯块 → 一律留着（可能承载手工覆盖内容）。
+ *
+ * "基准未知"为什么要单列：覆盖块可以打在**补丁文件之外**定义的条目上（profile 的
+ * cordis.yml 原生行，或另一份补丁文件的 insert 行）。此时"删掉这条 disabled: false"
+ * 完全可能把它翻回原生状态的 disabled: true —— 所以基准未知时只删被 decider 盖住的
+ * 那些块，绝不删 decider 自己。
+ *
+ * @param content - 补丁文件全文。
+ * @param otherFileContents - 同一 id 的 insert 行**可能坐在里面**的其它补丁文件全文
+ *   （项目级与全局两份互查）。只用于补基准，绝不用来推断本文件要删什么。
+ * @returns `ranges` 为要删除的行区间；`ids` 为逐 id 统计。
+ */
+export function planOverrideCompaction(content, otherFileContents = []) {
+    const lines = content.split(/\r?\n/);
+    const byId = new Map();
+    for (const block of scanOverrideBlocks(content)) {
+        const list = byId.get(block.id);
+        if (list)
+            list.push(block);
+        else
+            byId.set(block.id, [block]);
+    }
+    const baseOf = new Map();
+    for (const row of insertBaseRows(content))
+        baseOf.set(row.id, row.disabled === true);
+    for (const other of otherFileContents) {
+        for (const row of insertBaseRows(other))
+            if (!baseOf.has(row.id))
+                baseOf.set(row.id, row.disabled === true);
+    }
+    const ranges = [];
+    const ids = {};
+    for (const [id, list] of byId) {
+        const baseKnown = baseOf.has(id);
+        const base = baseOf.get(id) === true;
+        let decider = -1;
+        for (let i = 0; i < list.length; i++)
+            if (list[i].disabled !== undefined)
+                decider = i;
+        const doomed = [];
+        if (decider >= 0) {
+            for (let i = 0; i < decider; i++)
+                if (list[i].pure)
+                    doomed.push(list[i]);
+            if (baseKnown && list[decider].pure && list[decider].disabled === base)
+                doomed.push(list[decider]);
+        }
+        ids[id] = { total: list.length, dropped: doomed.length };
+        for (const block of doomed)
+            ranges.push([markerLinesAbove(lines, block.start), block.end]);
+    }
+    return { ranges, ids };
+}