dsh-plugin-tool-management 0.13.0 → 0.15.0

package/lib/index.js

@@ -22,6 +22,8 @@ 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 { createSnapshotOps } from './ops/snapshot.js';
+import { AUDIT_TARGET_CONFIG, clearAudit, readAudit, recordAudit, recordOpAudit } from './audit-log.js';
 import { readIndexSync } from './memories/index-io.js';
 import { runStateDoctor } from './ops/state-doctor.js';
 import { createSubagentService, decideToolFilter, defaultPersonasDir } from './subagents/service.js';
@@ -29,18 +31,20 @@ 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 { buildToolTableReport, normalizeToolTableSettings, } from './tools/table.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 { 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。这里保持原路径可导出，契约不变。
 export { normalizeKnownTools, countEnabledTools } from './mcp/manager.js';
-import { applyLoaderToken, applyLoaderTokenDisabled, readLoaderToken } from './mcp/loader-token.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';
@@ -56,6 +60,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';
@@ -160,6 +165,8 @@ export default {
                 kind: 'read',
                 fallback: 'inform-only',
                 detail: '技能 provider 装配失败（' + message(e) + '）：技能启用/停用与 agent 技能目录这一轮不生效。',
+                detailKey: 'skills-provider',
+                params: { reason: message(e) },
             });
         }
         // ---------- 提示词预设库（hub/prompts/）+ 切换 ----------
@@ -210,7 +217,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) }
                 : {}),
@@ -293,7 +300,41 @@ export default {
             // 用生效集去校验会把合法勾选判成 stale 丢掉。
             return (await skillScan()).all;
         }
+        // 整体替换关停名单的那一步抽成具名函数：引擎的 apply 依赖与「修改场景」表单的
+        // 即时生效（scene-sync 包装）共用同一条写路径，不能各抄一份。
+        const applyToolTableHiddenNow = async (hidden) => {
+            // 与 `tool-table` op 写分支同一条路径、同一顺序：落盘 → 重排可见性 → 两个目录重算。
+            // 绕开这套顺序就会留下「名单已经改了、工具下一轮还发给模型」这种最难查的状态。
+            const current = await readToolTableSettings();
+            const next = {
+                hidden: normalizeToolTableSettings({ hidden }).hidden.filter((name) => toolTableSizes.has(name)),
+                presets: current.presets,
+            };
+            const saved = await writeToolTableSettings(next);
+            if (!saved.ok)
+                throw new Error(saved.error);
+            mcp.scheduleToolRestrictions();
+            await Promise.all([
+                skillCatalog.refresh().catch(() => { }),
+                subagentCatalog.refresh().catch(() => { }),
+            ]);
+        };
         const archiveService = createArchiveEngine({
+            // 引擎每应用/还原一次整套档案记一条流水（source='engine'，见 ./audit-log.ts）。
+            // 记在边界这一层而不是往五个 apply* 里散着写：一条流水说的是「引擎动了整个环境」，
+            // 与同一次进入里面板/模型那条记录天然按秒分组显示。
+            audit: (op, target) => recordAudit({ ts: Date.now(), op, target: target || AUDIT_TARGET_CONFIG, source: 'engine' }),
+            // ── 模型工具表（0.15.0 C1）：场景可以绑一份方案，进场景整体换成那一份 ──
+            currentToolTableHidden: async () => [...(await readToolTableSettings()).hidden],
+            toolTablePresetHidden: async (name) => {
+                const s = await readToolTableSettings();
+                // 用户存的方案**优先**：万一有人把方案起名叫 'factory-default'，他要的是自己那份。
+                const hit = s.presets.filter((p) => p.name === name)[0];
+                if (hit)
+                    return [...hit.hidden];
+                return name === FACTORY_TOOL_TABLE_PRESET ? [...DEFAULT_HIDDEN_TOOLS] : null;
+            },
+            applyToolTableHidden: applyToolTableHiddenNow,
             loadSlice: async () => ({ ...(await memoriesService.readArchiveSlice()) }),
             saveSlice: (slice) => memoriesService.patchIndex(slice),
             configuredServers: async () => {
@@ -510,8 +551,10 @@ export default {
                 .map((s) => slice.archives[s.name]?.subagents ?? []);
         };
         // ---------- 模型工具表开关（侧车 `tool-table.json`，界面在「兼容」页）----------
-        // 工具表按**每个请求**付钱：20 个工具的整份定义合计 ≈3,500 tok 每轮都在。关掉某几个，
-        // 它们整份不进请求（实测口径与取舍见 src/tools/table.ts 的文件头）。
+        // 工具表按**每个请求**付钱：20 个工具的整份定义合计 ≈3,769 tok 每轮都在。关掉某几个，
+        // 它们整份不进请求（实测口径与取舍见 src/tools/table.ts 的文件头）。**出厂就已经关了十五条**
+        // （20 条里实发只剩 5 条）—— 名单、判据与代价在 `DEFAULT_HIDDEN_TOOLS`，只在这个人从没记过
+        // 选择时铺（见下面的 `toolTableSettingsFrom`）。
         //
         // 为什么放在目录之前：两个目录的「用 `X` 查」提示要跟着这份设置变（工具关掉后那句话
         // 就是假的），所以它们的构造依赖在这块之后 —— 不做前向引用，顺序就是依赖顺序。
@@ -536,7 +579,20 @@ export default {
                 return toolTableCache.value;
             await ensurePaths();
             const raw = await readJsonFile(hubPath(TOOL_TABLE_FILE));
-            const value = normalizeToolTableSettings(raw);
+            // 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) };
             // 首读 / 文件被外部改过 ⇒ 可见性要跟着重排。同步快照的调用方（门禁、注入通道）不会
@@ -552,8 +608,9 @@ export default {
         }
         /**
          * 同步快照（热路径用：工具门禁每次调用、注入通道每个 step 都要问一句）。还没加载时先给
-         * 默认值并异步预热 —— 默认是"什么都没关"，预热前的这一瞬与用户的选择可能不一致，但
-         * 方向是安全的那一侧（不隐藏任何东西，绝不因为读盘慢而让工具凭空消失）。
+         * **空集**并异步预热 —— 空集不是出厂默认（出厂关着五条），是刻意的：预热前的这一瞬与
+         * 用户的选择可能不一致，但方向必须是安全的那一侧（不隐藏任何东西，绝不因为读盘慢而让
+         * 工具凭空消失）。
          */
         function toolTableHidden() {
             if (toolTableCache === null) {
@@ -564,27 +621,74 @@ export default {
         }
         const toolTableRows = () => [...toolTableSizes].map(([name, bytes]) => ({ name, bytes }));
         const toolTableReport = (hidden = [...toolTableHidden()]) => buildToolTableReport(toolTableRows(), hidden);
-        async function toolTableOp(args) {
-            const current = await readToolTableSettings();
-            if (!args || args.set !== true)
-                return { ok: true, hidden: current.hidden, report: toolTableReport(current.hidden) };
-            const next = normalizeToolTableSettings({ hidden: args.hidden });
-            // 只收**已注册**的名字：写进来的陌生名字在下一次 restrict 时会让官方抛错
-            // （"names unknown global tool"）。注册失败的工具本来也不在表里。
-            const hidden = next.hidden.filter((name) => toolTableSizes.has(name));
+        /** 落盘 + 同步内存缓存（三条写路径共用：改勾选 / 存方案 / 删方案）。 */
+        async function writeToolTableSettings(next) {
             await ensurePaths();
             // 落盘在写锁里，落完**出了锁**再刷新（`withWriteLock` 是一条不可重入的链：锁里再调
             // 一次会等自己，直接卡死）。刷新是两处目录读，本来也不必占着写锁。
-            const saved = await withWriteLock(async () => {
+            return withWriteLock(async () => {
                 try {
-                    await writeJsonFile(hubPath(TOOL_TABLE_FILE), { hidden });
+                    await writeJsonFile(hubPath(TOOL_TABLE_FILE), next);
                 }
                 catch (e) {
                     return { ok: false, error: '设置保存失败: ' + message(e) };
                 }
-                toolTableCache = { at: Date.now(), value: { hidden }, off: new Set(hidden) };
+                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 名单重排）、两个目录（截断提示里点名的工具可能没了）。
@@ -594,7 +698,7 @@ export default {
                 skillCatalog.refresh().catch(() => { }),
                 subagentCatalog.refresh().catch(() => { }),
             ]);
-            return { ok: true, hidden, report: toolTableReport(hidden) };
+            return toolTablePayload(next);
         }
         // ---------- 「有官方等价物 ⇒ 我们让位」----------
         // 官方 `skill` 工具（`@deepseek-ai/dsh-tool-skill`）与我们的 `skill_manager_read` 是同一
@@ -628,7 +732,7 @@ export default {
             }
             return out;
         };
-        // ---------- 注入通道（场景和记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
+        // ---------- 注入通道（场景 / 记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
         // 这些文本以前是 systemPrompt 段（persona complete 会整段压掉）。现在改走官方的
         // 「每步注入一条合成消息」通道（skill-catalog / AGENTS.md / 时间上下文同款）：
         // 任何预设都到得了，内容没变不重发。**每个域一条自己的消息**（来源 kind 各不同，
@@ -737,7 +841,7 @@ export default {
                 return { ok: true, settings: next };
             });
         }
-        // 注入实况（只读诊断）：注入器的 live() 读回"最近活跃会话"可见表面上的五域文本。
+        // 注入实况（只读诊断）：注入器的 live() 读回"最近活跃会话"可见表面上的各域文本。
         // 挂在 apply 作用域：`injection-live` op 与注入器不在同一层（effect 内部）。
         let contextInjectorLive = null;
         // 采纳遥测的入口（同样是 apply 作用域的中转）：工具注册在 effect 之外，
@@ -759,16 +863,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() },
                         {
@@ -805,7 +914,9 @@ export default {
                 label: '上下文注入通道',
                 kind: 'read',
                 fallback: 'inform-only',
-                detail: '注入通道装配失败（' + message(e) + '）：五个注入域的内容这一轮不会被送进模型。',
+                detail: '注入通道装配失败（' + message(e) + '）：全部注入域的内容这一轮不会被送进模型。',
+                detailKey: 'context-injection',
+                params: { reason: message(e) },
             });
         }
         void readInjectSettings().catch(() => { });
@@ -832,6 +943,7 @@ export default {
                     kind: 'read',
                     fallback: 'inform-only',
                     detail: 'cordis 导出的 symbols.original 与 Symbol.for("cordis.original") 不是同一个符号：能力探测可能把代理当原始对象，身份判定会失真。',
+                    detailKey: 'cordis-original-symbol',
                 });
             }
         }
@@ -1119,23 +1231,87 @@ export default {
             if (cached)
                 return cached;
             let home = null;
+            let derivedProfileDir = null;
+            let derivedProfileName = null;
+            let docObserved;
+            let docError;
             try {
                 // 注意：这里的 home 来自宿主文档路径的切片，与 `skills/core.js` 的
                 // `resolveDshHome()`（`$DSH_HOME` ‖ `~/.dsh`）是**两条独立来源**，本插件同时用着两者。
                 // 不合并是有意的：合并会改变所有 profile 补丁的落点，属于行为变更，留给结构性重构那一档。
                 const doc = await settings.prepareDocument();
                 if (typeof doc === 'string' && doc) {
+                    docObserved = doc;
                     const i = Math.max(doc.lastIndexOf('\\'), doc.lastIndexOf('/'));
-                    home = i > 0 ? doc.slice(0, i) : doc;
+                    const docDir = i > 0 ? doc.slice(0, i) : doc;
+                    // 0.1.7 起 `prepareDocument()` 返回的是 **profile 补丁**（`configEditor.documentPath`，
+                    // 形如 `<home>\profiles\web\cordis.patch.yml`）；0.1.5 返回的才是主目录下的设置文档。
+                    // 直接切片会把 profile 目录当成主目录 —— globalPatch 随之指到 profile 补丁，
+                    // 全局补丁里那些 MCP 行就全部读不到了（0.15.0 实测）。所以先认这个形状：
+                    // 目录以 `profiles\<name>` 结尾 ⇒ 它自己就是 profileDir，主目录上溯两级。
+                    const profileShaped = /^(.+)[\\/]profiles[\\/]([^\\/]+)$/.exec(docDir);
+                    if (profileShaped) {
+                        home = profileShaped[1];
+                        derivedProfileDir = docDir;
+                        derivedProfileName = profileShaped[2];
+                    }
+                    else {
+                        home = docDir;
+                    }
                 }
             }
-            catch (e) { /* ignore */ }
-            if (!home)
+            catch (e) {
+                docError = String(e?.message ?? e);
+            }
+            if (!home) {
+                // 推导失败从「静默抛错」升级为「具名上报 + 抛错」：这条路径正是 0.1.7 升级事故的
+                // 源头（prepareDocument 返回语义一变这里就指错目录，MCP 页与补丁读写全部失明），
+                // 下次契约再变，兼容页必须第一眼看到推导挂了，而不是等某个页面空白再倒查。
+                noteRuntime({
+                    id: 'paths.home-derivation',
+                    label: '主目录推导',
+                    kind: 'read',
+                    fallback: 'refuse-operation',
+                    detail: docError !== undefined
+                        ? `settings.prepareDocument() 抛错：${docError}。主目录推导失败，MCP 页与补丁读写不可用。`
+                        : 'settings.prepareDocument() 未返回可用路径（宿主路径契约可能又变了）。主目录推导失败，MCP 页与补丁读写不可用。',
+                });
                 throw new Error('无法确定 DSH 主目录（settings.prepareDocument 未返回路径）');
+            }
             const sep = home.indexOf('\\') >= 0 ? '\\' : '/';
-            let profileDir = null;
-            let profileName = DEFAULT_PROFILE_NAME;
-            for (const name of PROFILE_CANDIDATES) {
+            // prepareDocument 给出的就是**现存**的 profile 补丁路径（官方注释如此），所以
+            // 推导出的 profileDir 直接可信；只有它没给出 profile 形状时才走下面的候选探测。
+            const profileShapedPatchExists = derivedProfileDir !== null
+                && (await exists(derivedProfileDir + sep + 'cordis.patch.yml'));
+            // —— 推导自检（0.15.0）：健康时不留 note（运行时上报一律渲染成兼容页的问题行，
+            // 常驻健康行会违反「琥珀只留给故障」的口径），只在推导结果反常时记，恢复时收掉。
+            // 两条不变量照着 0.1.7 事故的形状挑：那次推出的「主目录」其实存在（是 profile 目录），
+            // 存在性检查抓不住，**profiles 子目录**检查才抓得住 —— 主目录下永远有 profiles\
+            //（本插件自己的 profile 就住在里面）。官方再改一次语义，两道检查至少一道当场报警。
+            const derivationNote = (detail) => {
+                noteRuntime({
+                    id: 'paths.home-derivation',
+                    label: '主目录推导',
+                    kind: 'read',
+                    fallback: 'refuse-operation',
+                    detail,
+                });
+            };
+            if (!(await exists(home))) {
+                derivationNote(`推导出的主目录不存在：${home}（设置文档路径：${docObserved ?? '未知'}）。推导结果不可信，MCP 页与补丁读写会落空。`);
+            }
+            else if (!(await exists(home + sep + 'profiles'))) {
+                derivationNote(`推导出的主目录下没有 profiles 目录：${home}（设置文档路径：${docObserved ?? '未知'}）。主目录很可能指错了 —— 直接切片一个 profile 补丁路径就是这个形状；MCP 页与补丁读写会读错文件。`);
+            }
+            else if (derivedProfileDir !== null && !profileShapedPatchExists) {
+                derivationNote(`设置文档路径呈 profile 目录形状，但其中没有 cordis.patch.yml：${docObserved}。官方承诺返回「现存」的 profile 补丁路径，形状对不上说明契约又变了；已回退候选探测。`);
+            }
+            else {
+                clearRuntimeNote('paths.home-derivation');
+            }
+            let profileDir = profileShapedPatchExists ? derivedProfileDir : null;
+            let profileName = derivedProfileName ?? DEFAULT_PROFILE_NAME;
+            for (const name of profileDir === null ? PROFILE_CANDIDATES : []) {
                 if (await exists(home + sep + 'profiles' + sep + name + sep + 'cordis.patch.yml')) {
                     profileDir = home + sep + 'profiles' + sep + name;
                     profileName = name;
@@ -1166,6 +1342,10 @@ export default {
                 profileName,
                 projectPatch: profileDir + sep + 'cordis.patch.yml',
                 globalPatch: home + sep + 'cordis.patch.yml',
+                // 0.1.7 bundle 层：插件包内自己的 cordis.patch.yml（`dsh.bundle.patch`）定义 loader
+                // 条目。它只是「覆盖目标存在吗」的凭证与读取参照，**绝不是令牌的写点** —— 那份文件
+                // 是仓库镜像（sync 每次构建覆盖），把令牌写进去等于把明文密钥提交进仓库。
+                bundlePatch: profileDir + sep + 'node_modules' + sep + 'dsh-plugin-tool-management' + sep + 'cordis.patch.yml',
             };
             return cached;
         }
@@ -1404,7 +1584,17 @@ export default {
                     infoOf.set(abs, { token: read.token, disabled: read.disabled });
                 }
             }
-            return { files, infoOf };
+            // 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 };
         }
         /**
          * 配置**文件里**写了令牌，但当前进程还没生效（或反过来）—— 也就是"改了配置还没重启"。
@@ -1494,13 +1684,39 @@ export default {
                 if (value === CONFIG_TOKEN)
                     return { ok: true, changed: false, note: '和当前令牌相同，未改动。', restartRequired: false };
             }
-            const { files } = await loaderTokenFiles();
-            if (!files.length) {
-                return { ok: false, error: '没找到本插件的 loader 行，无法自动改写配置：请在 profile 的 cordis.patch.yml 里手动设置 config.token（或改用环境变量 DSH_PLUGIN_TOOL_MANAGEMENT_TOKEN）。' };
+            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 = '';
@@ -1682,8 +1898,31 @@ 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,
+            // 「最近改动」流水的读侧（0.15.0 B2）：只读 hub 里的 `audit.jsonl`，倒序、可按域过滤。
+            'audit-list': async (args) => ({ ok: true, entries: await readAudit(args || {}) }),
+            // 清空流水。清完这一条 op 自己会被下面的包装层记进新流水（"谁清过"也留痕）。
+            'audit-clear': async () => await clearAudit(),
             'skill-open': skillOpen,
             // MCP 域 16 个 op（实现在 ./mcp/manager.ts）
             ...mcp.ops,
@@ -1722,30 +1961,16 @@ export default {
                 cleanPatchBackups,
                 getContextInjectorLive: () => contextInjectorLive,
                 // 功能总览（B6）的三层合成：令牌实况与兼容页「访问令牌」同源；场景锁定与写门禁同源；
-                // 停用工具数读 mcp 的 TTL 缓存（无 I/O）。
+                // 停用工具的两个口径读 mcp 的 TTL 缓存（无 I/O）。
                 readTokenState: async () => ({ active: TOKEN !== '', accepted: TOKEN !== '' && acceptedThisBoot() }),
                 lockedSceneNames: () => lockedSceneNames(),
-                disabledToolCount: () => mcp.disabledToolCount(),
+                disabledToolSummary: () => mcp.disabledToolSummary(),
+                injectServiceCount: INJECT_SERVICES.length,
                 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 /
@@ -1774,6 +1999,20 @@ export default {
             // 必须排在 ...memoriesService.ops 之后 —— 这里是显式覆盖同名 op，不是新增。
             ...buildSceneSyncOps({
                 withAgentsMdSync,
+                onToolTablePresetChanged: async (scene, value) => {
+                    // 「修改场景」里改绑工具表方案且改的是**当前启用场景** → 立即把关停名单整体换成
+                    // 那一份（与「改档案 = 立刻生效」同口径）。解绑（''）按下拉里的承诺 =「保持现状」，
+                    // 运行时不动；悬空绑定（方案已删）也不在这里硬失败，交给引擎进出场景时的 stale 处理。
+                    const slice = await memoriesService.readArchiveSlice();
+                    if (!slice.mode || slice.mode.scene !== scene || !value)
+                        return;
+                    const s = await readToolTableSettings();
+                    const hit = s.presets.filter((p) => p.name === value)[0];
+                    const hidden = hit ? [...hit.hidden] : (value === FACTORY_TOOL_TABLE_PRESET ? [...DEFAULT_HIDDEN_TOOLS] : null);
+                    if (!hidden)
+                        return;
+                    await applyToolTableHiddenNow(hidden);
+                },
                 rulesOps: {
                     'rules-set-active': (args) => memoriesService.ops['rules-set-active'](args),
                     'rules-update-scene': (args) => memoriesService.ops['rules-update-scene'](args),
@@ -1785,6 +2024,7 @@ export default {
             ...buildCandidateOps({
                 presetToolCandidates: candidates.presetToolCandidates,
                 modelCandidates: candidates.modelCandidates,
+                modelReasoning: candidates.modelReasoning,
                 getToolFailures: () => subagentToolFailures,
                 mcpmListView: mcp.mcpmListView,
                 toolStates: candidates.toolStates,
@@ -2176,6 +2416,22 @@ export default {
         // handlers 后处理（2026-09-19 抽到 ./request-gate.ts）：场景锁定守卫、开关同步档案、
         // 读 op 的 anyLocked/activeScene 注解、子智能体失败清单 attach。
         // 顺序即语义（先装的在内层），整段搬运未改。
+        //
+        // 整机迁移快照（0.15.0 C2）在门禁装好**之前**并入 handlers：它自己不写任何域的数据，
+        // 而是逐域调 handlers 表里那些 op —— 装好后取到的就是带门禁的那一份，场景锁定期间各域
+        // 自己拒绝，迁移这边不必再判一套锁。
+        const snapshotOps = createSnapshotOps({
+            invokeOp: (name, args) => {
+                const fn = handlers[name];
+                return fn ? fn(args || {}) : Promise.resolve({ ok: false, error: '未知操作: ' + name });
+            },
+            hubPath,
+            ensurePaths,
+            pluginVersion: () => PKG_VERSION,
+            promptsDir: () => promptsDir,
+            message,
+        });
+        Object.assign(handlers, snapshotOps);
         installHandlerGuards({
             handlers,
             lockedSceneNames,
@@ -2253,8 +2509,28 @@ export default {
          */
         const hostDefineToolAny = hostDefineTool;
         const defineTool = ((options) => trackAdoption(hostDefineToolAny(options)));
-        // 五个域共用的那一份依赖（形状见 tools/deps.ts）。defineTool 带着遥测一起传下去 ——
+        // 各域共用的那一份依赖（形状见 tools/deps.ts）。defineTool 带着遥测一起传下去 ——
         // 各域必须用它，直接 import 宿主的那个会丢掉采纳统计。
+        /**
+         * 「最近改动」流水的模型侧挂点（0.15.0 B2）。
+         *
+         * 为什么包在**交给工具的 op 表**上而不是散进每个 op：op 执行有多条入口路径（HTTP 路由、
+         * 模型工具的 execute、场景引擎），而判断「谁干的」这件事只有调用点知道 —— 在 op 里自己猜
+         * 调用方就是猜。这里给工具看到的表包一层，界面上 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;
+        };
         const toolDeps = {
             defineTool,
             // 量体积只认**注册成功**的那些（注册失败的域工具本来就不在模型工具表里）——
@@ -2262,24 +2538,53 @@ export default {
             register: (def) => { recordToolSize(def); tools.register(def); },
             lockedSceneGuard,
             syncSwitchToScene,
+            // 错误句里点名工具前要先问一句（判据与两个目录的 `listToolVisible` 同一份缓存）。
+            toolVisible: (name) => !toolTableHidden().has(name),
             reachNoticeForAgent,
             presetRoster: candidates.presetRoster,
             injectNoticeOptions,
             message,
         };
+        const mcpToolOps = auditOps(mcp.ops);
         buildMcpTools({
             ...toolDeps,
             mcpmListView: mcp.mcpmListView,
-            mcpmSetEnabled: mcp.ops['mcpm-set-enabled'],
-            mcpmRestart: mcp.ops['mcpm-restart'],
-            mcpmAdd: mcp.ops['mcpm-add'],
+            mcpmTools: mcp.ops['mcpm-tools'],
+            mcpmSetEnabled: mcpToolOps['mcpm-set-enabled'],
+            mcpmRestart: mcpToolOps['mcpm-restart'],
+            mcpmToolEnabled: mcpToolOps['mcpm-tool-enabled'],
+            mcpmAdd: mcpToolOps['mcpm-add'],
+            mcpmEdit: mcpToolOps['mcpm-edit'],
+            mcpmNote: mcpToolOps['mcpm-note'],
+            // **故意不接 `mcpm-reveal`**：`mcp_manager_save` 的改分支用 `mcpmListView()` 的
+            // 打码视图填回省略字段，由 `mcpm-edit` 的 `resolveMaskedKv` / `resolveMaskedUrl`
+            // 还原真值 —— 那条路本来就是给"表单里出现打码值"设计的（界面编辑框预填的就是它）。
+            // 让模型驱动的工具在进程内读明文凭据，是另一条没人设计过、也没有测试覆盖的路径。
+        });
+        buildSkillTools({ ...toolDeps, skillsOps: auditOps(skillsService.ops) });
+        // 传 op 表而不是 promptsService：「生效中」的判定只有 `agentsmd-list` 里有（场景绑定
+        // 的那份才算），直调服务会得到文件比对口径 —— 场景驱动时工具会报一个与界面不同的答案。
+        buildPromptTools({ ...toolDeps, promptOps: auditOps(promptOps), applyPresetGuarded, promptsDir });
+        buildMemoryTools({ ...toolDeps, rulesOps: auditOps(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: auditOps(memoriesService.ops),
+            archiveOps: auditOps(archiveService.ops),
+            sceneActivate: auditFn('rules-set-active', (args) => handlers['rules-set-active'](args)),
         });
-        buildSkillTools({ ...toolDeps, skillsOps: skillsService.ops });
-        buildPromptTools({ ...toolDeps, promptsService, applyPresetGuarded, promptsDir });
-        buildMemoryTools({ ...toolDeps, rulesOps: memoriesService.ops });
         buildSubagentTools({
             ...toolDeps,
-            subagentService,
+            // 只换掉工具看到的 `ops` 那一层（原型链回真实服务，其余读法一字不动）。
+            subagentService: Object.assign(Object.create(subagentService), { ops: auditOps(subagentService.ops) }),
             sceneLists: subagentSceneLists,
             toolFilterFor: subagentToolFilterFor,
             failures: subagentFailures,
@@ -2292,15 +2597,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: '「写入记忆」',
-                memory_manager_update: '「修改记忆」',
+                // 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: '「运行子代理」',
-                subagent_manager_create: '「新建人设」',
-                subagent_manager_update: '「修改人设」',
-                // 模型侧只有这一个工具能塞进任意 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))
@@ -2325,80 +2643,123 @@ export default {
                     return true;
                 }
             };
-            /** `subagent_manager_update` 要改名已存在、`_create` 要目标未被占用。 */
-            const subagentWriteWouldApply = async (exec) => {
-                try {
-                    const a = (exec && exec.arguments) || {};
-                    const name = String(a.name || '').trim();
-                    if (!name)
-                        return false;
-                    const list = await subagentService.list();
-                    const has = (n) => list.some((p) => p.name === n);
-                    if (exec.name === 'subagent_manager_update') {
-                        const next = String(a.nextName || '').trim();
-                        return has(name) && (next === '' || next === name || !has(next));
-                    }
-                    return !has(name);
-                }
-                catch (e) {
-                    return true;
-                }
-            };
             ctx.on('tools/pre-execute', async (exec, next) => {
                 if (!exec || !CONFIRM_LABELS[String(exec.name)])
                     return next();
                 if (exec.name === 'subagent_manager_run' && !(await subagentManagerRunTargetExists(exec)))
                     return next();
-                if ((exec.name === 'subagent_manager_create' || exec.name === 'subagent_manager_update')
-                    && !(await subagentWriteWouldApply(exec)))
-                    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' || exec.name === 'memory_manager_update') {
+                if (exec.name === 'memory_manager_save') {
                     // D2：模型写规则默认需确认；设置关闭后直接放行。ask 无应答者时降级为拒绝（fail-closed），
                     // 不在此处做任何兜底放行。
-                    // `memory_manager_update` 走**同一个开关**：改一条记忆和建一条记忆动的是同一批文件，
-                    // 而改的破坏性更大（覆盖已有内容）—— 给它另设一档只会造出一个"改不用问、建要问"的倒挂。
-                    const what = exec.name === 'memory_manager_write'
-                        ? 'Write a memory under ~/.dsh/tool-management/memories'
-                        : 'Update an existing memory under ~/.dsh/tool-management/memories';
+                    // 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: what } : next()))
                         .catch(() => ({ kind: 'ask', reason: what }));
                 }
-                if (exec.name === 'subagent_manager_create' || exec.name === 'subagent_manager_update') {
-                    // 与 `skill_manager_create` 完全对称：往 hub 里落一份新文件 / 整份重写一份现有文件。
+                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 里落一份新文件 / 整份重写一份现有文件。
                     // 无条件问（不设开关）—— 人设是"以后每次委派都按它来"的长期资产，改错了影响的是
                     // 后续所有子代理的行为，而不是一次输出。
-                    // update 尤其：`subagent-update` 走 serializePersona 整份重写，改名还会连带改
+                    // 改分支尤其：`subagent-update` 走 serializePersona 整份重写，改名还会连带改
                     // 场景档案里的绑定 —— 那是一次会影响环境配置的操作，不是一句文案修改。
+                    // 建还是改要读一次现状才知道（工具侧也是执行时才读），所以这里查一下名单：
+                    // 只报"新建"会让一次整份重写看起来像加了个文件，反过来也一样。
                     const a = (exec && exec.arguments) || {};
-                    const what = exec.name === 'subagent_manager_create'
-                        ? `Create persona「${String(a.name || '')}」under ~/.dsh/tool-management/subagents`
-                        : `Rewrite persona「${String(a.name || '')}」${a.nextName ? ` and rename it to「${String(a.nextName)}」(scene-profile bindings follow the rename)` : ''}`;
+                    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），可关。
@@ -2670,6 +3031,10 @@ export default {
                                 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) {