dsh-plugin-tool-management 0.13.0 → 0.14.0

package/lib/index.js

@@ -29,13 +29,15 @@ 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, 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。这里保持原路径可导出，契约不变。
@@ -56,6 +58,7 @@ import { buildMcpTools } from './tools/mcp.js';
 import { buildSkillTools } from './tools/skills.js';
 import { buildPromptTools } from './tools/prompt.js';
 import { buildMemoryTools } from './tools/memory.js';
+import { buildSceneTools } from './tools/scene.js';
 import { buildSubagentTools } from './tools/subagent.js';
 import { createScenePromptSync } from './scene-prompt-sync.js';
 import { extractText } from './imports/parsers.js';
@@ -210,7 +213,7 @@ export default {
             memoriesRoot: String(config?.memoriesRoot || ''),
             stateDir: String(config?.memoriesStateDir || ''),
             scenesDir: String(config?.memoriesScenesDir || ''),
-            // 场景记忆段预算（字节），默认 65536；仅用于测试与特殊部署调优。
+            // 场景记忆段预算（字节），默认 131072（= DEFAULT_MAX_BYTES，128 KiB）；仅用于测试与特殊部署调优。
             ...(Number.isFinite(Number(config?.rulesMaxBytes))
                 ? { maxBytes: Number(config.rulesMaxBytes) }
                 : {}),
@@ -510,8 +513,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 +541,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 +570,9 @@ export default {
         }
         /**
          * 同步快照（热路径用：工具门禁每次调用、注入通道每个 step 都要问一句）。还没加载时先给
-         * 默认值并异步预热 —— 默认是"什么都没关"，预热前的这一瞬与用户的选择可能不一致，但
-         * 方向是安全的那一侧（不隐藏任何东西，绝不因为读盘慢而让工具凭空消失）。
+         * **空集**并异步预热 —— 空集不是出厂默认（出厂关着五条），是刻意的：预热前的这一瞬与
+         * 用户的选择可能不一致，但方向必须是安全的那一侧（不隐藏任何东西，绝不因为读盘慢而让
+         * 工具凭空消失）。
          */
         function toolTableHidden() {
             if (toolTableCache === null) {
@@ -564,27 +583,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 +660,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 +694,7 @@ export default {
             }
             return out;
         };
-        // ---------- 注入通道（场景和记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
+        // ---------- 注入通道（场景 / 记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
         // 这些文本以前是 systemPrompt 段（persona complete 会整段压掉）。现在改走官方的
         // 「每步注入一条合成消息」通道（skill-catalog / AGENTS.md / 时间上下文同款）：
         // 任何预设都到得了，内容没变不重发。**每个域一条自己的消息**（来源 kind 各不同，
@@ -759,16 +825,21 @@ export default {
                     // `catalogDepth` 字段的注释。目录正文也按同一个判据过滤（`text(agent)`），两处同源
                     // 所以不会分叉。
                     //
-                    // 记忆域（2026-09-17 用户裁定）：**只在顶层注入**。记忆是"父会话的现场"，不是子代理
-                    // 完成任务所需的事实 —— 而且它带着「一律照办，覆盖你的默认做法」这种强主张，塞进
-                    // 一次性子会话只会与角色定义争注意力（实测：子代理跑审查时，上下文里同时躺着人设与
-                    // 整份场景记忆）。子代理手里有 `memory_manager_list/read`，需要什么自己取；父代理
-                    // 上下文里也有记忆，相关事实应当由它写进 `task`（子代理的上下文 = 角色 + 任务）。
+                    // 场景与记忆（2026-09-17 用户裁定；2026-09-23 拆成两个域）：**都只在顶层注入**。
+                    // 记忆是"父会话的现场"，不是子代理完成任务所需的事实 —— 塞进一次性子会话只会与
+                    // 角色定义争注意力（实测：子代理跑审查时，上下文里同时躺着人设与整份记忆）。
+                    // 场景段同理：它说的是"父会话现在处在哪个模式"，而子代理根本没有"模式"可言。
+                    // 子代理手里有 `memory_manager_list/read` 与 `scene_manager_save`，需要什么自己取；
+                    // 父代理上下文里也有，相关事实应当由它写进 `task`（子代理的上下文 = 角色 + 任务）。
                     // 其余三域对任何深度都成立：提示词是用户规则（本插件的立身之本就是"覆盖到子代理"）、
                     // 技能目录与 MCP 状态是"操作这台机器所需的事实"（子代理手里就有 `skill` / `mcp__*`
                     // 工具，不知道清单就只能瞎调）。
                     domains: () => [
-                        { key: 'memory', name: 'tool-management:scene-memory', label: '场景和记忆', form: 'snapshot', text: () => memoriesService.memoryText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
+                        // 场景（**框架**）：启用的场景 + 场景说明（用户的约定）。排第一 —— 先让模型知道
+                        // "现在在哪个场景、这个场景的约定是什么"，再读下面的记忆条目。
+                        { key: 'scene', name: 'tool-management:scene', label: '场景', form: 'snapshot', text: () => memoriesService.sceneCatalogText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
+                        // 记忆（**内容**）：各场景下的条目。与场景段同源、同一条 `applicableTo`。
+                        { key: 'memory', name: 'tool-management:memory', label: '记忆', form: 'snapshot', text: () => memoriesService.memoryText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
                         { key: 'mcp', name: 'tool-management:mcp-state', label: 'MCP 服务器', form: 'catalog', text: () => mcp.stateCatalog.text() },
                         { key: 'skills', name: 'tool-management:skill-catalog', label: '技能目录', form: 'catalog', text: () => skillCatalog.text() },
                         {
@@ -1682,6 +1753,25 @@ export default {
             memoriesService,
             toolKeyParts,
         });
+        // 提示词预设域的 op 表。单独提出来是为了让**模型工具**能复用同一份判定：
+        // `prompt_manager_list` 以前直调 `promptsService.list()`，于是它报的「生效中」是
+        // **文件比对**口径（预设正文 == ~/.dsh/AGENTS.md），而界面报的是 `agentsmd-list` 的口径
+        // （启用的场景绑了预设时，**只有那份**算生效中）—— 同一件事两个答案，场景驱动时工具就在
+        // 说假话。工具改走 op 之后两边只有一份判定。
+        const promptOps = buildPromptOps({
+            promptsService,
+            scenePromptSync,
+            // 显式转发而不是整表传入：这两个 op 名字写死在这里，rules 域哪天改名会立刻红，
+            // 不会静默变成 undefined 调用。
+            rulesOps: {
+                'rules-list': (args) => memoriesService.ops['rules-list'](args),
+                'rules-rebind-prompt': (args) => memoriesService.ops['rules-rebind-prompt'](args),
+            },
+            applyPresetGuarded,
+            withAgentsMdSync,
+            promptRefReason,
+            warn: (m) => { ctx.logger?.warn?.(m); },
+        });
         const handlers = {
             'plugin-version': pluginVersion,
             'skill-open': skillOpen,
@@ -1729,23 +1819,8 @@ export default {
                 message,
                 compatLog,
             }),
-            // AGENTS.md / 提示词预设域（ops/prompts.ts 提供）：agentsmd-list / read / create /
-            // update / apply / get-current / remove / import / trash-list / trash-restore /
-            // trash-delete。
-            ...buildPromptOps({
-                promptsService,
-                scenePromptSync,
-                // 显式转发而不是整表传入：这两个 op 名字写死在这里，rules 域哪天改名会立刻红，
-                // 不会静默变成 undefined 调用。
-                rulesOps: {
-                    'rules-list': (args) => memoriesService.ops['rules-list'](args),
-                    'rules-rebind-prompt': (args) => memoriesService.ops['rules-rebind-prompt'](args),
-                },
-                applyPresetGuarded,
-                withAgentsMdSync,
-                promptRefReason,
-                warn: (m) => { ctx.logger?.warn?.(m); },
-            }),
+            // AGENTS.md / 提示词预设域（ops/prompts.ts 提供，见上方 promptOps）。
+            ...promptOps,
             // 归档会话域（ops/history.ts 提供）：history-list / history-sessions /
             // history-export-defaults / dir-list / history-archive / history-archive-batch /
             // history-unarchive / history-delete / history-unarchive-batch / history-delete-batch /
@@ -1785,6 +1860,7 @@ export default {
             ...buildCandidateOps({
                 presetToolCandidates: candidates.presetToolCandidates,
                 modelCandidates: candidates.modelCandidates,
+                modelReasoning: candidates.modelReasoning,
                 getToolFailures: () => subagentToolFailures,
                 mcpmListView: mcp.mcpmListView,
                 toolStates: candidates.toolStates,
@@ -2262,6 +2338,8 @@ export default {
             register: (def) => { recordToolSize(def); tools.register(def); },
             lockedSceneGuard,
             syncSwitchToScene,
+            // 错误句里点名工具前要先问一句（判据与两个目录的 `listToolVisible` 同一份缓存）。
+            toolVisible: (name) => !toolTableHidden().has(name),
             reachNoticeForAgent,
             presetRoster: candidates.presetRoster,
             injectNoticeOptions,
@@ -2270,13 +2348,38 @@ export default {
         buildMcpTools({
             ...toolDeps,
             mcpmListView: mcp.mcpmListView,
+            mcpmTools: mcp.ops['mcpm-tools'],
             mcpmSetEnabled: mcp.ops['mcpm-set-enabled'],
             mcpmRestart: mcp.ops['mcpm-restart'],
+            mcpmToolEnabled: mcp.ops['mcpm-tool-enabled'],
             mcpmAdd: mcp.ops['mcpm-add'],
+            mcpmEdit: mcp.ops['mcpm-edit'],
+            mcpmNote: mcp.ops['mcpm-note'],
+            // **故意不接 `mcpm-reveal`**：`mcp_manager_save` 的改分支用 `mcpmListView()` 的
+            // 打码视图填回省略字段，由 `mcpm-edit` 的 `resolveMaskedKv` / `resolveMaskedUrl`
+            // 还原真值 —— 那条路本来就是给"表单里出现打码值"设计的（界面编辑框预填的就是它）。
+            // 让模型驱动的工具在进程内读明文凭据，是另一条没人设计过、也没有测试覆盖的路径。
         });
         buildSkillTools({ ...toolDeps, skillsOps: skillsService.ops });
-        buildPromptTools({ ...toolDeps, promptsService, applyPresetGuarded, promptsDir });
+        // 传 op 表而不是 promptsService：「生效中」的判定只有 `agentsmd-list` 里有（场景绑定
+        // 的那份才算），直调服务会得到文件比对口径 —— 场景驱动时工具会报一个与界面不同的答案。
+        buildPromptTools({ ...toolDeps, promptOps, applyPresetGuarded, promptsDir });
         buildMemoryTools({ ...toolDeps, rulesOps: memoriesService.ops });
+        // 场景族（tools/scene.ts）：列场景与档案（`_list`）+ 建场景 / 写档案 / 绑提示词（`_save`）
+        // + 进入与退出（`_switch`）。
+        // 传**包装后**的 `archiveService.ops`：`scene-archive-save` 与 `scene-mode-set` 都在本文件
+        // 被包了一层（前者联动人设开关、后者带锁定守卫与目录重算），工具走同一条路才有同一套行为。
+        //
+        // `sceneActivate` 传的是 **handlers 表里那份**（`buildSceneSyncOps` 覆盖过的）：AGENTS.md
+        // 同步在包装里，直调 `memoriesService.ops['rules-set-active']` 会静默漏掉"把场景绑定的
+        // 预设正文写进 `~/.dsh/AGENTS.md`、退出时恢复基线"这一步。传 handlers 里那份而不是在这里
+        // 再包一次，是为了让工具与 HTTP API 共用同一个实现（不会各自漂移）。
+        buildSceneTools({
+            ...toolDeps,
+            rulesOps: memoriesService.ops,
+            archiveOps: archiveService.ops,
+            sceneActivate: (args) => handlers['rules-set-active'](args),
+        });
         buildSubagentTools({
             ...toolDeps,
             subagentService,
@@ -2292,15 +2395,28 @@ export default {
             // 在完全权限下的行为一致；探测实现与回归测试见 approval-policy.ts（必须 ctx.get('approval')，
             // 不能用 ctx.approval——inject 未声明该服务时 cordis 代理会抛 "cannot get property without inject"）。
             const CONFIRM_LABELS = {
-                skill_manager_create: '「新建技能」',
-                memory_manager_write: '「写入记忆」',
-                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 +2441,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），可关。

package/lib/mcp/manager.js

@@ -23,7 +23,7 @@ import { hubPath } from '../hub.js';
 import { planOverrideCompaction } from './override-blocks.js';
 import { createMcpStateCatalog } from './state-section.js';
 import { appendBlock, buildDisableBlock, buildInsertBlock, parseRows, removeEntryAll, removeMarked, spliceRanges, splitLines, } from './patch-yaml.js';
-import { describeMaskedOutcome, maskedKeysIn, resolveMaskedKv, resolveMaskedUrl } from './secret-guard.js';
+import { describeMaskedOutcome, maskUrlQuery, maskedKeysIn, resolveMaskedKv, resolveMaskedUrl } from './secret-guard.js';
 /**
  * 归一化「已知工具」侧车的一行值。
  *
@@ -653,19 +653,8 @@ export function createMcpManager(deps) {
         }
         return out;
     }
-    function maskUrlQuery(url) {
-        if (!url)
-            return url;
-        try {
-            const parsed = new URL(url);
-            if (parsed.search)
-                parsed.search = '?<redacted>';
-            return parsed.toString();
-        }
-        catch (e) {
-            return url;
-        }
-    }
+    // `maskUrlQuery` 已挪到 ./secret-guard.js：那里是两条打码形态的唯一口径，而使用方
+    // 现在有两个（本文件的列表视图 + index.ts 的确认卡）。
     /** Shared UI rows: mcpmList plus notes, secrets masked unless `reveal`. */
     async function mcpmRowsWithNotes(reveal) {
         const result = await mcpmList();

package/lib/mcp/secret-guard.js

@@ -69,6 +69,27 @@ export function isMaskedUrl(value) {
         return false;
     }
 }
+/**
+ * 把 URL 的查询串换成 `<redacted>` 哨兵 —— 打码的**产出**侧，与上面的 `isMaskedUrl` 配对。
+ *
+ * 放在这里而不是 manager.ts 里：本模块是这两条打码形态的唯一口径，而使用方已经有两个
+ * ——MCP 列表视图（`mcpmRowsWithNotes`），以及模型调 `mcp_manager_save` 时的确认卡
+ * （卡里要回显"新 URL"，但用户批准的是「跑这个地址」，查询串里的凭据不该明文进卡片）。
+ * 两处各写一份的话，改了一处就会漂成两种打码形态，而 `isMaskedUrl` 只认其中一种。
+ */
+export function maskUrlQuery(url) {
+    if (!url)
+        return url;
+    try {
+        const parsed = new URL(url);
+        if (parsed.search)
+            parsed.search = '?' + URL_REDACTED_QUERY;
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
 /**
  * 把表单来的 URL 收敛成"可以安全写盘"的一个（与 `resolveMaskedKv` 同方向：往旧值收）。
  *