dsh-plugin-tool-management 0.16.6 → 0.18.0

package/lib/request-gate.js

@@ -4,18 +4,19 @@
 //   * 访问令牌（可选）—— 两条用途：宿主浏览器鉴权的逃生口，以及写操作的纵深防御；
 //   * 写 / 敏感 op 白名单 —— 哪些 op 要凭令牌（含"只读但会泄露明文"与"只读但会改宿主状态"）；
 //     清单本身在 `./op-registry.ts`，本文件只拼装（`opsWith` / `frozenOps`）。
-//   * 场景锁定 —— 任一场景 locked=true 时五个管理域整体冻结；
+//   * 场景锁定 —— 任一场景 locked=true 时五个管理域整体冻结。判据是 `createFrozenGate`，
+//     HTTP handlers 与**模型侧 op 表**各装一次，用的是同一份函数；
 //   * handlers 后处理 —— 把上面三条装到 op 表上（包装顺序即语义，见 installHandlerGuards）。
 //
 // 为什么抽出来：四段分散在 apply() 的 220 / 902 / 1650 / 1928，靠闭包共享 handlers 与
 // memoriesService。抽成工厂后依赖改为显式入参，index.ts 只剩四行装配 —— 而引用点用解构
 // 保持原名字，一行没动（改名才是这类搬迁最容易出静默错误的地方）。
 //
-// **一处必须守住的不变量**：handlers 的后处理顺序。`guardLockedOps` / `syncSceneArchiveOnSwitch`
+// **一处必须守住的不变量**：handlers 的后处理顺序。冻结包装 / `syncSceneArchiveOnSwitch`
 // 都是「读原函数 → 换包装」的原地改写，先装的在内层、后装的在外层；`annotateLocked` 只挂在
 // 五个读 op 上。整段照搬、顺序未变。
 import { createHash, timingSafeEqual } from 'node:crypto';
-import { frozenOps, opsWith } from './op-registry.js';
+import { OP_REGISTRY, frozenOps, opsWith } from './op-registry.js';
 /**
  * 建访问令牌三件套。**必须**从 apply 的第二个参数取配置 ——
  * 读 `ctx.config` 不是注入服务，启动时会抛 "cannot get property without inject"。
@@ -114,10 +115,13 @@ export function createOpWhitelist(deps) {
 }
 // ---------- 场景锁定守卫（v0.8）----------
 // 任一场景 locked=true = 五个管理域（MCP/技能/子智能体/记忆/提示词）整体冻结：
-// 下面列出的写 op 一律拒绝；界面按钮同步禁用，这里是兜底（防止绕过界面直接打 op）。
-// 只包 **handlers** 这一层是有意的：进/退模式的运行时应用走的是内部函数与
-// service.ops（applyMcpServerSwitches / applySkills / applySubagentSwitches / patchIndex），
-// 不经过 handlers —— 锁定就是为了让场景能按原样启动，运行时应用不能被自己挡住。
+// 冻结清单里的写 op 一律拒绝；界面按钮同步禁用，这里是兜底（防止绕过界面直接打 op）。
+//
+// 装在**哪一层**：HTTP handlers 一层 + 模型侧 op 表一层（index.ts 的 `auditOps`），
+// 两层用同一个判据（`createFrozenGate`）。**不装在 service.ops 上**是有意的：进/退模式的
+// 运行时应用走的是内部函数与 service.ops（applyMcpServerSwitches / applySkills /
+// applySubagentSwitches / patchIndex），不经过 handlers —— 锁定就是为了让场景能按原样启动，
+// 运行时应用不能被自己挡住。
 // 例外里的例外：scene-archive-save / rules-remove-scene 只对**被锁的那个场景**拒绝。
 export function createSceneLock(deps) {
     async function lockedSceneNames() {
@@ -144,12 +148,104 @@ export function createSceneLock(deps) {
     }
     return { lockedSceneNames, activeSceneName, lockedSceneGuard };
 }
+/** 「改它」的兜底动词（登记表里没有专门文案时用）。 */
+const FROZEN_DEFAULT_VERB = '修改';
+const ACTIVE_SCENE_LABEL = { 'rules-set-active': '切换场景' };
+const SELF_SCENE_LABEL = { 'scene-archive-save': '改档案', 'rules-remove-scene': '删除' };
+/**
+ * 场景冻结的**唯一判据**：`op` + `args` → 拒绝文案（null = 放行）。
+ *
+ * 三种口径的语义登记在 `./op-registry.ts` 的 `frozenScope` 上，这里只实现：
+ *   all          —— 只要有场景锁着就拒（不看 args）。
+ *   active-scene —— 只在"锁着的场景正在生效"且这次提交**改了启用集合**时拒
+ *                   （同集合的重复提交放行：它没改变任何东西，不该被"冻结"挡下来）。
+ *   self-scene   —— 只挡被锁的那个场景自己（目标从 `args.scene` / `args.name` 取）。
+ *
+ * 为什么抽成一个函数：HTTP handlers 与**模型侧 op 表**（index.ts 的 `auditOps`）必须用
+ * 同一份判据。此前只包 handlers —— 模型工具拿的是 `service.ops`，于是"锁一个**非活动**
+ * 场景"在 HTTP 上被拒、在模型侧五个域全放行（审查 F3，0.17.0 修）。判据只写一遍，
+ * 两侧就不可能再分家。
+ *
+ * 判据只读 `args`、不落盘，所以对同一次调用可以安全地判两次（handlers 与模型侧各一次）。
+ */
+export function createFrozenGate(deps) {
+    const { lockedSceneNames, activeSceneName } = deps;
+    return async function frozenRejection(op, args) {
+        const cls = OP_REGISTRY[op];
+        if (!cls || cls.frozen !== true)
+            return null;
+        const scope = cls.frozenScope ?? 'all';
+        if (scope === 'active-scene') {
+            const scene = await activeSceneName();
+            if (!scene || !(await lockedSceneNames()).includes(scene))
+                return null;
+            const current = new Set([scene]);
+            const next = new Set((Array.isArray(args && args.scenes) ? args.scenes : [])
+                .map((n) => String(n == null ? '' : n).trim())
+                .filter((n) => n !== ''));
+            const same = current.size === next.size && [...current].every((n) => next.has(n));
+            if (same)
+                return null;
+            const what = ACTIVE_SCENE_LABEL[op] ?? '改它';
+            return `场景「${scene}」已锁定：先到场景页解锁再${what}（锁定期间改启用集合会让模型侧的写门禁失效）`;
+        }
+        if (scope === 'self-scene') {
+            const scene = String((args && (args.scene || args.name)) || '').trim();
+            if (!scene)
+                return null;
+            if (!(await lockedSceneNames()).includes(scene))
+                return null;
+            return `场景「${scene}」已锁定：先解锁再${SELF_SCENE_LABEL[op] ?? '改它'}`;
+        }
+        const locked = await lockedSceneNames();
+        return locked.length ? `场景已锁定（${locked.join('、')}）：先到场景页解锁再${FROZEN_DEFAULT_VERB}` : null;
+    };
+}
+// ── 3.6 模型侧 op 表的冻结闸（与 handlers 同一份判据）────────────────────────
+/**
+ * 给**模型侧**的 op 表装冻结闸（审查 F3，0.17.0）。
+ *
+ * 为什么抽成一个函数、而不是在 index.ts 里手写 for 循环：模型侧与 HTTP 侧必须用**同一个**
+ * `frozen` 判据对象。写成两个循环、各自去 `createFrozenGate`，就给了"两边又分家"的机会 ——
+ * 而 F3 的成因正是两侧判据不同。抽出来之后，契约测试可以直接拿真实的 `createFrozenGate`
+ * 与真实的 `installHandlerGuards` 对同一个 op 比对两侧结论。
+ *
+ * **不改动传入的表**：返回新表。场景引擎直调的是原表（`applySkills` → `service.ops`），
+ * 装在原表上会把场景自己锁死。
+ *
+ * @param ops    原始 op 表
+ * @param frozen `createFrozenGate(...)` 的返回值
+ * @param after  成功后的回调（挂流水用）。被拒时**不调用** —— 什么都没改。
+ */
+export function guardModelOps(ops, frozen, after) {
+    const out = {};
+    for (const [opName, fn] of Object.entries(ops)) {
+        if (typeof fn !== 'function') {
+            out[opName] = fn;
+            continue;
+        }
+        out[opName] = async (args) => {
+            const denied = await frozen(opName, args || {});
+            if (denied)
+                return { ok: false, error: denied };
+            const result = await fn(args || {});
+            if (after)
+                after(opName, args || {}, result);
+            return result;
+        };
+    }
+    return out;
+}
+/** 单个 op 版本（`guardModelOps` 的一元特例）：给不经 op 表的调用点用。 */
+export function guardModelOp(opName, fn, frozen, after) {
+    return guardModelOps({ [opName]: fn }, frozen, after)[opName];
+}
 export function installHandlerGuards(deps) {
     const { handlers, lockedSceneNames, activeSceneName, syncSwitchToScene, subagentToolFailures } = deps;
     /**
      * 包一层：开关成功后把改动同步进当前场景档案（见 syncSwitchToScene）。
      * 失败只挂 `sceneSyncError`，不改写原操作的成功结论 —— 运行时确实改了，档案没跟上要说得清。
-     * 锁定仍由 `guardLockedOps` 挡住（更靠内的那层包装先执行）。
+     * 锁定由更靠内的冻结包装挡住（先装的在内层，它返回 `ok:false` 时这里不会去同步档案）。
      */
     function syncSceneArchiveOnSwitch(opNames) {
         for (const opName of opNames) {
@@ -165,64 +261,27 @@ export function installHandlerGuards(deps) {
             };
         }
     }
-    function guardLockedOps(opNames, what) {
-        for (const opName of opNames) {
+    // 冻结清单与档案同步清单都来自 `./op-registry.ts`：加 op 时在那里登记一条，这里不再抄。
+    // 三种口径（all / active-scene / self-scene）现在合成**一个**判据函数（`createFrozenGate`），
+    // 由 `frozenOps()`（不带 scope = 全部冻结 op）一次装完。原先它们分散成三段手写包装，
+    // 而模型侧 op 表压根没装 —— 这正是 F3 的成因（见 `createFrozenGate` 的注释）。
+    // 包装顺序不变：冻结仍在**内层**，`syncSceneArchiveOnSwitch` 在外层（前者返回 ok:false 时
+    // 后者不会去同步档案）。
+    {
+        const frozen = createFrozenGate({ lockedSceneNames, activeSceneName });
+        for (const opName of frozenOps()) {
             const original = handlers[opName];
             if (typeof original !== 'function')
                 continue;
             handlers[opName] = async (args) => {
-                const locked = await lockedSceneNames();
-                if (locked.length)
-                    return { ok: false, error: `场景已锁定（${locked.join('、')}）：先到场景页解锁再${what}` };
-                return original(args);
+                const denied = await frozen(opName, args);
+                return denied ? { ok: false, error: denied } : original(args);
             };
         }
     }
-    // 冻结清单与档案同步清单都来自 `./op-registry.ts`：加 op 时在那里登记一条，这里不再抄。
-    guardLockedOps(frozenOps('all'), '修改');
     // 场景内「开关」类操作（用户裁定 2026-09-17）：未锁定时**可用**，改动同步进当前场景档案。
     // 与「锁定」正交：锁定冻结全部写操作，这里只是把页面开关的意图也写进档案。
     syncSceneArchiveOnSwitch(opsWith('syncsArchive'));
-    // 口径 `frozenScope: 'active-scene'` 的那几条（判据与理由登记在 op-registry.ts 的
-    // `rules-set-active` 条目上）。没有锁定场景在生效时（全局态 / 场景未锁）照旧可用。
-    const ACTIVE_SCENE_LABEL = { 'rules-set-active': '切换场景' };
-    for (const opName of frozenOps('active-scene')) {
-        const what = ACTIVE_SCENE_LABEL[opName] ?? '改它';
-        const original = handlers[opName];
-        if (typeof original !== 'function')
-            continue;
-        handlers[opName] = async (args) => {
-            const scene = await activeSceneName();
-            if (scene && (await lockedSceneNames()).includes(scene)) {
-                // 同集合的重复提交放行：它没有改变任何东西，不该被"冻结"挡下来。
-                const current = new Set([scene]);
-                const next = new Set((Array.isArray(args && args.scenes) ? args.scenes : [])
-                    .map((n) => String(n == null ? '' : n).trim())
-                    .filter((n) => n !== ''));
-                const same = current.size === next.size && [...current].every((n) => next.has(n));
-                if (!same) {
-                    return { ok: false, error: `场景「${scene}」已锁定：先到场景页解锁再${what}（锁定期间改启用集合会让模型侧的写门禁失效）` };
-                }
-            }
-            return original(args);
-        };
-    }
-    // 被锁场景自身的档案与删除：只挡它自己，别的场景照常（口径 `frozenScope: 'self-scene'`）。
-    // 目标场景一律从 `args.scene` / `args.name` 里取 —— 这两个键名就是本插件 op 的惯例。
-    const SELF_SCENE_LABEL = { 'scene-archive-save': '改档案', 'rules-remove-scene': '删除' };
-    for (const opName of frozenOps('self-scene')) {
-        const what = SELF_SCENE_LABEL[opName] ?? '改它';
-        const original = handlers[opName];
-        if (typeof original !== 'function')
-            continue;
-        handlers[opName] = async (args) => {
-            const scene = String((args && (args.scene || args.name)) || '').trim();
-            const locked = await lockedSceneNames();
-            if (scene && locked.includes(scene))
-                return { ok: false, error: `场景「${scene}」已锁定：先解锁再${what}` };
-            return original(args);
-        };
-    }
     // 各页列表响应带上 anyLocked + activeScene：界面据此禁用写控件、并说明
     // 「当前处于场景 X，开关请到档案里改」（读 op，附加字段不影响既有消费方）。
     async function annotateLocked(res) {

package/lib/scene-linkage.js

@@ -0,0 +1,184 @@
+export function installSceneLinkage(deps) {
+    /**
+     * 人设改名后同步场景绑定：场景档案的 `subagents` 名单存的是**人设名**，
+     * 不跟着改就会留一个悬空引用（界面把它报成 stale，用户看到「人设不存在」却找不到地方改）。
+     * 绑定存在 memories-index.json 里，人设服务看不到它，所以在这一层补一次（同提示词改名的做法）。
+     */
+    async function rebindSubagentInArchives(from, to) {
+        try {
+            const slice = await deps.memoriesService.readArchiveSlice();
+            const touched = {};
+            for (const [scene, archive] of Object.entries(slice.archives || {})) {
+                const list = archive.subagents;
+                if (!Array.isArray(list) || !list.includes(from))
+                    continue;
+                touched[scene] = { ...archive, subagents: list.map((n) => (n === from ? to : n)) };
+            }
+            const names = Object.keys(touched);
+            // 逐场景增量（审查 P2-3）：此前整表回写，会把窗口期里别人保存的**别的场景**档案抹掉。
+            for (const scene of names)
+                await deps.memoriesService.saveArchive(scene, touched[scene]);
+            return names.length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * 人设改名后同步运行时快照（F-025）：退出还原按 `subagentsAll` 逐名走，快照里
+     * 还留着旧名的话，退出会「旧名静默跳过、新名不还原」—— 被改名的人设停留在
+     * 场景期间状态。快照在进入场景时拍、改名发生在进入后，只能在改名时跟着改。
+     */
+    async function renameSubagentInSnapshot(from, to) {
+        try {
+            const slice = await deps.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 deps.memoriesService.patchIndex({ mode: { ...mode, snapshot: next } });
+        }
+        catch { /* 快照同步失败不阻断改名本身；残留与修复前一致 */ }
+    }
+    const baseSubagentUpdate = deps.subagentService.ops['subagent-update'];
+    if (typeof baseSubagentUpdate === 'function') {
+        deps.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;
+        };
+    }
+    /**
+     * 快捷提示词改名后同步场景档案（与人设改名那两条同一件事）：档案里存的还是旧 id 的话，
+     * 下一次进场景它会被当成 stale 丢掉 —— 用户看到的就成了"改了个名字，场景里的勾选悄悄没了"，
+     * 而且那条快捷词还会在进场景时被停用（它不在勾选集里了）。
+     */
+    async function rebindQuickPromptInArchives(from, to) {
+        try {
+            const slice = await deps.memoriesService.readArchiveSlice();
+            const touched = [];
+            for (const [scene, archive] of Object.entries(slice.archives || {})) {
+                const list = archive.quickPrompts;
+                if (!Array.isArray(list) || !list.includes(from))
+                    continue;
+                touched.push([scene, { ...archive, quickPrompts: list.map((n) => (n === from ? to : n)) }]);
+            }
+            // 逐场景增量写（与审查 P2-3 同一条口径）：整表回写会抹掉窗口期里别人存的别的场景。
+            for (const [scene, next] of touched)
+                await deps.memoriesService.saveArchive(scene, next);
+        }
+        catch { /* 同步失败不阻断改名本身；残留由档案保存时的 stale 清理兜住 */ }
+    }
+    const baseQuickPromptUpdate = deps.quickPromptOps['quickprompt-update'];
+    if (typeof baseQuickPromptUpdate === 'function') {
+        deps.quickPromptOps['quickprompt-update'] = async (args) => {
+            const res = await baseQuickPromptUpdate(args);
+            if (res && res.ok !== false && res.renamedFrom)
+                void rebindQuickPromptInArchives(String(res.renamedFrom), String(res.id));
+            return res;
+        };
+    }
+    // 模式切换会改人设开关（进入=启用勾选的，退出=按快照停回）——目录段立即重算，
+    // 别等 1s TTL：切完场景紧接着的下一轮请求就该看到新名单。
+    const baseSceneModeSet = deps.archiveService.ops['scene-mode-set'];
+    if (typeof baseSceneModeSet === 'function') {
+        deps.archiveService.ops['scene-mode-set'] = async (args) => {
+            // 锁定的场景不能关闭（用户裁定）：退出模式（scene=null）和切换到别的场景
+            // 都意味着先退出当前模式 —— 当前模式场景处于锁定状态时一律拒绝。
+            // 目标就是当前场景 = 无操作，放行（引擎自己会 early-return）。
+            try {
+                const slice = await deps.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 deps.lockedSceneNames();
+                        if (locked.includes(current)) {
+                            return { ok: false, error: `场景「${current}」已锁定：先解锁再关闭` };
+                        }
+                    }
+                }
+            }
+            catch { /* 守卫读状态失败不拦正常流程（引擎自身校验兜底） */ }
+            const res = await baseSceneModeSet(args);
+            if (res && res.ok !== false) {
+                // 进/退/切换模式会改 MCP 启停（服务器级）与备注（场景备注覆盖/恢复），
+                // 状态段必须立即重算 —— 场景退出后下一次请求就该看到恢复的全局备注与启停。
+                void deps.subagentCatalog.refresh().catch(() => { });
+                void deps.mcp.stateCatalog.refresh().catch(() => { });
+            }
+            return res;
+        };
+    }
+    /**
+     * 模式进行中保存当前场景的档案时，联动人设开关：**档案 = 这个场景开着的人设**
+     * （与进入场景时同一口径，见 archive-engine）——
+     *   新勾进来的立即启用，并追加进快照的「退出时停回」名单；
+     *   取消勾选的立即停用；其中「进场景前就开着」的那些追加进快照的「退出时开回」名单
+     *   （在停回名单里的说明是本次进场景才打开的，退出本来就该关，不进开回名单）。
+     */
+    const baseSceneArchiveSave = deps.archiveService.ops['scene-archive-save'];
+    if (typeof baseSceneArchiveSave === 'function') {
+        deps.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 deps.memoriesService.readArchiveSlice();
+                const mode = slice.mode;
+                if (mode && mode.scene === res.scene) {
+                    const every = (await deps.subagentService.list()).map((p) => p.name);
+                    const unbound = every.filter((n) => bound.indexOf(n) < 0);
+                    const toOn = await deps.subagentService.enabledStore.disabledAmong(bound);
+                    const toOff = await deps.subagentService.enabledStore.enabledAmong(unbound);
+                    if (toOn.length)
+                        await deps.subagentService.enabledStore.setEnabled(toOn, true);
+                    if (toOff.length)
+                        await deps.subagentService.enabledStore.setEnabled(toOff, false);
+                    if (toOn.length || toOff.length)
+                        void deps.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 deps.memoriesService.patchIndex({ mode: { ...mode, snapshot: { ...snapshot, subagents: backOn, subagentsOn: offList } } });
+                    }
+                }
+            }
+            catch { /* 联动失败不阻断档案保存本身；开关会在下次进/退模式时对齐 */ }
+            return res;
+        };
+    }
+}

package/lib/scene-prompt-sync.js

@@ -24,8 +24,11 @@
 //   `driver()`     —— 谁在驱动基线（提示词页「应用」据此判断：应用别的份 = 换掉该场景的绑定）；
 //   `refs()`       —— 每个预设被谁引用（删除保护的唯一依据：场景绑定 / 基线当前内容 / 退出恢复目标）；
 //   `baseline()`   —— 进场景前的基线快照（退出场景后要恢复的那一份）。
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, stat } from 'node:fs/promises';
 import { dirname } from 'node:path';
+// 基线快照走原子写（temp + rename）：它是「退出场景时恢复 AGENTS.md」的**唯一依据**，
+// 裸写中断留下半截 JSON 会让 `readBaseline` 解析失败（审查 P2-16）。
+import { writeFileAtomically } from './memories/index-io.js';
 export function createScenePromptSync(deps) {
     const warn = (message) => { try {
         deps.logger?.warn?.(message);
@@ -48,13 +51,35 @@ export function createScenePromptSync(deps) {
             return null;
         }
     }
+    /** 快照文件是否**存在**（不看内容）。用来把「没有快照」与「快照读不出来」分开。 */
+    async function baselineExists() {
+        try {
+            return (await stat(deps.baselineFile)).isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 写基线快照。**失败必须让调用方看得见**（2026-09-30 审查 F14）。
+     *
+     * 原来这里 catch 后只 `warn` 并返回 void，于是「快照没写成」与「写成了」在调用方眼里
+     * 完全一样 —— 结果就是：AGENTS.md 被切到场景态、而退出场景时恢复不回来，用户看到的是
+     * 「没场景驱动所以什么都没做」。这正是「看起来成功」那类失败。
+     * @returns 失败原因（原样回给调用方拼进提示）；成功返回 null。
+     */
     async function writeBaseline(next) {
         try {
             await mkdir(dirname(deps.baselineFile), { recursive: true });
-            await writeFile(deps.baselineFile, JSON.stringify(next), 'utf8');
+            // 原子写（2026-09-30 审查 P2-16）：裸写在中断/断电时会留下半截 JSON → `readBaseline`
+            // 解析失败返回 null → 退出场景**不恢复** AGENTS.md，用户的提示词基线悄悄留在场景态。
+            await writeFileAtomically(deps.baselineFile, JSON.stringify(next));
+            return null;
         }
         catch (e) {
-            warn(`scene-prompt: could not persist baseline: ${String(e)}`);
+            const reason = String(e);
+            warn(`scene-prompt: could not persist baseline: ${reason}`);
+            return reason;
         }
     }
     async function state() {
@@ -157,25 +182,39 @@ export function createScenePromptSync(deps) {
                 return { applied: current.presetId, unchanged: true };
             // 进场景的第一笔写入之前，先记下当时的基线（已有快照就不覆盖：连续切场景时
             // 基线始终是"进场景之前"那一份）。
+            let baselineError;
             const saved = await readBaseline();
             if (!saved || saved.content === null) {
                 const cur = await deps.prompts.getCurrent();
-                await writeBaseline({
+                const failed = await writeBaseline({
                     v: 1,
                     at: Date.now(),
                     presetId: cur && cur.ok && cur.presetId ? String(cur.presetId) : null,
                     content: cur && cur.ok && cur.exists ? String(cur.content) : null,
                 });
+                // 基线写不进去 = 退出场景时恢复不回来。**照旧进场景**（那是用户的要求），
+                // 但必须当场说出来，别让用户以为还能退回去（审查 F14）。
+                if (failed !== null) {
+                    baselineError = `进场景前的提示词基线没能写入（${failed}）：AGENTS.md 已切到场景「${current.scene}」绑定的预设，但退出场景时恢复不回原来的内容（${deps.baselineFile}）。`;
+                }
             }
             const res = await deps.prompts.apply(current.presetId);
             if (res && res.ok === false)
-                return { error: String(res.error || '写入 AGENTS.md 失败') };
-            return { applied: current.presetId };
+                return { error: String(res.error || '写入 AGENTS.md 失败'), ...(baselineError ? { baselineError } : {}) };
+            return { applied: current.presetId, ...(baselineError ? { baselineError } : {}) };
         }
         // 没有场景驱动 → 如果刚从驱动态退出，把进场景前的基线写回去。
         const saved = await readBaseline();
-        if (!saved || saved.content === null)
+        if (!saved || saved.content === null) {
+            // 「没有快照」是常态（没进过场景）；「快照文件在、但读不出来」是**故障** ——
+            // 那意味着恢复目标丢了，AGENTS.md 的提示词基线会悄悄留在场景态。这里曾经一律
+            // 静默 `unchanged`，用户看到的是"没场景驱动所以什么都没做"（审查 P2-16）。
+            if (await baselineExists()) {
+                warn(`scene-prompt: baseline snapshot exists but is unreadable: ${deps.baselineFile}`);
+                return { error: `基线快照读不出来（文件可能损坏），未能恢复 AGENTS.md：${deps.baselineFile}` };
+            }
             return { unchanged: true };
+        }
         const res = await deps.prompts.restore(saved.content);
         if (res && res.ok === false)
             return { error: String(res.error || '恢复 AGENTS.md 失败') };

package/lib/scenes/candidates.js

@@ -13,6 +13,8 @@
 //
 // 依赖全部经 deps 显式传入。注意 \`toolKeyParts\` 留在 index.ts：场景档案引擎也在用它，
 // 放进本文件会让两个域互相引用。
+import { MCP_TOOL_PREFIX } from '../host-names.js';
+import { serverNameCandidates } from '../host-names.js';
 import { presetRosterOf } from '../compat/preset-reach.js';
 import { injectionFactsOf, readCompositionFacts, readCompositionText } from '../compat/preset-reach.js';
 /**
@@ -39,9 +41,25 @@ export function createCandidates(deps) {
             schemas = await tools.schemas();
         }
         catch { /* 无 live 工具 → 仅启停表 */ }
+        // 切分的候选 serverName 集合必须与 `serverKnownTools`（index.ts）同源 —— 同一批来源、
+        // 同一个 builder，否则「服务器名含 `__`」时两处会把同一个全名切成不同的 (server, tool)
+        // （2026-09-30 审查 N1）。三个来源里补丁那份是唯一与切分结果无关的（另两份是插件自己
+        // 写出来的：停用表键来自界面勾选、缓存键来自上一次切分），缺它会在首次遇到含 `__` 的名字时
+        // 切错并锁死。任一份读不到就退化为其余两份（少候选 = 少命中，不会多命中）。
+        let known = {};
+        try {
+            known = await mcp.readKnownMcpTools();
+        }
+        catch { /* 缓存不可读 → 仅停用表 */ }
+        let configured = [];
+        try {
+            configured = await mcp.configuredServerNames();
+        }
+        catch { /* 补丁读不到 → 仅另两份 */ }
+        const serverNames = serverNameCandidates(configured, disabled, known);
         const liveByServer = {};
         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 = liveByServer[p.server] || (liveByServer[p.server] = []);
@@ -214,7 +232,7 @@ export function createCandidates(deps) {
                         continue;
                     // MCP 工具名形如 `mcp__<server>__<tool>`：面向上百个条目，噪声大于价值 → 不进候选。
                     // 子代理照样能用当前在跑的 MCP —— 那份名单在 decideToolFilter 里运行时并进白名单。
-                    const names = (await presetToolNames(id)).filter((name) => !name.startsWith('mcp__'));
+                    const names = (await presetToolNames(id)).filter((name) => !name.startsWith(MCP_TOOL_PREFIX));
                     presets.push({
                         id,
                         name: String((p && (p.name || p.id)) || id),
@@ -236,7 +254,7 @@ export function createCandidates(deps) {
         }
         // 当前会话的工具即便没有任何预设可枚举，也要出现在候选里（否则选择器是空的）。
         for (const name of currentNames) {
-            if (name.startsWith('mcp__'))
+            if (name.startsWith(MCP_TOOL_PREFIX))
                 continue;
             const rec = byName.get(name) || { name, presets: new Set(), current: false };
             byName.set(name, rec);