dsh-plugin-tool-management 0.12.1 → 0.14.0

package/lib/index.js

@@ -22,16 +22,22 @@ import { isInsideRootResolved } from './paths.js';
 import { DEFAULT_PROFILE_NAME, PROFILE_CANDIDATES } from './host-names.js';
 import { createMemoriesService } from './memories/service.js';
 import { createArchiveEngine } from './memories/archive-engine.js';
+import { readIndexSync } from './memories/index-io.js';
+import { runStateDoctor } from './ops/state-doctor.js';
 import { createSubagentService, decideToolFilter, defaultPersonasDir } from './subagents/service.js';
 import { createSubagentCatalog } from './subagents/catalog.js';
 import { createSkillCatalog } from './skills/catalog.js';
 import { DEFAULT_INJECT_SETTINGS, createContextInjector, normalizeInjectSettings, subagentDepthOf, } from './context-inject.js';
 import { isApprovalNever } from './approval-policy.js';
+import { addPreset, buildToolTableReport, DEFAULT_HIDDEN_TOOLS, dropPreset, migrateLegacyToolNames, normalizeToolTableSettings, PRESET_MAX_COUNT, PRESET_NAME_MAX_LENGTH, toolTableSettingsFrom, } from './tools/table.js';
+import { normalizeSceneSettings } from './scene-settings.js';
 import { checkPatchWrite, takePatchGuardWarnings } from './compat/patch-dialect.js';
 import { clearRuntimeNote, noteRuntime } from './compat/runtime-notes.js';
 import { reachNoticeForAgent } from './compat/preset-reach.js';
 import { TOKEN_CODE_BAD, TOKEN_MSG, fenceRejection, secretOpRejection } from './http-fence.js';
 import { createMcpManager } from './mcp/manager.js';
+// 确认卡回显"新 URL"时要打码（查询串里的凭据不该明文进卡片），口径与列表视图同一份实现。
+import { maskUrlQuery } from './mcp/secret-guard.js';
 import { createCandidates } from './scenes/candidates.js';
 // 「已知工具」归一化与「当前可用工具数」原本定义在本文件（导出仅为测试接缝），
 // 2026-09-19 随 MCP 域搬进 ./mcp/manager.ts。这里保持原路径可导出，契约不变。
@@ -44,6 +50,7 @@ import { buildPromptOps } from './ops/prompts.js';
 import { buildSessionOps } from './ops/sessions.js';
 // HTTP 请求准入与 handlers 后处理（2026-09-19 从本文件 apply 闭包抽出，依赖显式传参）。
 import { createAccessToken, createOpWhitelist, createSceneLock, installHandlerGuards } from './request-gate.js';
+import { auditOpRegistry, auditProblems } from './op-registry.js';
 import { buildSceneSyncOps } from './ops/scene-sync.js';
 import { buildCandidateOps } from './ops/candidates.js';
 // model 工具（ctx.tools.register）按域分文件；共享的依赖形状见 tools/deps.ts。
@@ -51,6 +58,7 @@ import { buildMcpTools } from './tools/mcp.js';
 import { buildSkillTools } from './tools/skills.js';
 import { buildPromptTools } from './tools/prompt.js';
 import { buildMemoryTools } from './tools/memory.js';
+import { buildSceneTools } from './tools/scene.js';
 import { buildSubagentTools } from './tools/subagent.js';
 import { createScenePromptSync } from './scene-prompt-sync.js';
 import { extractText } from './imports/parsers.js';
@@ -101,6 +109,8 @@ export const INJECT_SERVICES = [
     'timer', 'fs', 'settings', 'sandboxPolicy', 'webServer', 'tools', 'skills', 'sessions',
     'agents', 'workspaceRegistry', 'sessionProjectionCache', 'sessionPersistence',
 ];
+/** 工具表设置预热完成前的答案：一个都不关（见 apply 里 toolTableHidden 的注释）。 */
+const EMPTY_TOOL_SET = new Set();
 export default {
     name: 'dsh-plugin-tool-management-host',
     inject: [...INJECT_SERVICES],
@@ -203,7 +213,7 @@ export default {
             memoriesRoot: String(config?.memoriesRoot || ''),
             stateDir: String(config?.memoriesStateDir || ''),
             scenesDir: String(config?.memoriesScenesDir || ''),
-            // 场景记忆段预算（字节），默认 65536；仅用于测试与特殊部署调优。
+            // 场景记忆段预算（字节），默认 131072（= DEFAULT_MAX_BYTES，128 KiB）；仅用于测试与特殊部署调优。
             ...(Number.isFinite(Number(config?.rulesMaxBytes))
                 ? { maxBytes: Number(config.rulesMaxBytes) }
                 : {}),
@@ -502,7 +512,189 @@ export default {
                 .filter((s) => s.active)
                 .map((s) => slice.archives[s.name]?.subagents ?? []);
         };
-        // ---------- 注入通道（场景和记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
+        // ---------- 模型工具表开关（侧车 `tool-table.json`，界面在「兼容」页）----------
+        // 工具表按**每个请求**付钱：20 个工具的整份定义合计 ≈3,769 tok 每轮都在。关掉某几个，
+        // 它们整份不进请求（实测口径与取舍见 src/tools/table.ts 的文件头）。**出厂就已经关了十五条**
+        // （20 条里实发只剩 5 条）—— 名单、判据与代价在 `DEFAULT_HIDDEN_TOOLS`，只在这个人从没记过
+        // 选择时铺（见下面的 `toolTableSettingsFrom`）。
+        //
+        // 为什么放在目录之前：两个目录的「用 `X` 查」提示要跟着这份设置变（工具关掉后那句话
+        // 就是假的），所以它们的构造依赖在这块之后 —— 不做前向引用，顺序就是依赖顺序。
+        const TOOL_TABLE_FILE = 'tool-table.json';
+        const TOOL_TABLE_TTL_MS = 3000;
+        /** 注册时量到的工具体积（只记真进了表的那些；量的是 register 收到的整份定义）。 */
+        const toolTableSizes = new Map();
+        function recordToolSize(def) {
+            try {
+                const name = String(def.name ?? '');
+                if (name === '')
+                    return;
+                // 与宿主同一口径（dsh-token-meter 的 estimateToolsTokens 就是把 tools 整份
+                // JSON.stringify 后除以 4），所以这里量整份定义，不只量 description。
+                toolTableSizes.set(name, JSON.stringify(def).length);
+            }
+            catch { /* 量不出来就不记：它只影响界面上的估算数字 */ }
+        }
+        let toolTableCache = null;
+        async function readToolTableSettings(force = false) {
+            if (toolTableCache && !force && Date.now() - toolTableCache.at < TOOL_TABLE_TTL_MS)
+                return toolTableCache.value;
+            await ensurePaths();
+            const raw = await readJsonFile(hubPath(TOOL_TABLE_FILE));
+            // 0.14.0 旧工具名迁移：读侧翻译一次并**回写盘**（幂等）。不迁移的话，用户"关掉了某条"
+            // 的意图会在新名字上静默失效 —— 那条工具照旧每轮发出去，而界面上看不出来。
+            // 写失败不回滚本次读取：内存里已经是迁移后的值，下次读会再试一次。
+            // 侧车不存在（`readJsonFile` 给 null）= 用户从没记过选择 ⇒ 用**出厂默认**（十五条不发，
+            // 实发 5 条；判据与代价见 tools/table.ts 的 DEFAULT_HIDDEN_TOOLS）。存过盘的
+            // 一律照盘上那份，包括显式的 `hidden: []` —— 那是"我全都要"，不能被默认值盖掉。
+            const migrated = migrateLegacyToolNames(toolTableSettingsFrom(raw));
+            const value = migrated.settings;
+            if (migrated.changed) {
+                try {
+                    await writeJsonFile(hubPath(TOOL_TABLE_FILE), value);
+                }
+                catch { /* 回写失败：本次仍按迁移后的值生效 */ }
+            }
+            const changed = toolTableCache === null || toolTableCache.value.hidden.join('\u0000') !== value.hidden.join('\u0000');
+            toolTableCache = { at: Date.now(), value, off: new Set(value.hidden) };
+            // 首读 / 文件被外部改过 ⇒ 可见性要跟着重排。同步快照的调用方（门禁、注入通道）不会
+            // 自己重排，它们只是"下次问的时候读到新值"；把限制摘掉/装上这一步必须有人做。
+            // （`mcp` 在 apply 里是同步赋值、本函数只可能在自己的 await 之后回到这里，所以到得了。）
+            if (changed) {
+                try {
+                    mcp.scheduleToolRestrictions();
+                }
+                catch { /* 兜底：拿不到 manager 就等下一次 tools/change */ }
+            }
+            return value;
+        }
+        /**
+         * 同步快照（热路径用：工具门禁每次调用、注入通道每个 step 都要问一句）。还没加载时先给
+         * **空集**并异步预热 —— 空集不是出厂默认（出厂关着五条），是刻意的：预热前的这一瞬与
+         * 用户的选择可能不一致，但方向必须是安全的那一侧（不隐藏任何东西，绝不因为读盘慢而让
+         * 工具凭空消失）。
+         */
+        function toolTableHidden() {
+            if (toolTableCache === null) {
+                void readToolTableSettings().catch(() => { });
+                return EMPTY_TOOL_SET;
+            }
+            return toolTableCache.off;
+        }
+        const toolTableRows = () => [...toolTableSizes].map(([name, bytes]) => ({ name, bytes }));
+        const toolTableReport = (hidden = [...toolTableHidden()]) => buildToolTableReport(toolTableRows(), hidden);
+        /** 落盘 + 同步内存缓存（三条写路径共用：改勾选 / 存方案 / 删方案）。 */
+        async function writeToolTableSettings(next) {
+            await ensurePaths();
+            // 落盘在写锁里，落完**出了锁**再刷新（`withWriteLock` 是一条不可重入的链：锁里再调
+            // 一次会等自己，直接卡死）。刷新是两处目录读，本来也不必占着写锁。
+            return withWriteLock(async () => {
+                try {
+                    await writeJsonFile(hubPath(TOOL_TABLE_FILE), next);
+                }
+                catch (e) {
+                    return { ok: false, error: '设置保存失败: ' + message(e) };
+                }
+                toolTableCache = { at: Date.now(), value: next, off: new Set(next.hidden) };
+                return { ok: true };
+            });
+        }
+        /**
+         * 回给界面的同一份形状：当前名单 + 已存方案 + 出厂默认名单 + 体积报告。
+         *
+         * `defaultHidden` 单独回一份而不是塞进 `presets`：那条**不存在文件里**（它是代码里的
+         * `DEFAULT_HIDDEN_TOOLS`），写进文件就会出现"用户删不掉的一条数据"。界面把它排在最前、
+         * 不给删除键，词典出它的名字。
+         */
+        const toolTablePayload = (value) => ({
+            ok: true, hidden: value.hidden, presets: value.presets,
+            defaultHidden: [...DEFAULT_HIDDEN_TOOLS], report: toolTableReport(value.hidden),
+        });
+        /** 方案名：折叠空白 + 截到上限。空名由调用方报错（这里不猜"用户想叫什么"）。 */
+        const presetNameOf = (raw) => String(raw ?? '').replaceAll(/\s+/g, ' ').trim().slice(0, PRESET_NAME_MAX_LENGTH);
+        async function toolTableOp(args) {
+            const current = await readToolTableSettings();
+            if (!args || args.set !== true) {
+                // 存 / 删方案都不动 `hidden`，所以这两条路**不**重排可见性、也不刷目录（那是 `set`
+                // 那一条才有的三处联动）。失败原因回 `code` 不回中文串 —— 英文界面会原样露出中文。
+                if (args && args.presetSave !== undefined) {
+                    const name = presetNameOf(args.presetSave);
+                    if (name === '')
+                        return { ok: false, code: 'nameEmpty' };
+                    const added = addPreset(current, name, current.hidden);
+                    // 同名不覆盖（用户裁定）：撞名要用户换个名字，而不是悄悄改掉已有那份。
+                    if (added.exists)
+                        return { ok: false, code: 'nameTaken', name };
+                    if (current.presets.length >= PRESET_MAX_COUNT) {
+                        return { ok: false, code: 'limit', limit: PRESET_MAX_COUNT };
+                    }
+                    const saved = await writeToolTableSettings(added.settings);
+                    if (!saved.ok)
+                        return saved;
+                    return toolTablePayload(added.settings);
+                }
+                if (args && args.presetDelete !== undefined) {
+                    const name = presetNameOf(args.presetDelete);
+                    const dropped = dropPreset(current, name);
+                    if (!dropped.changed)
+                        return { ok: false, code: 'notFound', name };
+                    const saved = await writeToolTableSettings(dropped.settings);
+                    if (!saved.ok)
+                        return saved;
+                    return toolTablePayload(dropped.settings);
+                }
+                return toolTablePayload(current);
+            }
+            // 只收**已注册**的名字：写进来的陌生名字在下一次 restrict 时会让官方抛错
+            // （"names unknown global tool"）。注册失败的工具本来也不在表里。
+            const hidden = normalizeToolTableSettings({ hidden: args.hidden }).hidden
+                .filter((name) => toolTableSizes.has(name));
+            const next = { hidden, presets: current.presets };
+            const saved = await writeToolTableSettings(next);
+            if (!saved.ok)
+                return saved;
+            // 三处跟着变：可见性（restrict 名单重排）、两个目录（截断提示里点名的工具可能没了）。
+            // 目录的 refresh 会把新的一句话注入出去 —— 内容变了才重发，这是正确行为。
+            mcp.scheduleToolRestrictions();
+            await Promise.all([
+                skillCatalog.refresh().catch(() => { }),
+                subagentCatalog.refresh().catch(() => { }),
+            ]);
+            return toolTablePayload(next);
+        }
+        // ---------- 「有官方等价物 ⇒ 我们让位」----------
+        // 官方 `skill` 工具（`@deepseek-ai/dsh-tool-skill`）与我们的 `skill_manager_read` 是同一
+        // 件事：按名字给正文。标准类预设下它在场，第二份就是白付的 174 tok/轮。
+        //
+        // 判据抄官方自己的写法（`dsh-tool-skill/lib/index.js:207`：`ctx.tools.get(skillTool.name,
+        // agent) === skillTool`）—— 拿 agent 当 scope 问"这个 agent 解析得到 `skill` 吗"。比读
+        // 预设组合文件更准：它观察的是**这个 agent 实际能看见什么**（限定到该 scope 的同名 shadow
+        // 也算数），而组合文件只能说"配了"。判不出来时返回空 = 不让位：少一条拿正文的路，比多花
+        // 174 tok 糟。
+        //
+        // 与注入侧的关系：那边（`CARRIER_FACT_OF`）按组合事实决定"官方目录在场就不注入我们的
+        // 目录"，这边按解析结果决定"官方加载器在场就不下发我们的加载器"。两者只在一种情形下
+        // 不一致 —— 组合里挂了、但这个 agent 的 scope 里解析不到（被别的限制摘掉）：那时注入侧
+        // 跳过我们的目录，这里仍然保留我们的工具，方向是对的（模型手里还有 list + read）。
+        /** `[官方工具名, 我们该让位的工具]` —— 只有技能这一对（官方没有 MCP 管理 / 记忆 / AGENTS 编辑工具）。 */
+        const CARRIER_DUPLICATES = [['skill', 'skill_manager_read']];
+        const carrierHiddenToolsFor = async (agent) => {
+            // 拿不到 agent 就什么都不让位：`get(name, undefined)` 问的是**全局视图**，而官方那些
+            // 工具是按预设挂进 agent 那一层的 —— 问错对象会得出相反的结论。
+            if (agent === null || (typeof agent !== 'object' && typeof agent !== 'function'))
+                return [];
+            const scope = agent;
+            const out = [];
+            for (const [carrier, ours] of CARRIER_DUPLICATES) {
+                try {
+                    if (tools.get(carrier, scope) !== undefined)
+                        out.push(ours);
+                }
+                catch { /* 读不到 = 不让位 */ }
+            }
+            return out;
+        };
+        // ---------- 注入通道（场景 / 记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
         // 这些文本以前是 systemPrompt 段（persona complete 会整段压掉）。现在改走官方的
         // 「每步注入一条合成消息」通道（skill-catalog / AGENTS.md / 时间上下文同款）：
         // 任何预设都到得了，内容没变不重发。**每个域一条自己的消息**（来源 kind 各不同，
@@ -516,6 +708,8 @@ export default {
         const subagentCatalog = createSubagentCatalog({
             list: () => subagentService.list(),
             sceneLists: subagentSceneLists,
+            // 人在「兼容」页把 `subagent_manager_list` 关掉后，截断提示里那句「用 X 查」就是假的。
+            listToolVisible: () => !toolTableHidden().has('subagent_manager_list'),
         });
         // ⚠️ 取数必须用 mcpmRowsWithNotes(false)：true 会带上**未打码**的 url/headers/env（含明文密钥）。
         // 技能目录与提示词两个域是**官方载体的兜底**：预设挂得到官方
@@ -523,6 +717,7 @@ export default {
         // CARRIER_FACT_OF），挂不到（极简）时才由这里送 —— 所以极简下也能按开关决定要不要。
         const skillCatalog = createSkillCatalog({
             state: () => skillsService.ops['skill-state']({}),
+            listToolVisible: () => !toolTableHidden().has('skill_manager_list'),
         });
         // 注入设置（侧车 `inject-settings.json`，界面在「兼容」页）：
         //   - underSuppressingPresets：压制型预设（persona complete / 关运行时上下文，如极简）
@@ -574,6 +769,40 @@ export default {
                 return { ok: true, settings: next };
             });
         }
+        // 场景页的界面设置（侧车 `scene-settings.json`）：目前只有一项 —— 进入场景前要不要先弹
+        // 那张「会改什么」的卡。它纯粹是界面提示，所以**不进场景冻结**（锁着场景的人在场景页
+        // 照样能关掉提醒，那与五个管理域的只读无关）。
+        const SCENE_SETTINGS_FILE = 'scene-settings.json';
+        const SCENE_SETTINGS_TTL_MS = 3000;
+        let sceneSettingsCache = null;
+        async function readSceneSettings(force = false) {
+            if (sceneSettingsCache && !force && Date.now() - sceneSettingsCache.at < SCENE_SETTINGS_TTL_MS)
+                return sceneSettingsCache.value;
+            await ensurePaths();
+            const raw = await readJsonFile(hubPath(SCENE_SETTINGS_FILE));
+            const value = normalizeSceneSettings(raw);
+            sceneSettingsCache = { at: Date.now(), value };
+            return value;
+        }
+        async function sceneSettingsOp(args) {
+            const current = await readSceneSettings();
+            if (!args || args.set !== true)
+                return { ok: true, settings: current };
+            const next = normalizeSceneSettings({
+                enterPreview: typeof args.enterPreview === 'boolean' ? args.enterPreview : current.enterPreview,
+            });
+            await ensurePaths();
+            return withWriteLock(async () => {
+                try {
+                    await writeJsonFile(hubPath(SCENE_SETTINGS_FILE), next);
+                }
+                catch (e) {
+                    return { ok: false, error: '设置保存失败: ' + message(e) };
+                }
+                sceneSettingsCache = { at: Date.now(), value: next };
+                return { ok: true, settings: next };
+            });
+        }
         // 注入实况（只读诊断）：注入器的 live() 读回"最近活跃会话"可见表面上的五域文本。
         // 挂在 apply 作用域：`injection-live` op 与注入器不在同一层（effect 内部）。
         let contextInjectorLive = null;
@@ -596,16 +825,21 @@ export default {
                     // `catalogDepth` 字段的注释。目录正文也按同一个判据过滤（`text(agent)`），两处同源
                     // 所以不会分叉。
                     //
-                    // 记忆域（2026-09-17 用户裁定）：**只在顶层注入**。记忆是"父会话的现场"，不是子代理
-                    // 完成任务所需的事实 —— 而且它带着「一律照办，覆盖你的默认做法」这种强主张，塞进
-                    // 一次性子会话只会与角色定义争注意力（实测：子代理跑审查时，上下文里同时躺着人设与
-                    // 整份场景记忆）。子代理手里有 `memory_manager_list/read`，需要什么自己取；父代理
-                    // 上下文里也有记忆，相关事实应当由它写进 `task`（子代理的上下文 = 角色 + 任务）。
+                    // 场景与记忆（2026-09-17 用户裁定；2026-09-23 拆成两个域）：**都只在顶层注入**。
+                    // 记忆是"父会话的现场"，不是子代理完成任务所需的事实 —— 塞进一次性子会话只会与
+                    // 角色定义争注意力（实测：子代理跑审查时，上下文里同时躺着人设与整份记忆）。
+                    // 场景段同理：它说的是"父会话现在处在哪个模式"，而子代理根本没有"模式"可言。
+                    // 子代理手里有 `memory_manager_list/read` 与 `scene_manager_save`，需要什么自己取；
+                    // 父代理上下文里也有，相关事实应当由它写进 `task`（子代理的上下文 = 角色 + 任务）。
                     // 其余三域对任何深度都成立：提示词是用户规则（本插件的立身之本就是"覆盖到子代理"）、
                     // 技能目录与 MCP 状态是"操作这台机器所需的事实"（子代理手里就有 `skill` / `mcp__*`
                     // 工具，不知道清单就只能瞎调）。
                     domains: () => [
-                        { key: 'memory', name: 'tool-management:scene-memory', label: '场景和记忆', form: 'snapshot', text: () => memoriesService.memoryText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
+                        // 场景（**框架**）：启用的场景 + 场景说明（用户的约定）。排第一 —— 先让模型知道
+                        // "现在在哪个场景、这个场景的约定是什么"，再读下面的记忆条目。
+                        { key: 'scene', name: 'tool-management:scene', label: '场景', form: 'snapshot', text: () => memoriesService.sceneCatalogText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
+                        // 记忆（**内容**）：各场景下的条目。与场景段同源、同一条 `applicableTo`。
+                        { key: 'memory', name: 'tool-management:memory', label: '记忆', form: 'snapshot', text: () => memoriesService.memoryText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
                         { key: 'mcp', name: 'tool-management:mcp-state', label: 'MCP 服务器', form: 'catalog', text: () => mcp.stateCatalog.text() },
                         { key: 'skills', name: 'tool-management:skill-catalog', label: '技能目录', form: 'catalog', text: () => skillCatalog.text() },
                         {
@@ -619,6 +853,8 @@ export default {
                         { key: 'prompt', name: 'tool-management:prompt', label: '提示词', form: 'instructions', text: () => memoriesService.promptText(), files: () => memoriesService.promptFiles() },
                     ],
                     settings: () => injectSettingsSync(),
+                    // 工具表开关：`how` 行里点名工具的那几句要跟着它换话术（关掉的不点名）。
+                    hiddenTools: toolTableHidden,
                     factsFor: (agent) => candidates.presetFactsForAgent(agent),
                     // 令牌门禁（2026-09-19，用户裁定「宿主侧硬拦截」）：令牌**在生效**（`TOKEN !== ''`，
                     // 关掉或没配都是空串）而本次启动还没有人验过 ⇒ 这一步不放行，宿主把 turn 收成
@@ -1417,6 +1653,12 @@ export default {
             writePatch,
             memoriesService,
             wait,
+            // 兼容页「模型工具表」关掉的工具与 MCP 停用工具**合并成一次 restrict**：官方
+            // `tools.restrict()` 是"每个 scope 一层限制"，两边各调一次会互相覆盖（后一层赢）。
+            // 名单的合法性（只含已注册工具）由 manager 那边与 schemas() 求交后保证。
+            pluginHiddenTools: () => [...toolTableHidden()],
+            // 有官方等价物时逐 agent 让位（见上面 CARRIER_DUPLICATES 的注释）。
+            carrierHiddenTools: carrierHiddenToolsFor,
         });
         // ---------- ops ----------
         async function pluginVersion() {
@@ -1511,6 +1753,25 @@ export default {
             memoriesService,
             toolKeyParts,
         });
+        // 提示词预设域的 op 表。单独提出来是为了让**模型工具**能复用同一份判定：
+        // `prompt_manager_list` 以前直调 `promptsService.list()`，于是它报的「生效中」是
+        // **文件比对**口径（预设正文 == ~/.dsh/AGENTS.md），而界面报的是 `agentsmd-list` 的口径
+        // （启用的场景绑了预设时，**只有那份**算生效中）—— 同一件事两个答案，场景驱动时工具就在
+        // 说假话。工具改走 op 之后两边只有一份判定。
+        const promptOps = buildPromptOps({
+            promptsService,
+            scenePromptSync,
+            // 显式转发而不是整表传入：这两个 op 名字写死在这里，rules 域哪天改名会立刻红，
+            // 不会静默变成 undefined 调用。
+            rulesOps: {
+                'rules-list': (args) => memoriesService.ops['rules-list'](args),
+                'rules-rebind-prompt': (args) => memoriesService.ops['rules-rebind-prompt'](args),
+            },
+            applyPresetGuarded,
+            withAgentsMdSync,
+            promptRefReason,
+            warn: (m) => { ctx.logger?.warn?.(m); },
+        });
         const handlers = {
             'plugin-version': pluginVersion,
             'skill-open': skillOpen,
@@ -1544,6 +1805,8 @@ export default {
                 tools,
                 readInjectSettings,
                 injectSettingsOp,
+                toolTableOp,
+                toolTableReport: () => toolTableReport(),
                 presetRoster: candidates.presetRoster,
                 listPatchBackups,
                 cleanPatchBackups,
@@ -1556,23 +1819,8 @@ export default {
                 message,
                 compatLog,
             }),
-            // AGENTS.md / 提示词预设域（ops/prompts.ts 提供）：agentsmd-list / read / create /
-            // update / apply / get-current / remove / import / trash-list / trash-restore /
-            // trash-delete。
-            ...buildPromptOps({
-                promptsService,
-                scenePromptSync,
-                // 显式转发而不是整表传入：这两个 op 名字写死在这里，rules 域哪天改名会立刻红，
-                // 不会静默变成 undefined 调用。
-                rulesOps: {
-                    'rules-list': (args) => memoriesService.ops['rules-list'](args),
-                    'rules-rebind-prompt': (args) => memoriesService.ops['rules-rebind-prompt'](args),
-                },
-                applyPresetGuarded,
-                withAgentsMdSync,
-                promptRefReason,
-                warn: (m) => { ctx.logger?.warn?.(m); },
-            }),
+            // AGENTS.md / 提示词预设域（ops/prompts.ts 提供，见上方 promptOps）。
+            ...promptOps,
             // 归档会话域（ops/history.ts 提供）：history-list / history-sessions /
             // history-export-defaults / dir-list / history-archive / history-archive-batch /
             // history-unarchive / history-delete / history-unarchive-batch / history-delete-batch /
@@ -1612,6 +1860,7 @@ export default {
             ...buildCandidateOps({
                 presetToolCandidates: candidates.presetToolCandidates,
                 modelCandidates: candidates.modelCandidates,
+                modelReasoning: candidates.modelReasoning,
                 getToolFailures: () => subagentToolFailures,
                 mcpmListView: mcp.mcpmListView,
                 toolStates: candidates.toolStates,
@@ -1622,6 +1871,51 @@ export default {
                 memorySceneCandidates: candidates.memorySceneCandidates,
                 memoryCandidates: candidates.memoryCandidates,
             }),
+            // 场景页的界面设置（读 / 写）：进入场景前要不要弹预览卡。按写操作门禁（它写侧车），
+            // 但**不进场景冻结** —— 它是界面提示，与五个管理域的只读无关（见 scene-settings.ts）。
+            'scene-settings': (args) => sceneSettingsOp(args),
+            // state-doctor：跨域**悬空引用**体检（只读，实现与理由见 src/ops/state-doctor.ts）。
+            // 这里只做"把权威集合取来"这一件事 —— 某一域读失败就传 null，体检会把它记进
+            // `skipped` 而不是当成"该域没有悬空项"（读不到 ≠ 不存在，报成后者就是骗人）。
+            'state-doctor': async () => {
+                const stateDir = String(config?.memoriesStateDir || '');
+                const safe = async (read) => {
+                    try {
+                        return await read();
+                    }
+                    catch {
+                        return null;
+                    }
+                };
+                const report = await runStateDoctor({
+                    index: () => readIndexSync(stateDir),
+                    presetIds: async () => {
+                        const r = await safe(async () => promptsService.list());
+                        return r && r.ok ? r.presets.map((p) => p.id) : null;
+                    },
+                    serverNames: async () => {
+                        const r = await safe(mcp.mcpmListView);
+                        if (!r)
+                            return null;
+                        const out = [];
+                        for (const row of (r.rows || [])) {
+                            const n = String((row && row.serverName) || '');
+                            if (n && out.indexOf(n) < 0)
+                                out.push(n);
+                        }
+                        return out;
+                    },
+                    skillKeys: async () => {
+                        const r = await safe(skillStates);
+                        return r === null ? null : new Set(Object.keys(r));
+                    },
+                    personaNames: async () => {
+                        const r = await safe(() => subagentService.list());
+                        return r === null ? null : new Set(r.map((p) => p.name));
+                    },
+                });
+                return { ok: true, ...report };
+            },
         };
         // MCP 写操作成功后立即重算状态段（SWR：text() 同步返回缓存值，写后主动 refresh）。
         // 覆盖所有会改变「哪些 server 可用 / 有哪些备注」的写入口 —— 集中在这一处包，
@@ -1965,6 +2259,33 @@ export default {
             syncSwitchToScene,
             subagentToolFailures,
         });
+        // A1 的"机器那一边"：拿**真实** op 表与 `./op-registry.ts` 对账，四个方向都查（未归类 /
+        // 幽灵条目 / serviceWrite 与 service 自报分叉 / 只读与写自相矛盾）。
+        // 为什么值得在启动期花这一次遍历：门禁失守的症状从来不是报错，而是"没配令牌也能写"或
+        // "锁定的场景能被改"（0.6.0 / 0.7.0 / 0.10.0 已失守四次）。少一个 op 没登记，这里当场
+        // 在兼容页挂一条降级，而不是等到出事再倒查。
+        {
+            const problems = auditProblems(auditOpRegistry(Object.keys(handlers), [
+                ...skillsService.writeOps,
+                ...memoriesService.writeOps,
+                ...archiveService.writeOps,
+                ...subagentService.writeOps,
+            ]));
+            if (problems.length) {
+                ctx.logger?.warn?.(`op 登记表与实际 op 表对不上（${problems.length} 处）：${problems.join('；')}`);
+                noteRuntime({
+                    id: 'op-registry',
+                    label: 'op 门禁登记表对账',
+                    kind: 'read',
+                    fallback: 'inform-only',
+                    detail: `${problems.length} 处对不上：${problems.slice(0, 6).join('；')}${problems.length > 6 ? ' 等' : ''}`
+                        + ' —— 未归类的 op 不受写门禁与场景冻结约束。修法：在 src/op-registry.ts 补登记那一条。',
+                });
+            }
+            else {
+                clearRuntimeNote('op-registry');
+            }
+        }
         // ---------- agent-facing tools (standard ctx.tools.register + defineTool) ----------
         const text = (value) => [{ type: 'text', text: value }];
         /**
@@ -2012,9 +2333,13 @@ export default {
         // 各域必须用它，直接 import 宿主的那个会丢掉采纳统计。
         const toolDeps = {
             defineTool,
-            register: (def) => { tools.register(def); },
+            // 量体积只认**注册成功**的那些（注册失败的域工具本来就不在模型工具表里）——
+            // 兼容页「模型工具表」块的分组与 ≈token 都取自这里，那是这份设置唯一的数字来源。
+            register: (def) => { recordToolSize(def); tools.register(def); },
             lockedSceneGuard,
             syncSwitchToScene,
+            // 错误句里点名工具前要先问一句（判据与两个目录的 `listToolVisible` 同一份缓存）。
+            toolVisible: (name) => !toolTableHidden().has(name),
             reachNoticeForAgent,
             presetRoster: candidates.presetRoster,
             injectNoticeOptions,
@@ -2023,13 +2348,38 @@ export default {
         buildMcpTools({
             ...toolDeps,
             mcpmListView: mcp.mcpmListView,
+            mcpmTools: mcp.ops['mcpm-tools'],
             mcpmSetEnabled: mcp.ops['mcpm-set-enabled'],
             mcpmRestart: mcp.ops['mcpm-restart'],
+            mcpmToolEnabled: mcp.ops['mcpm-tool-enabled'],
             mcpmAdd: mcp.ops['mcpm-add'],
+            mcpmEdit: mcp.ops['mcpm-edit'],
+            mcpmNote: mcp.ops['mcpm-note'],
+            // **故意不接 `mcpm-reveal`**：`mcp_manager_save` 的改分支用 `mcpmListView()` 的
+            // 打码视图填回省略字段，由 `mcpm-edit` 的 `resolveMaskedKv` / `resolveMaskedUrl`
+            // 还原真值 —— 那条路本来就是给"表单里出现打码值"设计的（界面编辑框预填的就是它）。
+            // 让模型驱动的工具在进程内读明文凭据，是另一条没人设计过、也没有测试覆盖的路径。
         });
         buildSkillTools({ ...toolDeps, skillsOps: skillsService.ops });
-        buildPromptTools({ ...toolDeps, promptsService, applyPresetGuarded, promptsDir });
+        // 传 op 表而不是 promptsService：「生效中」的判定只有 `agentsmd-list` 里有（场景绑定
+        // 的那份才算），直调服务会得到文件比对口径 —— 场景驱动时工具会报一个与界面不同的答案。
+        buildPromptTools({ ...toolDeps, promptOps, applyPresetGuarded, promptsDir });
         buildMemoryTools({ ...toolDeps, rulesOps: memoriesService.ops });
+        // 场景族（tools/scene.ts）：列场景与档案（`_list`）+ 建场景 / 写档案 / 绑提示词（`_save`）
+        // + 进入与退出（`_switch`）。
+        // 传**包装后**的 `archiveService.ops`：`scene-archive-save` 与 `scene-mode-set` 都在本文件
+        // 被包了一层（前者联动人设开关、后者带锁定守卫与目录重算），工具走同一条路才有同一套行为。
+        //
+        // `sceneActivate` 传的是 **handlers 表里那份**（`buildSceneSyncOps` 覆盖过的）：AGENTS.md
+        // 同步在包装里，直调 `memoriesService.ops['rules-set-active']` 会静默漏掉"把场景绑定的
+        // 预设正文写进 `~/.dsh/AGENTS.md`、退出时恢复基线"这一步。传 handlers 里那份而不是在这里
+        // 再包一次，是为了让工具与 HTTP API 共用同一个实现（不会各自漂移）。
+        buildSceneTools({
+            ...toolDeps,
+            rulesOps: memoriesService.ops,
+            archiveOps: archiveService.ops,
+            sceneActivate: (args) => handlers['rules-set-active'](args),
+        });
         buildSubagentTools({
             ...toolDeps,
             subagentService,
@@ -2045,12 +2395,28 @@ export default {
             // 在完全权限下的行为一致；探测实现与回归测试见 approval-policy.ts（必须 ctx.get('approval')，
             // 不能用 ctx.approval——inject 未声明该服务时 cordis 代理会抛 "cannot get property without inject"）。
             const CONFIRM_LABELS = {
-                skill_manager_create: '「新建技能」',
-                memory_manager_write: '「写入记忆」',
+                // 0.14.0 起 create 与 update 并成 save（标签取中性的「保存」：改一份已有技能时
+                // "新建"是句假话）。危险度不变 —— 两者都往 hub 落文件。
+                skill_manager_save: '「保存技能」',
+                // 0.14.0 起 write/update 并成一条 upsert，标签取中性的「保存记忆」：「写入」在改一条
+                // 已有记忆时是句假话（与同一轮修 `prompt_manager_list` 的「生效中」同一个口径）。
+                memory_manager_save: '「保存记忆」',
+                // 场景族的唯一写工具。无条件问（不设开关）—— 它改的是"进入这个场景时会切换哪些
+                // mcp / 技能 / 人设"，改错了影响的是用户切场景之后的**整个运行时环境**，而不是一次
+                // 输出。与 skill / subagent 的 save 同一档（都是"以后每次都按它来"的长期资产）。
+                scene_manager_save: '「保存场景」',
+                // 0.14.0 的边界是"启用与进入留在界面"，0.14.x 补上这条工具后它成为**改运行时**的那一条：
+                // 六处开关一起动 + 收窄注入 + 改写 AGENTS.md。危险度高于 `_save`（那个只写剧本），
+                // 所以门禁同档、不降。
+                scene_manager_switch: '「切换场景」',
                 subagent_manager_run: '「运行子代理」',
-                // 模型侧只有这一个工具能塞进任意 command/args（改命令的 mcpm-edit 不对外注册成工具），
-                // 所以门禁加在它这里就覆盖了整个模型可达面。
-                mcp_manager_add: '「新增 MCP 服务器」',
+                // 0.14.0 起 create 与 update 并成 save（标签取中性的「保存人设」：改一份已有文件时
+                // "新建"是句假话）。危险度不变 —— 两者都往 hub 里落/整份重写一份文件。
+                subagent_manager_save: '「保存人设」',
+                // 0.14.0 起 add 与 edit 并成 save，模型侧能塞进任意 command/args 的仍只有这一个工具
+                // —— 门禁挂在它上面即覆盖整个模型可达面。标签取中性的「保存」：改一台已有服务器
+                // （含改 URL / 命令）与新增一台是同一档危险度，但"新增"在改分支上是句假话。
+                mcp_manager_save: '「保存 MCP 服务器」',
             };
             const bypassedByFullAccess = (exec) => {
                 if (!isApprovalNever(ctx, exec))
@@ -2059,10 +2425,10 @@ export default {
                 pluginLog()('confirm-bypass', `完全权限（approval=never）：跳过${CONFIRM_LABELS[String(exec && exec.name)]}的确认，直接放行`).catch(() => { });
                 return true;
             };
-            // subagent_manager_run 的目标人设是否真实存在。确认门是「问用户要不要做」，如果这个请求
-            // 本来就做不成（人设不存在），弹卡 / 写 bypass 日志只会产生一次无效审批：
-            // 用户批准之后模型收到的是「人设不可用」。所以先校验，再决定要不要问。
-            // 校验本身不可用时返回 true（保持原行为，绝不因为探测失败而少问一次）。
+            // 确认门是「问用户要不要做」，如果这个请求本来就做不成，弹卡 / 写 bypass 日志只会产生
+            // 一次无效审批：用户批准之后模型收到的是「人设不可用」/「人设不存在」/「人设已存在」。
+            // 所以先校验，再决定要不要问。校验本身不可用时返回 true（保持原行为，
+            // 绝不因为探测失败而少问一次）。
             const subagentManagerRunTargetExists = async (exec) => {
                 try {
                     const name = String((exec && exec.arguments && exec.arguments.agent) || '').trim();
@@ -2082,37 +2448,117 @@ export default {
                     return next();
                 if (bypassedByFullAccess(exec))
                     return next();
-                if (exec.name === 'skill_manager_create') {
-                    return Promise.resolve({ kind: 'ask', reason: 'Create a new skill under ~/.dsh/tool-management/skills' });
+                if (exec.name === 'skill_manager_save') {
+                    // 卡是**执行前**弹的：此时工具还没读 `skill-state`，走建还是改还没判出来，
+                    // 所以 reason 只能取并集。0.14.0 起 create 与 update 并成一条 upsert。
+                    return Promise.resolve({ kind: 'ask', reason: 'Create or overwrite a skill under ~/.dsh/tool-management/skills' });
                 }
-                if (exec.name === 'mcp_manager_add') {
+                if (exec.name === 'mcp_manager_save') {
                     // 为什么必须问：stdio 服务器是宿主按你给的 command/args **spawn** 出来的进程
                     // （见 http-fence.ts 对 mcpm-add 的说明），且这条目会写进配置长期生效。
                     // 写一个技能文件都要问，注册一条能起进程的配置却直接放行，是门禁倒挂 ——
                     // 危险度与门禁强度必须同向。
                     // 卡里回显将执行的命令行：用户批准的是「跑这条命令」，不是「加一个服务器」。
+                    // 0.14.0 起 save 也覆盖"改一台已存在的服务器"，此时把**旧命令**一并摆出来：
+                    // 「把 `npx A` 改成 `npx B`」与「新增一台跑 `npx B` 的」是两件不同的事，
+                    // 只报新那句会让一次改命令看起来像新建。
                     const a = (exec && exec.arguments) || {};
+                    const server = String(a.server || '');
                     const transport = String(a.transport || '');
                     const cmd = [a.command, a.args]
                         .map((x) => String(x ?? '').trim())
                         .filter((x) => x !== '')
                         .join(' ');
-                    const detail = transport === 'stdio'
+                    // 新 URL 走打码形态：查询串里的凭据不该明文进确认卡（与列表视图同一份实现）。
+                    // 旧 URL 已经是打码的 —— 它来自列表视图。
+                    const nextLine = transport === 'stdio'
                         ? (cmd ? `stdio command: ${cmd}` : 'stdio command: (empty)')
-                        : `${transport || 'streamable-http'} url: ${String(a.url || '(empty)')}`;
+                        : `${transport || 'streamable-http'} url: ${String(maskUrlQuery(String(a.url || '')) || '(empty)')}`;
+                    let cur = null;
+                    try {
+                        const r = await mcp.mcpmListView();
+                        cur = ((r && r.rows) || []).find((x) => String(x.serverName) === server) || null;
+                    }
+                    catch { /* 拿不到现状就按"新增"的口径报：宁可少说一句，也不因此拦住操作 */ }
+                    let detail = nextLine;
+                    if (cur) {
+                        const curCmd = [cur.command, Array.isArray(cur.args) ? cur.args.join(' ') : cur.args]
+                            .map((x) => String(x ?? '').trim())
+                            .filter((x) => x !== '')
+                            .join(' ');
+                        const curLine = String(cur.transport) === 'stdio'
+                            ? `stdio command: ${curCmd || '(empty)'}`
+                            : `${String(cur.transport || 'streamable-http')} url: ${String(cur.url || '(empty)')}`;
+                        detail = `current — ${curLine}; new — ${nextLine}`;
+                    }
                     return Promise.resolve({
                         kind: 'ask',
-                        reason: `Add MCP server「${String(a.serverName || '')}」— ${detail}. A stdio server is spawned by the host and the entry persists in the config.`,
+                        reason: `${cur ? 'Update' : 'Add'} MCP server「${server}」— ${detail}. A stdio server is spawned by the host and the entry persists in the config.`,
                     });
                 }
-                if (exec.name === 'memory_manager_write') {
+                if (exec.name === 'memory_manager_save') {
                     // D2：模型写规则默认需确认；设置关闭后直接放行。ask 无应答者时降级为拒绝（fail-closed），
                     // 不在此处做任何兜底放行。
+                    // 0.14.0 起 write/update 并成一条 upsert，reason 必须同时覆盖两种可能：卡是**执行前**
+                    // 弹的，此时工具还没跑，走"建"还是"改"要读一次 `rules-list` 才知道。旧实现按工具名
+                    // 分叉出两句，合并后只能取并集 —— 不能只留 "write"，那会让一次覆盖已有内容的操作
+                    // 在卡上看起来像新建（危险度与门禁强度必须同向）。
+                    const what = 'Create or overwrite a memory under ~/.dsh/tool-management/memories';
                     return mcp.readPluginSettings()
-                        .then((s) => (s.requireConfirmForModelRuleWrite
-                        ? { kind: 'ask', reason: 'Write a memory under ~/.dsh/tool-management/memories' }
-                        : next()))
-                        .catch(() => ({ kind: 'ask', reason: 'Write a memory under ~/.dsh/tool-management/memories' }));
+                        .then((s) => (s.requireConfirmForModelRuleWrite ? { kind: 'ask', reason: what } : next()))
+                        .catch(() => ({ kind: 'ask', reason: what }));
+                }
+                if (exec.name === 'scene_manager_save') {
+                    // 与记忆 save 的区别：**不设开关**。记忆写入有 `requireConfirmForModelRuleWrite`
+                    // 可以放行，场景写入没有 —— 它改的是"用户切进这个场景之后，哪些 mcp / 技能 / 人设
+                    // 会开、其余全部关掉"，那是一次环境切换的剧本，不是一份可以事后改的文档。
+                    // 卡里回显场景名与这次要写的档案段（用户批准的是"这个场景进入时开这些"）。
+                    const a = (exec && exec.arguments) || {};
+                    const scene = String(a.scene || '');
+                    const secs = ['mcp', 'skills', 'subagents'].filter((k) => a[k] !== undefined);
+                    const detail = secs.length
+                        ? `archive sections: ${secs.join(', ')}`
+                        : 'record only (label / description / prompt)';
+                    return Promise.resolve({
+                        kind: 'ask',
+                        reason: `Save scene「${scene}」— ${detail}. Entering it switches on exactly what this scene lists and turns everything else off.`,
+                    });
+                }
+                if (exec.name === 'scene_manager_switch') {
+                    // 与 `scene_manager_save` 同一档（都无条件问），但**问的是另一件事**：
+                    // save 改的是"以后进这个场景会怎样"（一份剧本），switch 改的是**现在** ——
+                    // 六处开关一起动（MCP 服务器级/工具级、技能来源级/技能级、人设、备注覆盖），
+                    // 注入范围随之收窄，并且**改写 `~/.dsh/AGENTS.md`**（本插件唯一会动那个文件的
+                    // 动作，覆盖前 5 代备份）。危险度只高不低，所以门禁强度不降。
+                    // 卡里回显动作与目标场景：用户批准的是"现在就切到 X"，不是"改一下 X 的配置"。
+                    const a = (exec && exec.arguments) || {};
+                    const action = String(a.action || '');
+                    const scene = String(a.scene || '');
+                    const what = action === 'exit'
+                        ? 'Leave the current scene — restore the runtime switches and the AGENTS.md baseline saved on entry'
+                        : `Enter scene「${scene}」— apply its archive (everything it does not list goes off), narrow injection to its memories, and apply its bound prompt preset to AGENTS.md`;
+                    return Promise.resolve({ kind: 'ask', reason: what });
+                }
+                if (exec.name === 'subagent_manager_save') {
+                    // 与 `skill_manager_save` 完全对称：往 hub 里落一份新文件 / 整份重写一份现有文件。
+                    // 无条件问（不设开关）—— 人设是"以后每次委派都按它来"的长期资产，改错了影响的是
+                    // 后续所有子代理的行为，而不是一次输出。
+                    // 改分支尤其：`subagent-update` 走 serializePersona 整份重写，改名还会连带改
+                    // 场景档案里的绑定 —— 那是一次会影响环境配置的操作，不是一句文案修改。
+                    // 建还是改要读一次现状才知道（工具侧也是执行时才读），所以这里查一下名单：
+                    // 只报"新建"会让一次整份重写看起来像加了个文件，反过来也一样。
+                    const a = (exec && exec.arguments) || {};
+                    const name = String(a.name || '');
+                    let exists = false;
+                    try {
+                        const docs = await subagentService.list();
+                        exists = docs.some((p) => String(p && p.name) === name);
+                    }
+                    catch { /* 读不到现状就按"新建"的口径报：宁可少说一句，也不因此拦住操作 */ }
+                    const what = exists
+                        ? `Rewrite persona「${name}」${a.nextName ? ` and rename it to「${String(a.nextName)}」(scene-profile bindings follow the rename)` : ''}`
+                        : `Create persona「${name}」under ~/.dsh/tool-management/subagents`;
+                    return Promise.resolve({ kind: 'ask', reason: what });
                 }
                 // subagent_manager_run：子代理运行花真 token：默认确认（requireConfirmForModelSubagentRun !== false），可关。
                 // `inherit: true` 时子代理会读到本次会话已完成的对话 —— 卡里如实说明（用户批准的是
@@ -2161,6 +2607,11 @@ export default {
                     if (mcp.isToolDisabled(String((exec && exec.name) || ''))) {
                         return '该工具已在 MCP 管理页停用';
                     }
+                    // 兼容页关掉的工具：可见性半边（restrict）正常时模型根本看不到它，走到这里只有两种
+                    // 可能 —— 名字是猜的，或者可见性半边没生效（那条降级会上报）。执行侧一律拦住。
+                    if (toolTableHidden().has(String((exec && exec.name) || ''))) {
+                        return '该工具已在「兼容」页的模型工具表里关掉（要它先在那里打开）';
+                    }
                 }
                 catch (e) { /* fallthrough to allow */ }
                 return undefined;
@@ -2318,11 +2769,12 @@ export default {
                                 }
                             }
                             // 「读改写」两态 op：不带 `set:true` 时是**纯读**，与写门禁无关。
-                            // `inject-settings`（兼容页的「注入」块）与 `mcpm-settings`（MCP 页的轮询设置）
+                            // `inject-settings`（兼容页的「注入」块）、`tool-table`（同页的「模型工具表」）、
+                            // `scene-settings`（场景页的提醒开关）与 `mcpm-settings`（MCP 页的轮询设置）
                             // 都用同一个 op 承担读与写，于是整条 op 被列进 WRITE_OPS —— 读侧也一起被拦，
                             // 界面表现是"没填令牌时整块设置消失、填了还要刷新才出现"（2026-09-19 用户报的）。
                             // 判据是**这次调用要不要写**，不是 op 名在不在名单里。
-                            const readOnlyCall = (op === 'inject-settings' || op === 'mcpm-settings')
+                            const readOnlyCall = (op === 'inject-settings' || op === 'tool-table' || op === 'scene-settings' || op === 'mcpm-settings')
                                 && !(payload.args && payload.args.set === true);
                             if (TOKEN && WRITE_OPS.has(op) && !readOnlyCall && !tokenMatches(hdr('x-dsh-token'))) {
                                 // 文案与明文门禁同源（http-fence.ts），code 也统一 —— 界面据此在最右侧挂