dsh-plugin-tool-management 0.16.6 → 0.18.0

package/lib/index.js

@@ -18,8 +18,9 @@ import { createHistoryDomain } from './sessions/history.js';
 import { createSkillsService, pluginLog } from './skills/service.js';
 import { renameWithRetry } from './skills/core.js';
 import { createPromptsService } from './prompts/service.js';
+import { createQuickPromptsService } from './prompts/quick-service.js';
 import { isInsideRootResolved } from './paths.js';
-import { DEFAULT_PROFILE_NAME, PROFILE_CANDIDATES } from './host-names.js';
+import { DEFAULT_PROFILE_NAME, MCP_TOOL_PREFIX, PROFILE_CANDIDATES, serverNameCandidates, splitMcpToolName } from './host-names.js';
 import { createMemoriesService } from './memories/service.js';
 import { createArchiveEngine } from './memories/archive-engine.js';
 import { createSnapshotOps } from './ops/snapshot.js';
@@ -29,14 +30,19 @@ 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 { createContextInjector, subagentDepthOf, } from './context-inject.js';
 import { isApprovalNever } from './approval-policy.js';
-import { addPreset, buildToolTableReport, DEFAULT_HIDDEN_TOOLS, dropPreset, migrateLegacyToolNames, normalizeToolTableSettings, FACTORY_TOOL_TABLE_PRESET, PRESET_MAX_COUNT, PRESET_NAME_MAX_LENGTH, toolTableSettingsFrom, } from './tools/table.js';
-import { normalizeSceneSettings } from './scene-settings.js';
+import { DEFAULT_HIDDEN_TOOLS, FACTORY_TOOL_TABLE_PRESET, normalizeToolTableSettings, } from './tools/table.js';
+import { createToolTableSwitch } from './tool-table-switch.js';
+import { createSettingsSidecars } from './settings-sidecars.js';
+// 改名 / 进场景 / 存档案的联动（op 重包，2026-10-01 从本文件 apply 闭包整段抽出）。
+import { installSceneLinkage } from './scene-linkage.js';
+// 访问令牌的宿主侧配置读写（2026-10-01 从本文件 apply 闭包整段抽出，依赖显式传参）。
+import { createTokenConfig } from './token-config.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 { installHttpApi } from './http-api.js';
 import { createMcpManager } from './mcp/manager.js';
 // 确认卡回显"新 URL"时要打码（查询串里的凭据不该明文进卡片），口径与列表视图同一份实现。
 import { maskUrlQuery } from './mcp/secret-guard.js';
@@ -44,14 +50,15 @@ import { createCandidates } from './scenes/candidates.js';
 // 「已知工具」归一化与「当前可用工具数」原本定义在本文件（导出仅为测试接缝），
 // 2026-09-19 随 MCP 域搬进 ./mcp/manager.ts。这里保持原路径可导出，契约不变。
 export { normalizeKnownTools, countEnabledTools } from './mcp/manager.js';
-import { applyLoaderToken, applyLoaderTokenDisabled, buildLoaderOverrideEntry, readLoaderToken } from './mcp/loader-token.js';
 import { hubBackupDir, hubPath, migrateHubLayoutSync, relocateEntries } from './hub.js';
 // 分域的 HTTP ops（2026-09-19 从本文件 handlers 表抽出，依赖显式传参）。
 import { buildCompatOps } from './ops/compat.js';
 import { buildPromptOps } from './ops/prompts.js';
+import { buildQuickPromptOps } from './ops/quick-prompts.js';
 import { buildSessionOps } from './ops/sessions.js';
 // HTTP 请求准入与 handlers 后处理（2026-09-19 从本文件 apply 闭包抽出，依赖显式传参）。
-import { createAccessToken, createOpWhitelist, createSceneLock, installHandlerGuards } from './request-gate.js';
+import { createAccessToken, createFrozenGate, createOpWhitelist, createSceneLock, guardModelOp, guardModelOps, installHandlerGuards } from './request-gate.js';
+// `isReadCall` 随 HTTP 路由一起搬走了（写门禁与审计流水都读同一份登记表判据）。
 import { auditOpRegistry, auditProblems } from './op-registry.js';
 import { buildSceneSyncOps } from './ops/scene-sync.js';
 import { buildCandidateOps } from './ops/candidates.js';
@@ -205,6 +212,13 @@ export default {
                 return p.home + sep + 'AGENTS.md';
             },
         });
+        // ---------- 快捷提示词（hub/quick-prompts/）----------
+        // 与上面的预设库**两份存储**，不是同一份加个标记位：`list()` 只扫自己目录，所以快捷词
+        // 天然进不了「应用 / 场景绑定 / 注入 / 模型工具」这四条只认 hub/prompts/ 的路径。
+        // 理由见 ./prompts/quick-service.ts 头注。
+        const quickPromptsDir = hubPath('quick-prompts');
+        const quickPromptsService = createQuickPromptsService({ dir: quickPromptsDir });
+        const quickPromptOps = buildQuickPromptOps(quickPromptsService);
         // ---------- rules（规则/记忆，v0.4）----------
         // 记忆真源 $DSH_HOME/tool-management/memories/<场景>/<name>.md（仅用户级，D1）。
         // **场景是显式记录**（memories-index.json 的 scenes 切片）：含保留场景 `global`（界面「全局」，
@@ -221,23 +235,37 @@ export default {
             ...(Number.isFinite(Number(config?.rulesMaxBytes))
                 ? { maxBytes: Number(config.rulesMaxBytes) }
                 : {}),
+            // 全局 AGENTS.md 的**宿主实际读的那一份**（profile home 下，与上面 `getGlobalAgentsMdPath`
+            // 同源）。`readGlobalAgentsMdSync` 的去重/兜底必须读它 —— `resolveDshHome()` 是另一条
+            // 独立来源（见 `ensurePaths` 的注释「不合并是有意的」），两边不同时会取到另一个文件、
+            // 去重永远不相等 → 同一份预设正文注入两遍（审查 P2-19）。
+            // 惰性求值：`cached` 在下面的 path discovery 段才声明（`let`），而本箭头函数只在 op
+            // 被调用时才求值 —— 那时 `ensurePaths()` 早已跑过。外面这层 `try` 是防**将来**有人在
+            // apply 中途同步调用 memories op 那种时序（`let` 的 TDZ 会抛 ReferenceError）。
+            globalAgentsMdPath: () => {
+                try {
+                    const p = cached;
+                    if (!p)
+                        return null;
+                    const sep = p.home.indexOf('\\') >= 0 ? '\\' : '/';
+                    return p.home + sep + 'AGENTS.md';
+                }
+                catch {
+                    return null;
+                }
+            },
         });
         // 场景记忆段的注册/生命周期由下面的注入通道统一管（memoriesService.memoryText / promptText）。
         // ---------- 场景档案引擎（设计 §2）----------
         // deps 把既有写通道（MCP 单工具启停 / 技能启停）注入引擎；引擎自身串行，
         // 状态机与纯逻辑在 ./memories/archive*.ts。mcpmToolEnabled / readDisabledTools
         // 为函数声明（提升），此处引用安全。
-        const toolKeyParts = (toolName) => {
-            if (!toolName.startsWith('mcp__'))
-                return null;
-            const rest = toolName.slice(5);
-            const i = rest.indexOf('__');
-            if (i <= 0)
-                return null;
-            const server = rest.slice(0, i);
-            const tool = rest.slice(i + 2);
-            return server && tool ? { key: server + '/' + tool, server, tool } : null;
-        };
+        // MCP 工具全名 → `{ server, tool }`。**切分规则只有一套**：`splitMcpToolName`
+        // （`host-names.ts`），与执行侧守卫 `mcp.isToolDisabled` 走的是同一个函数（2026-09-30 审查 N1）。
+        // 这里只负责把**候选 serverName 集合**传进去 —— 集合不同是切分结论不同的另一个来源，
+        // 所以集合也用同一个 builder（`serverNameCandidates`）从**同一批表**（停用表 ∪ 已知工具缓存）
+        // 取并集，不在这里手写 `Object.keys`。
+        const toolKeyParts = (toolName, serverNames) => splitMcpToolName(toolName, serverNames);
         /**
          * 一次扫描同时给出三样东西（避免为了三份视图各扫一遍磁盘）：
          *  - `states`：**真实生效**的技能 `<rootKey>/<name>` → boolean；
@@ -336,33 +364,41 @@ export default {
             },
             applyToolTableHidden: applyToolTableHiddenNow,
             loadSlice: async () => ({ ...(await memoriesService.readArchiveSlice()) }),
-            saveSlice: (slice) => memoriesService.patchIndex(slice),
-            configuredServers: async () => {
-                const r = await mcp.mcpmListView();
-                const out = [];
-                for (const row of ((r && r.rows) || [])) {
-                    const n = String((row && row.serverName) || '');
-                    if (n && out.indexOf(n) < 0)
-                        out.push(n);
-                }
-                return out;
-            },
+            // `fields` 必须原样透传：它决定"本次只写哪几片"，是审查 P2-3 里防丢更新的关键。
+            saveSlice: (slice, fields) => memoriesService.patchIndex(slice, fields),
+            saveArchive: (scene, archive) => memoriesService.saveArchive(scene, archive),
+            // 与 `serverKnownTools` 用同一个出口：都是「补丁里配了哪些 serverName」。
+            // 早先这里走 `mcpmListView()` —— 那份会顺带枚举工具 schema 并回写「已知工具」缓存，
+            // 而档案引擎只要名字（2026-09-30 审查 N1 顺带收窄）。
+            configuredServers: () => mcp.configuredServerNames(),
             serverKnownTools: async () => {
                 const out = {};
                 const raw = await mcp.readDisabledTools();
                 for (const [server, list] of Object.entries(raw))
                     out[server] = list.filter((t) => t !== '*');
                 // 「已知工具」缓存：未运行服务器也能按最后见过的名单计算补集。
-                for (const [server, list] of Object.entries(await mcp.readKnownMcpTools())) {
+                const known = await mcp.readKnownMcpTools();
+                for (const [server, list] of Object.entries(known)) {
                     out[server] = [...new Set([...(out[server] || []), ...list.map((item) => item.name)])].sort();
                 }
+                // 候选集合必须在**往 out 里补 live 工具之前**取：补进去的键是从 schema 名切出来的，
+                // 拿它当候选就成了循环论证（切错了也照样"命中"）。
+                //
+                // 三个来源里，补丁那份（`configuredServerNames`）是唯一与切分结果无关的 —— 停用表的键
+                // 来自界面勾选、缓存键来自上一次切分，单靠它们会锁死错误结论（审查 N1 / R3）。
+                let configured = [];
+                try {
+                    configured = await mcp.configuredServerNames();
+                }
+                catch { /* 补丁读不到 → 退化为另两份 */ }
+                const serverNames = serverNameCandidates(configured, raw, known);
                 let schemas = [];
                 try {
                     schemas = await tools.schemas();
                 }
                 catch { /* 无 live 工具 → 仅停用表 + 缓存 */ }
                 for (const s of schemas) {
-                    const p = toolKeyParts(String((s && s.name) || ''));
+                    const p = toolKeyParts(String((s && s.name) || ''), serverNames);
                     if (!p)
                         continue;
                     const list = out[p.server] || (out[p.server] = []);
@@ -530,6 +566,26 @@ export default {
                     await subagentService.enabledStore.setEnabled(on, true);
                 void subagentCatalog.refresh();
             },
+            // 快捷提示词（0.18.0）：档案定义了 quickPrompts 段时，进入场景 = 把每一条的开关置成
+            // 「在不在这份清单里」，退出按快照还原。读写的就是提示词页那颗开关的同一份存储
+            // （`hub/quick-prompts/<id>/meta.json`），不在别处再算一套状态。
+            knownQuickPrompts: async () => {
+                const r = await quickPromptsService.list();
+                return new Set(r.ok === true ? r.prompts.map((p) => p.id) : []);
+            },
+            quickPromptStates: async () => {
+                const r = await quickPromptsService.list();
+                if (r.ok !== true)
+                    throw new Error(r.error);
+                return Object.fromEntries(r.prompts.map((p) => [p.id, p.enabled !== false]));
+            },
+            applyQuickPromptSwitches: async (switches) => {
+                // 已不存在的 id 由 setEnabled 自己回 ok:false —— 这里**不**把它抛出去：退出场景时
+                // "还原一条已被删掉的快捷词"没有可写的地方，让它报错会把整次退出卡住
+                // （与 mcpServerRowsToRestore「现在已不存在的行直接跳过」同一口径）。
+                for (const s of switches)
+                    await quickPromptsService.setEnabled(s.id, s.enabled);
+            },
             // 记忆 id 全集。引擎已不消费（memories 段 P5 起废弃），实现保留以维持接口形状。
             knownMemoryIds: async () => {
                 const r = await memoriesService.ops['rules-list']({});
@@ -550,156 +606,20 @@ export default {
                 .filter((s) => s.active)
                 .map((s) => slice.archives[s.name]?.subagents ?? []);
         };
-        // ---------- 模型工具表开关（侧车 `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),
+        // ---------- 模型工具表开关（侧车 `tool-table.json`，界面在「兼容」页）→ ./tool-table-switch.ts ----------
+        // 那 134 行整段搬进同目录模块（侧车 TTL 缓存、三条写路径、`tool-table` op 正文），闭包名字
+        // 走 deps。工具体积表 toolTableSizes 按**同一个 Map 对象**交回来：注册口（defineTool 那层）
+        // 在外面写它、op 与场景写路径读它 —— 交回对象而不是复制，所以母文件这几处一个字都不用改。
+        // 这段仍然留在两个目录之前：目录里那句「用 `X` 查」的提示要读 toolTableHidden —— 搬走的是
+        // 这段的正文，不是这段的顺序（顺序就是依赖顺序）。
+        // mcp / skillCatalog / subagentCatalog 在本块之后才建，按 getter 交进去：取值发生在真正要
+        // 用的那一刻，与原闭包同形，既不撞 TDZ 也不动搬走的那些行。
+        const { toolTableSizes, recordToolSize, readToolTableSettings, toolTableHidden, writeToolTableSettings, toolTableReport, toolTableOp, } = createToolTableSwitch({
+            ensurePaths, readJsonFile, writeJsonFile, withWriteLock, message, EMPTY_TOOL_SET,
+            get mcp() { return mcp; },
+            get skillCatalog() { return skillCatalog; },
+            get subagentCatalog() { return subagentCatalog; },
         });
-        /** 方案名：折叠空白 + 截到上限。空名由调用方报错（这里不猜"用户想叫什么"）。 */
-        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/轮。
@@ -757,90 +677,16 @@ export default {
             state: () => skillsService.ops['skill-state']({}),
             listToolVisible: () => !toolTableHidden().has('skill_manager_list'),
         });
-        // 注入设置（侧车 `inject-settings.json`，界面在「兼容」页）：
-        //   - underSuppressingPresets：压制型预设（persona complete / 关运行时上下文，如极简）
-        //     下是否仍然注入。默认 false = 跟随预设。
-        //   - domains：各域开关（任何预设下都生效；界面五个勾选）。
-        // 注入器每个 step 都要同步读一次设置 → 走 TTL 缓存；未加载时先给默认值并异步预热。
-        const INJECT_SETTINGS_FILE = 'inject-settings.json';
-        const INJECT_SETTINGS_TTL_MS = 3000;
-        let injectSettingsCache = null;
-        async function readInjectSettings(force = false) {
-            if (injectSettingsCache && !force && Date.now() - injectSettingsCache.at < INJECT_SETTINGS_TTL_MS)
-                return injectSettingsCache.value;
-            await ensurePaths();
-            const raw = await readJsonFile(hubPath(INJECT_SETTINGS_FILE));
-            injectSettingsCache = { at: Date.now(), value: normalizeInjectSettings(raw) };
-            return injectSettingsCache.value;
-        }
-        /** 同步快照（注入器取用）；还没加载时先返回默认值，并顺手预热一次。 */
-        function injectSettingsSync() {
-            if (injectSettingsCache)
-                return injectSettingsCache.value;
-            void readInjectSettings().catch(() => { });
-            return DEFAULT_INJECT_SETTINGS;
-        }
-        /** 边界提示要的注入设置快照（总开关 + 各域开关）。 */
-        const injectNoticeOptions = () => {
-            const s = injectSettingsSync();
-            return { underSuppressingPresets: s.underSuppressingPresets, domains: s.domains };
-        };
-        async function injectSettingsOp(args) {
-            const current = await readInjectSettings();
-            if (!args || args.set !== true)
-                return { ok: true, settings: current };
-            const next = normalizeInjectSettings({
-                underSuppressingPresets: typeof args.underSuppressingPresets === 'boolean'
-                    ? args.underSuppressingPresets
-                    : current.underSuppressingPresets,
-                domains: { ...current.domains, ...(args.domains && typeof args.domains === 'object' ? args.domains : {}) },
-            });
-            await ensurePaths();
-            return withWriteLock(async () => {
-                try {
-                    await writeJsonFile(hubPath(INJECT_SETTINGS_FILE), next);
-                }
-                catch (e) {
-                    return { ok: false, error: '设置保存失败: ' + message(e) };
-                }
-                injectSettingsCache = { at: Date.now(), value: next };
-                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 };
-            });
-        }
+        // 三份界面设置侧车（inject / scene / slash）拆到 ./settings-sidecars.ts：读走 3 秒 TTL 缓存，
+        // 写共用上面那条串行写锁。工厂只在这里调用一次，三份缓存仍是「每次 apply 一份」。
+        // 传的是 apply 作用域里那几个函数声明的引用（提升已初始化），不是快照值。
+        const { readInjectSettings, injectSettingsSync, injectNoticeOptions, injectSettingsOp, readSceneSettings, sceneSettingsOp, readSlashSettings, slashSettingsOp, } = createSettingsSidecars({
+            ensurePaths,
+            readJsonFile,
+            writeJsonFile,
+            withWriteLock,
+            message,
+        });
         // 注入实况（只读诊断）：注入器的 live() 读回"最近活跃会话"可见表面上的各域文本。
         // 挂在 apply 作用域：`injection-live` op 与注入器不在同一层（effect 内部）。
         let contextInjectorLive = null;
@@ -929,6 +775,14 @@ export default {
             iso: new Date().toISOString(),
             version: PKG_VERSION,
             injects: [...INJECT_SERVICES],
+            // 宿主**进程身份**（2026-09-30 审查 §5 F1）：插件与宿主同进程，所以 `pid` 就是宿主的 pid，
+            // 而 `hostStartedAt` 是本进程的启动时刻（`Date.now() - uptime`）。有了这两个值，doctor
+            // 才能把「这份心跳是不是**这一轮**宿主写的」变成一条可计算的结论：
+            //   pid 已经不存在 → 宿主自那以后重启过（或那次运行已结束）；
+            //   pid 还在      → 心跳来自当前正在跑的宿主进程，插件这一轮**确实挂上了**。
+            // 此前只有时间戳，用户必须自己记得"我什么时候重启的"才能解读它。
+            pid: process.pid,
+            hostStartedAt: Date.now() - Math.round(process.uptime() * 1000),
         }).catch((e) => { ctx.logger?.warn?.('mount heartbeat write failed: ' + message(e)); });
         // B3 符号断言：probe.ts 的 unwrap 用硬编码的 `Symbol.for('cordis.original')`，与 cordis
         // 导出的 `symbols.original` 必须是同一个符号。不是的话，探针会把代理当原始对象、身份判定失真。
@@ -981,158 +835,18 @@ export default {
                 return result;
             };
         }
-        /**
-         * 人设改名后同步场景绑定：场景档案的 `subagents` 名单存的是**人设名**，
-         * 不跟着改就会留一个悬空引用（界面把它报成 stale，用户看到「人设不存在」却找不到地方改）。
-         * 绑定存在 memories-index.json 里，人设服务看不到它，所以在这一层补一次（同提示词改名的做法）。
-         */
-        async function rebindSubagentInArchives(from, to) {
-            try {
-                const slice = await memoriesService.readArchiveSlice();
-                const archives = { ...(slice.archives || {}) };
-                let changed = 0;
-                for (const [scene, archive] of Object.entries(archives)) {
-                    const list = archive.subagents;
-                    if (!Array.isArray(list) || !list.includes(from))
-                        continue;
-                    archives[scene] = { ...archive, subagents: list.map((n) => (n === from ? to : n)) };
-                    changed++;
-                }
-                if (changed)
-                    await memoriesService.patchIndex({ archives });
-                return changed;
-            }
-            catch {
-                return 0;
-            }
-        }
-        /**
-         * 人设改名后同步运行时快照（F-025）：退出还原按 `subagentsAll` 逐名走，快照里
-         * 还留着旧名的话，退出会「旧名静默跳过、新名不还原」—— 被改名的人设停留在
-         * 场景期间状态。快照在进入场景时拍、改名发生在进入后，只能在改名时跟着改。
-         */
-        async function renameSubagentInSnapshot(from, to) {
-            try {
-                const slice = await memoriesService.readArchiveSlice();
-                const mode = slice && slice.mode;
-                const snapshot = mode && mode.snapshot;
-                if (!snapshot)
-                    return;
-                let changed = false;
-                const next = { ...snapshot };
-                if (snapshot.subagentsAll && Object.prototype.hasOwnProperty.call(snapshot.subagentsAll, from)) {
-                    const all = {};
-                    for (const [k, v] of Object.entries(snapshot.subagentsAll)) {
-                        all[k === from ? to : k] = v;
-                        if (k === from)
-                            changed = true;
-                    }
-                    next.subagentsAll = all;
-                }
-                for (const field of ['subagents', 'subagentsOn']) {
-                    const list = snapshot[field];
-                    if (Array.isArray(list) && list.includes(from)) {
-                        next[field] = list.map((n) => (n === from ? to : n));
-                        changed = true;
-                    }
-                }
-                if (changed)
-                    await memoriesService.patchIndex({ mode: { ...mode, snapshot: next } });
-            }
-            catch { /* 快照同步失败不阻断改名本身；残留与修复前一致 */ }
-        }
-        const baseSubagentUpdate = subagentService.ops['subagent-update'];
-        if (typeof baseSubagentUpdate === 'function') {
-            subagentService.ops['subagent-update'] = async (args) => {
-                const res = await baseSubagentUpdate(args);
-                if (res && res.ok !== false && res.renamedFrom) {
-                    const from = String(res.renamedFrom);
-                    const to = String(res.name);
-                    void rebindSubagentInArchives(from, to);
-                    void renameSubagentInSnapshot(from, to);
-                }
-                return res;
-            };
-        }
-        // 模式切换会改人设开关（进入=启用勾选的，退出=按快照停回）——目录段立即重算，
-        // 别等 1s TTL：切完场景紧接着的下一轮请求就该看到新名单。
-        const baseSceneModeSet = archiveService.ops['scene-mode-set'];
-        if (typeof baseSceneModeSet === 'function') {
-            archiveService.ops['scene-mode-set'] = async (args) => {
-                // 锁定的场景不能关闭（用户裁定）：退出模式（scene=null）和切换到别的场景
-                // 都意味着先退出当前模式 —— 当前模式场景处于锁定状态时一律拒绝。
-                // 目标就是当前场景 = 无操作，放行（引擎自己会 early-return）。
-                try {
-                    const slice = await memoriesService.readArchiveSlice();
-                    const current = slice.mode && slice.mode.scene;
-                    if (current && args && 'scene' in (args || {})) {
-                        const target = args.scene == null ? null : String(args.scene).trim() || null;
-                        if (target !== current) {
-                            const locked = await lockedSceneNames();
-                            if (locked.includes(current)) {
-                                return { ok: false, error: `场景「${current}」已锁定：先解锁再关闭` };
-                            }
-                        }
-                    }
-                }
-                catch { /* 守卫读状态失败不拦正常流程（引擎自身校验兜底） */ }
-                const res = await baseSceneModeSet(args);
-                if (res && res.ok !== false) {
-                    // 进/退/切换模式会改 MCP 启停（服务器级）与备注（场景备注覆盖/恢复），
-                    // 状态段必须立即重算 —— 场景退出后下一次请求就该看到恢复的全局备注与启停。
-                    void subagentCatalog.refresh().catch(() => { });
-                    void mcp.stateCatalog.refresh().catch(() => { });
-                }
-                return res;
-            };
-        }
-        /**
-         * 模式进行中保存当前场景的档案时，联动人设开关：**档案 = 这个场景开着的人设**
-         * （与进入场景时同一口径，见 archive-engine）——
-         *   新勾进来的立即启用，并追加进快照的「退出时停回」名单；
-         *   取消勾选的立即停用；其中「进场景前就开着」的那些追加进快照的「退出时开回」名单
-         *   （在停回名单里的说明是本次进场景才打开的，退出本来就该关，不进开回名单）。
-         */
-        const baseSceneArchiveSave = archiveService.ops['scene-archive-save'];
-        if (typeof baseSceneArchiveSave === 'function') {
-            archiveService.ops['scene-archive-save'] = async (args) => {
-                const res = await baseSceneArchiveSave(args);
-                try {
-                    const bound = res && res.ok !== false && res.archive && Array.isArray(res.archive.subagents) ? res.archive.subagents : [];
-                    const slice = await memoriesService.readArchiveSlice();
-                    const mode = slice.mode;
-                    if (mode && mode.scene === res.scene) {
-                        const every = (await subagentService.list()).map((p) => p.name);
-                        const unbound = every.filter((n) => bound.indexOf(n) < 0);
-                        const toOn = await subagentService.enabledStore.disabledAmong(bound);
-                        const toOff = await subagentService.enabledStore.enabledAmong(unbound);
-                        if (toOn.length)
-                            await subagentService.enabledStore.setEnabled(toOn, true);
-                        if (toOff.length)
-                            await subagentService.enabledStore.setEnabled(toOff, false);
-                        if (toOn.length || toOff.length)
-                            void subagentCatalog.refresh();
-                        const snapshot = mode.snapshot;
-                        // 新快照带**全量映射**（`subagentsAll`，v0.9.1）→ 退出按映射逐个精确还原，这两个
-                        // 部分名单不再需要，也不再往新快照里写（老快照没有映射，仍然照旧维护，见
-                        // archive-engine 的 restoreSnapshot 兼容分支）。
-                        if (snapshot && !snapshot.subagentsAll && (toOn.length || toOff.length)) {
-                            const backOn = Array.isArray(snapshot.subagents) ? snapshot.subagents.slice() : [];
-                            const offList = Array.isArray(snapshot.subagentsOn) ? snapshot.subagentsOn.slice() : [];
-                            for (const n of toOn)
-                                if (backOn.indexOf(n) < 0)
-                                    backOn.push(n);
-                            for (const n of toOff)
-                                if (backOn.indexOf(n) < 0 && offList.indexOf(n) < 0)
-                                    offList.push(n);
-                            await memoriesService.patchIndex({ mode: { ...mode, snapshot: { ...snapshot, subagents: backOn, subagentsOn: offList } } });
-                        }
-                    }
-                }
-                catch { /* 联动失败不阻断档案保存本身；开关会在下次进/退模式时对齐 */ }
-                return res;
-            };
-        }
+        // ---------- 改名 / 进场景 / 存档案的联动（op 重包） ----------
+        // 正文 2026-10-01 整段搬到 ./scene-linkage.ts（一字未改，只把七个 apply 作用域名字改走
+        // deps）。调用点位置原样不动 —— 重包的是那四个 service 对象上的 ops 表，而下游（handlers
+        // 表、工具依赖表）取的是**当时那份函数**：包晚了，联动对它们就不存在。
+        // 两个**定义在本调用之后**的名字用 getter 传：`mcp` 在 MCP 管理域那一段才建、
+        // `lockedSceneNames` 在场景锁那一层才解构 —— 直接放进对象字面量会当场踩 TDZ，
+        // 而取用它们的时机是请求期，那时两个 const 都已初始化完。
+        installSceneLinkage({
+            memoriesService, subagentService, archiveService, quickPromptOps, subagentCatalog,
+            get mcp() { return mcp; },
+            get lockedSceneNames() { return lockedSceneNames; },
+        });
         // HTTP 写 / 敏感 op 白名单（2026-09-19 抽到 ./request-gate.ts）：四个 service 自报的
         // writeOps，加上本文件内联域（mcpm-* / skill-open / agentsmd-* / history-*）。
         const { WRITE_OPS, SENSITIVE_OPS } = createOpWhitelist({
@@ -1376,10 +1090,22 @@ export default {
         // learned this the hard way: a bad edit to cordis.patch.yml can stop DSH
         // from booting, so the pre-write file must stay recoverable without git.
         const KEEP_PATCH_BACKUPS = 5;
+        /**
+         * 备份名里的时间戳：**到毫秒 + 进程内序号**（定宽）。
+         *
+         * 为什么不能只到秒（2026-09-30 审查 P2-5）：同一次操作里常常连写两遍补丁（`mcpm-set-enabled`
+         * 的强制写 + 恢复写、整理补丁的批量写），两次落在同一秒时**后一份备份会覆盖前一份** ——
+         * `KEEP_PATCH_BACKUPS=5` 于是不是"留 5 个历史状态"而是"留 5 个秒"，最坏情况下唯一能回滚的
+         * 中间副本被挤掉。序号保证同一毫秒内也不撞名。
+         *
+         * 两段都是**定宽**，所以按名字排序仍然等于按时间排序（`listPatchBackups` 的剪枝依赖这一点）。
+         */
+        let backupSeq = 0;
         function backupStamp() {
             const d = new Date();
-            const p = (n) => String(n).padStart(2, '0');
-            return '' + d.getFullYear() + p(d.getMonth() + 1) + p(d.getDate()) + '-' + p(d.getHours()) + p(d.getMinutes()) + p(d.getSeconds());
+            const p = (n, w = 2) => String(n).padStart(w, '0');
+            backupSeq = (backupSeq + 1) % 1000;
+            return '' + d.getFullYear() + p(d.getMonth() + 1) + p(d.getDate()) + '-' + p(d.getHours()) + p(d.getMinutes()) + p(d.getSeconds()) + p(d.getMilliseconds(), 3) + p(backupSeq, 3);
         }
         // 改 patch 前的自动备份：写在 `hub/backups/`（不再堆在 `$DSH_HOME` 根下）。
         // 两个 patch 都叫 `cordis.patch.yml`（全局 + `profiles/<名字>/`），所以备份名里带上层级，
@@ -1415,7 +1141,10 @@ export default {
          * 用它列目录会得到 0 份。它的用途是启动期搬运旧文件，语义不同，别混。
          */
         function isBackupFileName(name) {
-            return /^cordis\.patch\.yml(?:\.[A-Za-z0-9._-]+)?\.bak-\d{8}-\d{6}$/.test(basename(String(name || '')));
+            // 两代时间戳都认：老名字到秒（`\d{6}`），0.17.0 起加了毫秒与序号（共 `\d{12}`）。
+            // 只认新格式会让**存量备份**在清单与自动剪枝里集体消失 —— 它们既不再被剪掉，
+            // 也不再出现在「清理旧备份」里，等于把明文密钥副本永久留在盘上。
+            return /^cordis\.patch\.yml(?:\.[A-Za-z0-9._-]+)?\.bak-\d{8}-\d{6}(?:\d{6})?$/.test(basename(String(name || '')));
         }
         /**
          * 一份备份属于**哪一份 patch**（备份名里的层级标签）。
@@ -1562,207 +1291,15 @@ export default {
                 return { ...result, warning: result.warning + '；' + extra };
             return { ...result, warning: extra };
         }
-        /**
-         * 找到本插件 loader 行所在的补丁文件。返回 0 / 1 / 多份，多份时调用方必须拒绝自动改：
-         * 同一条 loader 行出现在两份补丁里会让宿主起不来（重复 id），与 duplicateGuard 同一口径。
-         */
-        async function loaderTokenFiles() {
-            const p = await ensurePaths();
-            const files = [];
-            const infoOf = new Map();
-            for (const abs of [p.projectPatch, p.globalPatch]) {
-                let content = '';
-                try {
-                    content = await readPatch(abs);
-                }
-                catch {
-                    continue;
-                }
-                const read = readLoaderToken(content);
-                if (read.found) {
-                    files.push(abs);
-                    infoOf.set(abs, { token: read.token, disabled: read.disabled });
-                }
-            }
-            // 0.1.7 bundle 挂载：loader 条目由插件包内的 cordis.patch.yml（bundle 层）提供，两份
-            // 补丁里都没有可就地改写的行。bundleBase 只回答「覆盖目标存在吗」—— 写点是 profile
-            // 补丁里的覆盖条目（见 tokenConfigure），bundle 文件本身永不落密钥。
-            let bundleBase = false;
-            try {
-                bundleBase = readLoaderToken(await readPatch(p.bundlePatch)).found;
-            }
-            catch {
-                bundleBase = false;
-            }
-            return { files, infoOf, bundleBase };
-        }
-        /**
-         * 配置**文件里**写了令牌，但当前进程还没生效（或反过来）—— 也就是"改了配置还没重启"。
-         * 界面据此把"重启后生效"说成事实而不是猜测。
-         *
-         * 局限（写下来免得当成 bug）：读不到环境变量，所以靠 `DSH_PLUGIN_TOOL_MANAGEMENT_TOKEN`
-         * 提供令牌时（文件里没有 token），这里会报"待重启"。那是保守方向 —— 环境变量改动同样要重启。
-         */
-        async function tokenConfigState() {
-            try {
-                const { files, infoOf } = await loaderTokenFiles();
-                if (files.length !== 1)
-                    return { found: false, configHasToken: false, configDisabled: false, pendingRestart: false };
-                const info = infoOf.get(files[0]) || { token: '', disabled: false };
-                const configHasToken = info.token !== '';
-                // 「文件里配的」与「当前进程在用的」是否一致 —— 比的是**生效**状态（有位子但关了 = 没生效）。
-                const fileEffective = configHasToken && !info.disabled;
-                return { found: true, configHasToken, configDisabled: info.disabled, pendingRestart: fileEffective !== (TOKEN !== '') };
-            }
-            catch {
-                return { found: false, configHasToken: false, configDisabled: false, pendingRestart: false };
-            }
-        }
-        /**
-         * 改宿主侧的令牌配置：`set` 写入 / 换掉令牌、`off` 关掉令牌功能、`on` 重新打开、
-         * `clear` 把令牌从配置里删掉（回到"还没有令牌"那一态）。
-         *
-         * 关键设计（用户裁定 2026-09-19）：
-         *   - **`off` 不再删除 `token`**，只写一行 `tokenDisabled: true` —— 原令牌保留，随时能开回来，
-         *     不需要重新输一遍（此前的实现把配置删了，用户想再开就得重新想一遍令牌）。
-         *   - **`clear` 才是"删掉"**（用户 2026-09-19 问"令牌没有彻底清除按钮"）：删 `config.token`
-         *     与 `tokenDisabled` 两行，回到从未设置过的样子 —— 写操作不再要凭证、明文密钥随之
-         *     不可见。它是不可逆的那一端（配置里没有副本了），所以与 `off` 共用同一条凭证口径。
-         *   - **`off` / `clear` 只认"当场再输一次"的令牌**（`value` 对得上才算）：请求头里那份已验过
-         *     的凭证不算数 —— 解锁之后顺手一点就能把防护关掉 / 把令牌删掉，等于没把守（用户裁定
-         *     2026-09-19：「就算输入过了令牌，关闭保护也应该再次输入令牌才能关闭」）。界面据此就地在
-         *     「保护开关」/「宿主配置」里展开一个确认框。
-         *   - **`set` 与 `off` / `clear` 同一条口径**：宿主已有令牌时，改令牌也必须当场再输一次当前
-         *     令牌（走 `current` 字段 —— `token` 里是新令牌，证明不了知道旧值；凭证是旧值这件事不能
-         *     靠请求头里那份"本次启动已解锁"顶替）。界面据此在「宿主配置」表单里多摆一栏「当前令牌」，
-         *     并且不再要求用户先解锁再改。
-         *   - **`on` 仍接受请求头里的凭证**（`presented`），或输入框里那个值本身就是当前令牌。
-         *     两个方向都必须验 —— 否则"能打开 GUI 就能关掉保护"，令牌等于白配（要求 9）。
-         *   - `set`：宿主**还没配**令牌时允许（首次设置 —— 否则这个功能永远打不开），那一态没有
-         *     "当前令牌"可证明，所以 `current` 不作要求。
-         *
-         * 不放进 handlers：这样它既不在 HTTP 的普通 op 面上，也**不会**被任何模型工具间接调用 ——
-         * 模型不该有能力关掉访问令牌。
-         */
-        async function tokenConfigure(args, presented) {
-            const raw = String((args && args.mode) || '');
-            const mode = raw === 'off' ? 'off' : raw === 'on' ? 'on' : raw === 'clear' ? 'clear' : 'set';
-            const value = String((args && args.token) || '').trim();
-            const currentRaw = String((args && args.current) || '').trim();
-            // 关闭 / 重新打开时，用户填进输入框的那个值**就是**当前令牌，可以直接当凭证 ——
-            // 省掉"先保存再操作"两步。`set` 不行：那个值是新令牌，不能拿它证明自己知道旧值，
-            // 所以它的凭证单独走 `current`。
-            const proofByValue = mode !== 'set' && value !== '' && CONFIG_TOKEN !== '' && tokenMatches(value);
-            const proofByCurrent = mode === 'set' && currentRaw !== '' && CONFIG_TOKEN !== '' && tokenMatches(currentRaw);
-            // 关闭保护 / 删除令牌 / 修改令牌都是"改凭证 / 减防护"的方向：**不认**请求头里已经验过的
-            // 那份凭证，必须当面再输一次当前令牌（用户裁定 2026-09-19 —— 先判「关闭」，随后同一口径
-            // 推到「修改」，再推到「删除」）。开启保护仍接受请求头里的凭证。
-            if (mode === 'off' && CONFIG_TOKEN !== '' && !proofByValue) {
-                return { ok: false, code: 'error.secret.badToken', error: '关闭保护要再输一次当前令牌。' };
-            }
-            if (mode === 'clear' && CONFIG_TOKEN !== '' && !proofByValue) {
-                return { ok: false, code: 'error.secret.badToken', error: '删除令牌要再输一次当前令牌。' };
-            }
-            if (mode === 'set' && CONFIG_TOKEN !== '' && !proofByCurrent) {
-                return { ok: false, code: 'error.secret.badToken', error: '修改令牌要先填一次当前令牌。' };
-            }
-            if (CONFIG_TOKEN !== '' && !presented && !proofByValue && !proofByCurrent) {
-                return { ok: false, code: 'error.secret.badToken', error: '要改动访问令牌，请先在「本次启动」里填入当前令牌并解锁。' };
-            }
-            if ((mode === 'off' || mode === 'clear') && CONFIG_TOKEN === '') {
-                return { ok: true, changed: false, note: '宿主侧本来就没有配置令牌。', restartRequired: false };
-            }
-            if (mode === 'on' && CONFIG_TOKEN === '') {
-                return { ok: false, error: '配置里没有令牌：请先用「设置令牌」写入一个，再打开令牌保护。' };
-            }
-            if (mode === 'set') {
-                if (!value)
-                    return { ok: false, error: '请先填入要设置的令牌' };
-                // 换行会写坏 YAML 标量、NUL 会截断路径 —— 这两类直接拒绝比转义更清楚。
-                if (/[\r\n\u0000]/.test(value))
-                    return { ok: false, error: '令牌不能包含换行或控制字符' };
-                if (value === CONFIG_TOKEN)
-                    return { ok: true, changed: false, note: '和当前令牌相同，未改动。', restartRequired: false };
-            }
-            const p = await ensurePaths();
-            const { files, bundleBase } = await loaderTokenFiles();
-            if (!files.length && !(mode === 'set' && bundleBase)) {
-                return { ok: false, error: '没找到本插件的 loader 行，也无法确认 bundle 层的挂载条目，无法自动改写配置：请在 profile 的 cordis.patch.yml 里手动加一条覆盖条目（- id: dsh-plugin-tool-management → config: → token: "…"），或改用环境变量 DSH_PLUGIN_TOOL_MANAGEMENT_TOKEN。' };
-            }
-            if (files.length > 1) {
-                return { ok: false, error: '本插件的 loader 行同时出现在两份补丁文件里（会导致 DSH 无法启动）：请先清掉重复那条，再回来设置令牌。' };
-            }
-            if (!files.length) {
-                // 0.1.7 bundle 挂载：两份补丁里都没有本插件的 loader 行（条目由 bundle 层提供，那份
-                // 文件是仓库镜像、不能落密钥）—— 令牌写进 **profile 补丁的覆盖条目**：宿主在所有
-                // bundle 层之后应用它，整体替换那条 loader 的 config（bundle 条目没有 config，替换
-                // 零丢失）；同 id 的 insert 条目才会重复挂载导致启动失败，覆盖条目是官方支持的改法。
-                // `off` / `clear` / `on` 走不到这里：有 site 时就地改写，没 site 且有令牌 = 令牌来自
-                // 环境变量，那两条路在前面已按各自口径返回。
-                return withWriteLock(async () => {
-                    let content = '';
-                    try {
-                        content = await readPatch(p.projectPatch);
-                    }
-                    catch (e) {
-                        return { ok: false, error: '读取补丁失败: ' + message(e) };
-                    }
-                    const next = content === '' ? buildLoaderOverrideEntry(value) + '\n' : (content.endsWith('\n') ? content : content + '\n') + '\n' + buildLoaderOverrideEntry(value);
-                    try {
-                        await writePatch(p.projectPatch, next);
-                    }
-                    catch (e) {
-                        return { ok: false, error: '写入补丁失败: ' + message(e) };
-                    }
-                    return { ok: true, changed: true, mode, restartRequired: true, path: p.projectPatch };
-                });
-            }
-            const abs = files[0];
-            return withWriteLock(async () => {
-                let content = '';
-                try {
-                    content = await readPatch(abs);
-                }
-                catch (e) {
-                    return { ok: false, error: '读取补丁失败: ' + message(e) };
-                }
-                // 两步改写共用一份内容：先写令牌（set 写值 / clear 删掉），再写开关（set 与 clear 顺带
-                // 把"已关闭"那行清掉 —— 换了个新令牌却还留着"已关闭"、或者令牌都没了还写着"已关闭"，
-                // 都是说不通的）。
-                let changed = false;
-                // `refused`：loader 行里的 config 形状是插件读不了的（flow style / 重复键）。此时
-                // 改写会插入第二个 `config:`，而官方 js-yaml 对重复映射键是 throw —— 后果是 DSH 下次
-                // 起不来。所以拒绝并说明，而不是"尽力写一下"。
-                if (mode === 'set' || mode === 'clear') {
-                    const wrote = applyLoaderToken(content, mode === 'clear' ? null : value);
-                    if (!wrote.found)
-                        return { ok: false, error: '没找到本插件的 loader 行：' + abs };
-                    if (wrote.refused)
-                        return { ok: false, error: wrote.refused };
-                    content = wrote.content;
-                    changed = changed || wrote.changed;
-                }
-                const flag = mode === 'off' ? true : mode === 'clear' ? null : false;
-                const toggled = applyLoaderTokenDisabled(content, flag);
-                if (!toggled.found)
-                    return { ok: false, error: '没找到本插件的 loader 行：' + abs };
-                if (toggled.refused)
-                    return { ok: false, error: toggled.refused };
-                content = toggled.content;
-                changed = changed || toggled.changed;
-                if (changed) {
-                    try {
-                        await writePatch(abs, content);
-                    }
-                    catch (e) {
-                        return { ok: false, error: '写入补丁失败: ' + message(e) };
-                    }
-                }
-                // 改配置**需要重启 DSH 才生效**：当前进程的 TOKEN 是 apply 时读进来的常量。
-                // 所以这里如实回 restartRequired，界面据此说清"现在还没生效"，而不是让用户以为失败了。
-                return { ok: true, changed, mode, restartRequired: changed, path: abs };
-            });
-        }
+        // ---------- 访问令牌：宿主侧配置的读写（兼容页就地开关） ----------
+        // 正文 2026-10-01 整段搬到 ./token-config.ts（一字未改，只把八个 apply 作用域名字改走
+        // deps）。这一段是 apply 里唯一**改写宿主启动配置**的手：四个方向的凭证判据、写点优先级、
+        // 拒写形状全在那一层的注释里。这里按原位置建一次工厂 —— 它没有状态，两个出口仍然只被
+        // apply 末尾的 HTTP 路由就地调用（刻意不进 handlers 表，模型关不掉访问令牌）。
+        const { tokenConfigState, tokenConfigure } = createTokenConfig({
+            ensurePaths, readPatch, writePatch, withWriteLock, message,
+            TOKEN, CONFIG_TOKEN, tokenMatches,
+        });
         // ---------- 通用侧车 JSON 读写 ----------
         // 为什么留在 index.ts：注入设置（inject-settings.json）也在用这一对，搬进
         // ./mcp/manager.ts 就得为一对 6 行函数再加一层 deps 转发。
@@ -1878,7 +1415,7 @@ export default {
             catch {
                 hostNames = [];
             }
-            const mcp = hostNames.filter((name) => name.startsWith('mcp__'));
+            const mcp = hostNames.filter((name) => name.startsWith(MCP_TOOL_PREFIX));
             const known = new Set(hostNames);
             const presetId = currentPresetId(agentCtx);
             if (presetId !== null)
@@ -1954,6 +1491,7 @@ export default {
                 tools,
                 readInjectSettings,
                 injectSettingsOp,
+                readSlashSettings,
                 toolTableOp,
                 toolTableReport: () => toolTableReport(),
                 presetRoster: candidates.presetRoster,
@@ -1971,6 +1509,9 @@ export default {
             }),
             // AGENTS.md / 提示词预设域（ops/prompts.ts 提供，见上方 promptOps）。
             ...promptOps,
+            // 快捷提示词域（ops/quick-prompts.ts）：quickprompt-list / -create / -update /
+            // -toggle / -remove 与回收站三条。它**不**碰 AGENTS.md、不进场景、不进注入。
+            ...quickPromptOps,
             // 归档会话域（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 /
@@ -1990,6 +1531,7 @@ export default {
                 createSession: agents?.create,
                 host: (name) => ctx.get(name),
                 promptsDir,
+                quickPromptsDir,
                 rulesList: (args) => memoriesService.ops['rules-list'](args),
                 skillDetail: (args) => skillsService.ops['skill-detail'](args),
                 extractTurnsFromEvents,
@@ -1999,6 +1541,14 @@ export default {
             // 必须排在 ...memoriesService.ops 之后 —— 这里是显式覆盖同名 op，不是新增。
             ...buildSceneSyncOps({
                 withAgentsMdSync,
+                // 「两轴恒等」（ops/scene-sync.ts 文件头）：`rules-set-active` 要能把运行时跟着
+                // 启用集合一起切。`scene-mode-set` 取**包过一层的那份**（锁定守卫 + 目录重算），
+                // 且按调用时取（这里是组装期，联动在 931 行就已装好）。
+                currentModeScene: async () => {
+                    const slice = await memoriesService.readArchiveSlice();
+                    return slice.mode && slice.mode.scene ? slice.mode.scene : null;
+                },
+                sceneModeSet: (args) => archiveService.ops['scene-mode-set'](args),
                 onToolTablePresetChanged: async (scene, value) => {
                     // 「修改场景」里改绑工具表方案且改的是**当前启用场景** → 立即把关停名单整体换成
                     // 那一份（与「改档案 = 立刻生效」同口径）。解绑（''）按下拉里的承诺 =「保持现状」，
@@ -2013,6 +1563,17 @@ export default {
                         return;
                     await applyToolTableHiddenNow(hidden);
                 },
+                // 快捷提示词：改的是**当前启用场景**时按新勾选集立刻应用一次 —— 走的就是「保存档案 =
+                // 立刻生效」那条路（`scene-archive-save` 内含 stale 清理、运行时重应用与快照并入），
+                // 不在这里另写一套应用逻辑。解绑（null）不回滚：这一域回到"保持现状"，而进场景前那批
+                // 开关仍在模式快照里，退出照常还原。
+                onQuickPromptsChanged: async (scene, value) => {
+                    const slice = await memoriesService.readArchiveSlice();
+                    if (!slice.mode || slice.mode.scene !== scene || value === null)
+                        return;
+                    const cur = slice.archives[scene] || {};
+                    await archiveService.ops['scene-archive-save']({ scene, archive: { ...cur, quickPrompts: value } });
+                },
                 rulesOps: {
                     'rules-set-active': (args) => memoriesService.ops['rules-set-active'](args),
                     'rules-update-scene': (args) => memoriesService.ops['rules-update-scene'](args),
@@ -2038,6 +1599,9 @@ export default {
             // 场景页的界面设置（读 / 写）：进入场景前要不要弹预览卡。按写操作门禁（它写侧车），
             // 但**不进场景冻结** —— 它是界面提示，与五个管理域的只读无关（见 scene-settings.ts）。
             'scene-settings': (args) => sceneSettingsOp(args),
+            // 斜杠命令入口的开关（读 / 写）：客户端 boot 时读一次决定挂不挂 `/` 菜单里的「工具」段，
+            // 兼容页那两颗开关写一次。同 `scene-settings`：按写门禁但不冻结（见 slash-settings.ts）。
+            'slash-settings': (args) => slashSettingsOp(args),
             // state-doctor：跨域**悬空引用**体检（只读，实现与理由见 src/ops/state-doctor.ts）。
             // 这里只做"把权威集合取来"这一件事 —— 某一域读失败就传 null，体检会把它记进
             // `skipped` 而不是当成"该域没有悬空项"（读不到 ≠ 不存在，报成后者就是骗人）。
@@ -2383,6 +1947,18 @@ export default {
                         next.subagents = toggleInList(Array.isArray(next.subagents) ? next.subagents.slice() : [], name, enabled);
                         break;
                     }
+                    case 'quickprompt-toggle': {
+                        // 与上面几段**不同**：这一段未定义说的是"这一域保持现状"，不是"一个都没勾"。
+                        // 所以在没绑定的场景里手动勾一条快捷词，不该悄悄把它变成"按场景勾选"——
+                        // 那会让下一次进场景的行为整个换掉（用户看到的只是"我开了一个开关"）。
+                        if (!Array.isArray(next.quickPrompts))
+                            return null;
+                        const id = String((args && args.id) || '');
+                        if (!id)
+                            return null;
+                        next.quickPrompts = toggleInList(next.quickPrompts.slice(), id, enabled);
+                        break;
+                    }
                     default: return null;
                 }
             }
@@ -2429,6 +2005,7 @@ export default {
             ensurePaths,
             pluginVersion: () => PKG_VERSION,
             promptsDir: () => promptsDir,
+            quickPromptsDir: () => quickPromptsDir,
             message,
         });
         Object.assign(handlers, snapshotOps);
@@ -2519,18 +2096,23 @@ export default {
          * 调用方就是猜。这里给工具看到的表包一层，界面上 handlers 表那份原样不动，两条路各记各的。
          * 只多记一条流水：不改行为、不改返回值、也不吞异常（写类与成败的判据在 ./audit-log.ts）。
          */
-        const auditFn = (opName, fn) => async (args) => {
-            const result = await fn(args || {});
-            recordOpAudit(opName, args || {}, 'model', result);
-            return result;
-        };
-        const auditOps = (ops) => {
-            const out = {};
-            for (const [name, fn] of Object.entries(ops)) {
-                out[name] = typeof fn === 'function' ? auditFn(name, fn) : fn;
-            }
-            return out;
-        };
+        /**
+         * **模型侧的冻结闸**（审查 F3，0.17.0）：与 HTTP handlers 用同一个判据函数。
+         *
+         * 此前冻结只装在 `handlers` 上，而模型工具拿的是 `service.ops` 的副本 —— 于是「锁一个
+         * **非活动**场景」在 HTTP 上被拒、在模型侧五个域（技能/记忆/MCP/子智能体/场景档案）
+         * 全放行：`lockedSceneGuard()` 只看**当前**场景，锁的是别的场景时它返回 null。
+         * 一个界面禁用、模型可写的门禁，等于没有门禁。
+         *
+         * 装在这里而不是 service.ops 上：进/退场景的运行时应用直调 `service.ops`
+         * （`applySkills` / `applyMcpServerSwitches` / …），装在那一层会把场景自己锁死（见
+         * `createFrozenGate` 的注释）。`auditOps` 返回的是**新表**，原表不受影响。
+         */
+        const frozenGate = createFrozenGate({ lockedSceneNames, activeSceneName });
+        // 被拒时不记流水：什么都没改，记下来只会把真变更淹没（与只读 op 同一口径）。
+        const modelAudit = (opName, args, result) => recordOpAudit(opName, args, 'model', result);
+        const auditOps = (ops) => guardModelOps(ops, frozenGate, modelAudit);
+        const auditFn = (opName, fn) => guardModelOp(opName, fn, frozenGate, modelAudit);
         const toolDeps = {
             defineTool,
             // 量体积只认**注册成功**的那些（注册失败的域工具本来就不在模型工具表里）——
@@ -2564,7 +2146,16 @@ export default {
         buildSkillTools({ ...toolDeps, skillsOps: auditOps(skillsService.ops) });
         // 传 op 表而不是 promptsService：「生效中」的判定只有 `agentsmd-list` 里有（场景绑定
         // 的那份才算），直调服务会得到文件比对口径 —— 场景驱动时工具会报一个与界面不同的答案。
-        buildPromptTools({ ...toolDeps, promptOps: auditOps(promptOps), applyPresetGuarded, promptsDir });
+        //
+        // `applyPresetGuarded` 是模型侧**唯一**不经 op 表的写路径（`prompt_manager_apply` 直接调它，
+        // 见上面 `frozenGate` 的注释），所以冻结闸要在这里显式套一层 —— 它对应的 HTTP op 是
+        // `agentsmd-apply`（冻结清单里那条）。少了这一层，"锁着**别的**场景"时模型仍能换掉当前
+        // 场景的提示词绑定（审查 F3 的另一半）。
+        const applyPresetForModel = async (id) => {
+            const denied = await frozenGate('agentsmd-apply', { id });
+            return denied ? { ok: false, error: denied } : applyPresetGuarded(id);
+        };
+        buildPromptTools({ ...toolDeps, promptOps: auditOps(promptOps), applyPresetGuarded: applyPresetForModel, promptsDir });
         buildMemoryTools({ ...toolDeps, rulesOps: auditOps(memoriesService.ops) });
         // 场景族（tools/scene.ts）：列场景与档案（`_list`）+ 建场景 / 写档案 / 绑提示词（`_save`）
         // + 进入与退出（`_switch`）。
@@ -2839,214 +2430,15 @@ export default {
             mcp.dispose();
         }, 'dsh-plugin-tool-management: tool restriction cleanup');
         // ---------- HTTP API route (UI half), registered defensively ----------
-        if (webServer) {
-            // Cap request bodies (88 MiB): skill-upload carries Base64 folder/ZIP
-            // payloads (64 MiB of raw content). Reachability is decided by
-            // fenceRejection() below — the host's Host/Origin + browser-session fence
-            // (or a correct explicit token). `config.maxBodyBytes` overrides the cap
-            // (tests use a small value).
-            const configuredMaxBody = Number(config?.maxBodyBytes);
-            // 默认 88 MiB：够塞下一份带多张大附件（图片 / PDF）的技能或记忆打包体，又不至于让
-            // 一个失控的客户端把进程内存吃光。`config.maxBodyBytes` 可覆盖（测试用小值）。
-            const DEFAULT_MAX_BODY_BYTES = 88 * 1024 * 1024;
-            const MAX_BODY = Number.isFinite(configuredMaxBody) && configuredMaxBody > 0 ? configuredMaxBody : DEFAULT_MAX_BODY_BYTES;
-            const readBody = (req) => new Promise((resolve, reject) => {
-                // 先看 content-length：注定超限的请求在**读第一个字节之前**就拒掉。以前只能边收边数，
-                // 一个 5 GB 的上传会先让我们缓冲满 88 MiB 才回错。读取流照旧 drain（一个字节都不留），
-                // 否则响应写完后服务端会直接拆连接，客户端可能在上传中途拿到网络错误而不是下面这句 JSON。
-                // 错误消息必须含 `body too large` —— 后面的 catch 靠这个子串分流。
-                const declared = Number(req.headers && req.headers['content-length']);
-                if (Number.isFinite(declared) && declared > MAX_BODY) {
-                    const drain = req.resume;
-                    if (typeof drain === 'function')
-                        drain.call(req);
-                    reject(new Error('request body too large'));
-                    return;
-                }
-                // Accumulate Buffers and decode ONCE at the end: decoding each chunk
-                // separately corrupts multi-byte UTF-8 characters that straddle a
-                // chunk boundary (e.g. long Chinese skill bodies).
-                const chunks = [];
-                let size = 0;
-                req.on('data', (c) => {
-                    const buf = Buffer.isBuffer(c) ? c : Buffer.from(String(c));
-                    size += buf.length;
-                    if (size > MAX_BODY) {
-                        reject(new Error('request body too large'));
-                        return;
-                    }
-                    chunks.push(buf);
-                });
-                req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-                req.on('error', reject);
-            });
-            // 宿主 BrowserAuth 栅栏。宿主的鉴权**只包在它自己注册的路由上**——dsh-host-webserver
-            // 没有全局中间件，既定约定是每个注册方自己调 connection.requestRejection(req)：
-            // 它先做 Host/Origin 栅栏（Host 必须是回环或 deployment 派生的 LAN IP 字面量，
-            // 这是 DNS rebinding 唯一伪造不了的头），再叠加 browser-session cookie 鉴权。
-            // 本插件此前只查公开常量 x-dsh-plugin 与自比对（Origin.host === Host）的 "同源"，
-            // 两者都挡不住 rebind 后的网页或本机任意进程 —— 等于没鉴权。现在优先走宿主栅栏。
-            const connection = (() => {
-                try {
-                    return ctx.get('connection');
-                }
-                catch {
-                    return undefined;
-                }
-            })();
-            try {
-                // ctx.effect wires the route's disposer into this plugin's scope, so an
-                // unload (HMR removal, disable, update) unregisters the route — the
-                // documented cleanup contract (webServer.register does not auto-scope).
-                ctx.effect(() => webServer.register({
-                    kind: 'exact',
-                    path: '/dsh-plugin-tool-management/api',
-                    handler: async (req, res) => {
-                        // 鉴权顺序：POST-only → 插件门禁头（防误触，不是凭证）→ 宿主栅栏
-                        // （Host/Origin + browser-session cookie）→ 可选访问令牌。令牌是本地工具与
-                        // LAN 部署的逃生门：**令牌正确即视为已授权**，可越过浏览器鉴权。
-                        //
-                        // 「未配置令牌时」别读成"仍有门禁"：下面的写 op 判据是
-                        // `if (TOKEN && WRITE_OPS.has(op))` —— `TOKEN === ''` 时整条短路，79 个写 op
-                        // 只剩 `fenceRejection` 一道。而它自身有两种形态：宿主栅栏在场时含 cookie 鉴权；
-                        // 栅栏缺席或抛错时退回本地判定，**只查回环 Host 与（若给了）Origin 自比对**，
-                        // 没有 cookie 那一层 —— 本机任意进程都能调写 op。所以准确说法是：
-                        // 未配置令牌时不再有「**无栅栏**放行」的缺口，但进程级边界只有配了令牌才有。
-                        const hdr = (name) => {
-                            const v = req.headers?.[name];
-                            return Array.isArray(v) ? v[0] ?? '' : v ?? '';
-                        };
-                        if (String(req.method || 'POST').toUpperCase() !== 'POST') {
-                            res.writeHead(405, { 'content-type': 'application/json' });
-                            res.end(JSON.stringify({ ok: false, error: 'method not allowed' }));
-                            return;
-                        }
-                        if (hdr('x-dsh-plugin') !== 'dsh-plugin-tool-management') {
-                            res.writeHead(403, { 'content-type': 'application/json' });
-                            res.end(JSON.stringify({ ok: false, error: 'missing plugin gate header' }));
-                            return;
-                        }
-                        // 「本次带的这串对不对」比的是**存量**令牌：关掉令牌功能之后仍然要凭它才能开回来、
-                        // 换掉、或看明文（要求 9）。
-                        const tokenAccepted = CONFIG_TOKEN !== '' && tokenMatches(hdr('x-dsh-token'));
-                        // 验过就置闩（本次进程一次即可）。`agent/pre-step` 的令牌门禁读的就是它 ——
-                        // 那一边看不到请求头，只能由这里告诉它"这台机器已经有人验过令牌了"。
-                        if (tokenAccepted)
-                            markAccepted();
-                        if (!tokenAccepted) {
-                            const fence = fenceRejection(req, connection);
-                            if (fence) {
-                                res.writeHead(fence.status, { 'content-type': 'application/json' });
-                                res.end(JSON.stringify({ ok: false, error: fence.error }));
-                                return;
-                            }
-                        }
-                        res.writeHead(200, { 'content-type': 'application/json' });
-                        try {
-                            let payload = {};
-                            try {
-                                payload = JSON.parse((await readBody(req)) || '{}');
-                            }
-                            catch (e) {
-                                if (String(e?.message).includes('body too large')) {
-                                    res.end(JSON.stringify({ ok: false, error: '请求体过大' }));
-                                    return;
-                                }
-                                /* otherwise fall through with {} */
-                            }
-                            const op = String(payload.op || '');
-                            // 敏感 op（会吐明文密钥与完整配置）：**配了令牌就必须带对的**，没配令牌则不设防
-                            // （判定与理由见 http-fence.ts 的 secretOpRejection —— 用户裁定 2026-09-19：
-                            // 没配令牌时那道门没有出路，用户无从填一个不存在的令牌）。
-                            // 之前这里只查"有没有 Origin 头"，而 token 为空时它形同虚设 —— 任何能
-                            // 打开 GUI 的浏览器都拿得到全部密钥原文。
-                            if (SENSITIVE_OPS.has(op)) {
-                                // 明文门禁看的是**存量**令牌（CONFIG_TOKEN 而不是生效值 TOKEN）：关掉令牌
-                                // 功能之后仍然"要凭存量令牌才给明文"—— 那条路是通的（填对就能看），
-                                // 与"从来没配过"不同。
-                                const gate = secretOpRejection({ tokenConfigured: CONFIG_TOKEN !== '', tokenAccepted });
-                                if (gate) {
-                                    res.end(JSON.stringify({ ok: false, error: gate.error, code: gate.code }));
-                                    return;
-                                }
-                            }
-                            // 「读改写」两态 op：不带 `set:true` 时是**纯读**，与写门禁无关。
-                            // `inject-settings`（兼容页的「注入」块）、`tool-table`（同页的「模型工具表」）、
-                            // `scene-settings`（场景页的提醒开关）与 `mcpm-settings`（MCP 页的轮询设置）
-                            // 都用同一个 op 承担读与写，于是整条 op 被列进 WRITE_OPS —— 读侧也一起被拦，
-                            // 界面表现是"没填令牌时整块设置消失、填了还要刷新才出现"（2026-09-19 用户报的）。
-                            // 判据是**这次调用要不要写**，不是 op 名在不在名单里。
-                            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 也统一 —— 界面据此在最右侧挂
-                                // 「去填令牌」跳转按钮。这条错误会出现在**任意**页面，而入口只有一个。
-                                res.end(JSON.stringify({ ok: false, code: TOKEN_CODE_BAD, error: TOKEN_MSG }));
-                                return;
-                            }
-                            // 令牌状态（只读，**不需要**令牌本身）：回答"宿主配没配"、"本次带的这串对不对"、
-                            // "配置文件里的改动是不是还没重启生效"、"本次进程的标识"。就地回答而不是进 handlers 表：
-                            // 前者的答案来自本次请求头与进程状态，而后者的 handlers 只拿得到 args。
-                            // 不返回令牌、也不返回它的任何片段 —— 泄给同源页面等于把最后一道门交出去。
-                            if (op === 'token-status') {
-                                const state = await tokenConfigState();
-                                res.end(JSON.stringify({
-                                    ok: true,
-                                    // 「宿主配置了令牌」= 配置里**有**值（关掉也算有：随时能开回来）。
-                                    hostConfigured: CONFIG_TOKEN !== '',
-                                    // 当前进程里令牌功能是开还是关（关掉 = 写操作不要求令牌）。
-                                    disabled: TOKEN_DISABLED,
-                                    // 「当前进程里令牌**在生效**」= 写操作要不要令牌。关掉或没配都是 false。
-                                    // 界面据此判断"填令牌"这件事有没有意义（没生效时填了也没人验，还会把
-                                    // 一句无处可填的提示挂在屏幕上 —— 用户 2026-09-19 报的就是这个）。
-                                    active: TOKEN !== '',
-                                    accepted: tokenAccepted,
-                                    bootId: BOOT_ID,
-                                    configHasToken: state.configHasToken,
-                                    configDisabled: state.configDisabled,
-                                    configFound: state.found,
-                                    pendingRestart: state.pendingRestart,
-                                }));
-                                return;
-                            }
-                            // 设置 / 关闭令牌：同样就地处理（理由见 tokenConfigure 的注释 —— 也正因为不进
-                            // handlers，模型侧没有任何工具能间接关掉它）。
-                            if (op === 'token-configure') {
-                                res.end(JSON.stringify(withPatchWarnings(await tokenConfigure(payload.args || {}, tokenAccepted))));
-                                return;
-                            }
-                            // 「清除令牌」的配套：把「本次启动已验过」的闩重新挂上。没有它，解锁一次之后
-                            // 清除令牌 + 强刷新，浏览器里已无令牌，闩却挂着 —— pre-step 门禁读闩
-                            // （tokenGateActive），整个启动期都放行对话（2026-09-19 用户实测的漏洞）。
-                            // 不要求凭证：它只会收紧（要求重新验令牌），给不了任何人任何权限；同样不进
-                            // handlers —— 模型不该有能力拨这颗闩。
-                            if (op === 'token-unaccept') {
-                                unmarkAccepted();
-                                res.end(JSON.stringify({ ok: true }));
-                                return;
-                            }
-                            const fn = handlers[op];
-                            if (!fn) {
-                                res.end(JSON.stringify({ ok: false, error: '未知操作: ' + op }));
-                                return;
-                            }
-                            const result = await fn(payload.args || {});
-                            // 「最近改动」流水：来源 = 面板（这条 HTTP 路由是界面唯一的入口）。
-                            // `readOnlyCall` 是上面那四个「读改写两态 op」的纯读分支 —— 它们没改任何状态，不记。
-                            if (!readOnlyCall)
-                                recordOpAudit(op, payload.args || {}, 'panel', result);
-                            res.end(JSON.stringify(withPatchWarnings(result === undefined ? { ok: true } : result)));
-                        }
-                        catch (e) {
-                            res.end(JSON.stringify({ ok: false, error: message(e) }));
-                        }
-                    },
-                }), 'dsh-plugin-tool-management: api route');
-            }
-            catch (e) {
-                // A registration failure must never take down the whole entry: log and continue.
-                console.error('[dsh-plugin-tool-management] webServer route registration failed:', message(e));
-            }
-        }
+        // 正文 2026-10-01 整段搬到 ./http-api.ts（一字未改，只把 apply 作用域的名字改走 deps）。
+        // 位置也保持原样：这一段是 apply 的最后一条注册，前面的 handlers 表 / 门禁 / 白名单都已就位。
+        // 传引用而不是快照：`handlers` 在本调用之前还被 Object.assign 追加过、被 installHandlerGuards
+        // 逐条重包过，注册之后请求期读的也是当时的最新那份。
+        installHttpApi({
+            ctx, config, webServer, handlers, message, withPatchWarnings,
+            tokenConfigState, tokenConfigure,
+            CONFIG_TOKEN, TOKEN_DISABLED, TOKEN, tokenMatches, BOOT_ID, markAccepted, unmarkAccepted,
+            WRITE_OPS, SENSITIVE_OPS,
+        });
     },
 };