dsh-plugin-tool-management 0.9.0 → 0.10.0

package/lib/index.js

@@ -10,18 +10,19 @@
 //
 // Build: `tsc -p tsconfig.json` compiles this to lib/index.js (the shipped
 // artifact — same convention as DSH's own packages, which ship compiled JS).
-import { defineTool } from '@deepseek-ai/dsh-tools';
+import { defineTool as hostDefineTool } from '@deepseek-ai/dsh-tools';
 import { createRequire } from 'node:module';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
 import { ArchiveWorkspaceRegistry as HistoryService, workspaceBaseName, workspacePathKey } from './history/workspace.js';
 import { createSkillsService, pluginLog } from './skills/service.js';
+import { renameWithRetry } from './skills/core.js';
 import { createAgentsMdService } from './agents-md/service.js';
 import { createRulesService, planMemoryExport } from './rules/service.js';
 import { createArchiveEngine } from './rules/archive-engine.js';
 import { createSubagentService, decideToolFilter, defaultPersonasDir } from './subagents/service.js';
 import { createSubagentCatalog } from './subagents/catalog.js';
 import { createSkillCatalog } from './skills/catalog.js';
-import { DEFAULT_INJECT_SETTINGS, createContextInjector, normalizeInjectSettings, } from './context-inject.js';
+import { DEFAULT_INJECT_SETTINGS, createContextInjector, normalizeInjectSettings, subagentDepthOf, } from './context-inject.js';
 import { isApprovalNever } from './approval-policy.js';
 import { EXPECTED_MIN_HOST_VERSION, EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, summarize } from './compat/probe.js';
 import { assessPresetReach, injectionFactsOf, presetRosterOf, readCompositionFacts, reachNoticeForAgent } from './compat/preset-reach.js';
@@ -34,7 +35,7 @@ import { defineSubagentManagerListTool, defineSubagentManagerRunTool } from './s
 import { detectFormat, extractText, parseGenericText, parseJsonlTranscript, parseMarkdownTranscript } from './imports/parsers.js';
 import { homedir } from 'node:os';
 import { spawn } from 'node:child_process';
-import { mkdir, readdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, rm, stat, unlink, writeFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { zipSync } from 'fflate';
 /**
@@ -154,6 +155,10 @@ export default {
         // is not an injected service and throws "cannot get property without
         // inject" at boot.
         const TOKEN = String(config?.token || process.env.DSH_PLUGIN_TOOL_MANAGEMENT_TOKEN || '').trim();
+        // 令牌比较走「双侧 sha256 → timingSafeEqual」：摘要定长 32 字节，无需长度分支
+        // （直接比较不等长 Buffer 会抛），逐字节的耗时不随匹配前缀长度变化 —— JS 的 ===
+        // 逐字符短路，理论上可被计时侧信道逐位猜测。
+        const tokenMatches = (presented) => timingSafeEqual(createHash('sha256').update(presented).digest(), createHash('sha256').update(TOKEN).digest());
         const wait = (ms) => ctx.timeout(ms);
         const message = (e) => String((e && e.message) || e);
         let writeChain = Promise.resolve();
@@ -284,12 +289,18 @@ export default {
             const states = {};
             const all = {};
             const shadowed = new Set();
+            const unloadable = new Set();
             for (const root of ((r && r.data && r.data.roots) || [])) {
                 for (const sk of (root.skills || [])) {
                     const name = String(sk.declaredName || sk.name || '');
                     if (!name)
                         continue;
                     const key = String(root.key || '') + '/' + name;
+                    // 结构不完整的技能在 core 里**一律拒绝启停**（error.skill.notLoadable）：
+                    // 档案里若残留这样的键，旧实现会把 `applySkills` 的"应用失败"抛出去，于是
+                    // **整个场景进不去**。这里单独收集，与「被覆盖」同口径处理（见 applySkills）。
+                    if (sk.loadable === false)
+                        unloadable.add(key);
                     if (sk.shadowedBy) {
                         shadowed.add(key);
                         all[key] = false;
@@ -300,7 +311,24 @@ export default {
                     all[key] = on;
                 }
             }
-            return { states, shadowed, all };
+            return { states, shadowed, all, unloadable };
+        }
+        /**
+         * 档案里**能写、且写了有意义**的技能键：既不被同名技能覆盖，结构也完整。
+         *
+         * 为什么要单独给一个集合：档案的语义是「勾选集 = 该场景下开着的东西」，而被覆盖的副本
+         * 永远不可能生效（`applySkills` 直接跳过），结构不完整的更是启停都被 core 拒绝 ——
+         * 它们进档案只会造成「档案说开着、运行时说关着」（用户实测：启动目录后档案里多出被覆盖
+         * 的那个技能，而技能页显示它并未启动）。保存档案时按这个集合校验，顺带清理历史残留。
+         */
+        async function selectableSkillKeys() {
+            const { shadowed, unloadable } = await skillScan();
+            const all = new Set(Object.keys(await skillStates()));
+            for (const k of shadowed)
+                all.delete(k);
+            for (const k of unloadable)
+                all.delete(k);
+            return all;
         }
         async function skillStates() {
             // knownSkillKeys 需要**全量键**（含被覆盖的副本）：场景档案里允许勾选任意一条技能，
@@ -333,6 +361,7 @@ export default {
                             name,
                             enabled: sk.enabled === true && !sk.shadowedBy,
                             shadowed: !!sk.shadowedBy,
+                            loadable: sk.loadable !== false,
                             rootKey,
                             rootLabel: String((root && root.label) || rootKey),
                             ...(root && root.localeKey ? { rootLocaleKey: String(root.localeKey) } : {}),
@@ -392,22 +421,31 @@ export default {
                 scheduleToolRestrictions();
             },
             knownSkillKeys: async () => new Set(Object.keys(await skillStates())),
+            // 档案保存校验用：被同名覆盖的副本与结构不完整的技能都不算「可勾选」（见 selectableSkillKeys）。
+            selectableSkillKeys,
             // 快照只取**真实生效**的条目（不含被同名覆盖的副本）——副本不参与模式应用，
             // 退出回放时也不该去动它们，否则会改写用户对副本的显式策略记录。
             currentSkills: async () => (await skillScan()).states,
             applySkills: async (target) => {
-                // 两道过滤，缺一不可：
+                // 三道过滤，缺一不可：
                 //  1. 被同名覆盖的副本直接跳过——它们本来就不生效，写策略只会污染用户的记录。
-                //  2. **已经处于目标状态的技能不再写**。`applySkills` 写的是显式策略记录，而目标
+                //  2. 结构不完整的技能也跳过——core 对它们一律拒绝启停（error.skill.notLoadable），
+                //     不跳过就会抛成"应用失败"，**整个场景进不去**（老档案里的残留键能踩到）。
+                //  3. **已经处于目标状态的技能不再写**。`applySkills` 写的是显式策略记录，而目标
                 //     状态是生效状态，两者不等价：对已经生效为「停用」的技能再 disable 一次，
                 //     只是把「没有记录」固化成「显式停用」，场景模式进出一次就会改写 state.json。
-                const { states, shadowed } = await skillScan();
+                const { states, shadowed, unloadable } = await skillScan();
                 for (const [key, on] of Object.entries(target)) {
                     const i = key.indexOf('/');
                     if (i <= 0)
                         throw new Error(`技能 key 不合法: ${key}`);
+                    // 被同名覆盖的副本跳过（它本来就不生效，写策略只会污染用户的记录）。
                     if (shadowed.has(key))
                         continue;
+                    // 结构不完整的技能跳过：core 对它们**一律拒绝启停**（error.skill.notLoadable），
+                    // 继续往下走会抛成"应用失败"，**整个场景就进不去了**（老档案里的残留键能踩到）。
+                    if (unloadable.has(key))
+                        continue;
                     if (states[key] === on)
                         continue;
                     const root = key.slice(0, i);
@@ -487,12 +525,38 @@ export default {
                 }
                 return out;
             },
+            /**
+             * 来源级启停（进入 / 退出 / 就地重应用共用）。
+             *
+             * 容错口径（用户 2026-09-17 报「退出模式失败 → 卡在场景里」之后加的）：**结构性**失败
+             * （来源解析不到 / 该来源本来就不允许启停）只记警告并跳过 —— 这一行与本次改动无关，
+             * 拿它中断整个恢复只会把用户困在场景里；**写盘**类失败仍然抛错，那说明确实没还原成功。
+             * 结构性失败的正解在 `skills/service.ts` 的 `requestSwitchRoot`（项目来源按 key 前缀解析）。
+             */
             applySkillSourceSwitches: async (switches) => {
+                const skipped = [];
                 for (const s of switches) {
                     const op = s.enabled ? 'skill-source-enable' : 'skill-source-disable';
-                    const r = await skillsService.ops[op]({ root: s.root });
-                    if (r && r.ok === false)
+                    let r;
+                    try {
+                        r = await skillsService.ops[op]({ root: s.root });
+                    }
+                    catch (e) {
+                        r = { ok: false, error: message(e), code: '' };
+                    }
+                    if (r && r.ok === false) {
+                        const code = String((r && r.code) || '');
+                        const structural = code === 'error.root.readonly' || code === 'error.root.unknown' ||
+                            /来源不存在|不允许启用或停用/.test(String(r.error || ''));
+                        if (structural) {
+                            skipped.push(`${s.root}（${r.error}）`);
+                            continue;
+                        }
                         throw new Error(`技能来源 ${s.root} ${s.enabled ? '启用' : '停用'}失败：${r.error}`);
+                    }
+                }
+                if (skipped.length) {
+                    ctx.logger?.warn?.(`scene: 跳过无法启停的技能来源 —— ${skipped.join('、')}`);
                 }
             },
             sceneExists: async (name) => {
@@ -513,7 +577,7 @@ export default {
                     await subagentService.enabledStore.setEnabled(on, true);
                 void subagentCatalog.refresh();
             },
-            // 记忆 id 全集（保存 memories 段时校验并报 stale）。
+            // 记忆 id 全集。引擎已不消费（memories 段 P5 起废弃），实现保留以维持接口形状。
             knownMemoryIds: async () => {
                 const r = await rulesService.ops['rules-list']({});
                 return new Set(((r && r.rules) || []).filter((x) => !x.shadowed).map((x) => String(x.id)));
@@ -638,6 +702,12 @@ export default {
                 return undefined;
             }
         }
+        // 注入实况（只读诊断）：注入器的 live() 读回"最近活跃会话"可见表面上的五域文本。
+        // 挂在 apply 作用域：`injection-live` op 与注入器不在同一层（effect 内部）。
+        let contextInjectorLive = null;
+        // 采纳遥测的入口（同样是 apply 作用域的中转）：工具注册在 effect 之外，
+        // 拿不到 effect 内部的 `injector`；经这个 `let` 中转，热更新重建注入器也能跟上。
+        let contextInjectorNote = null;
         try {
             ctx.effect(() => {
                 const injector = createContextInjector({
@@ -645,17 +715,43 @@ export default {
                     // 顺序即界面勾选与消息顺序（用户裁定 2026-09-16）：场景和记忆 → MCP → 技能 →
                     // 子智能体 → 提示词。form 是宿主语义轴：记忆是「当前状态」（snapshot，后发取代先发），
                     // 三个目录是 catalog，提示词是 instructions（与官方 AGENTS.md 那条行同一形态）。
+                    //
+                    // `applicableTo`（2026-09-17 方案 A）：子智能体域按"**目录该不该注入到这么深的
+                    // 会话**"（人设的 `catalogDepth`，默认 1 = 只在顶层注入）判断，**不是**"能不能
+                    // 委派"。委派可行性由官方决定：`dsh-tool-subagent` 默认 `maxDepth: 3`，provider
+                    // 只在传了该值时才校验，所以子代理本来就能继续嵌套（用户实测确认）。此前判据叫
+                    // "还有没有委派预算"、语义是"还能不能委派"，那是错的 —— 详见 service.ts 里
+                    // `catalogDepth` 字段的注释。目录正文也按同一个判据过滤（`text(agent)`），两处同源
+                    // 所以不会分叉。
+                    //
+                    // 记忆域（2026-09-17 用户裁定）：**只在顶层注入**。记忆是"父会话的现场"，不是子代理
+                    // 完成任务所需的事实 —— 而且它带着「一律照办，覆盖你的默认做法」这种强主张，塞进
+                    // 一次性子会话只会与角色定义争注意力（实测：子代理跑审查时，上下文里同时躺着人设与
+                    // 整份场景记忆）。子代理手里有 `memory_manager_list/read`，需要什么自己取；父代理
+                    // 上下文里也有记忆，相关事实应当由它写进 `task`（子代理的上下文 = 角色 + 任务）。
+                    // 其余三域对任何深度都成立：提示词是用户规则（本插件的立身之本就是"覆盖到子代理"）、
+                    // 技能目录与 MCP 状态是"操作这台机器所需的事实"（子代理手里就有 `skill` / `mcp__*`
+                    // 工具，不知道清单就只能瞎调）。
                     domains: () => [
-                        { key: 'memory', name: 'tool-management:scene-memory', label: '场景和记忆', form: 'snapshot', text: () => rulesService.memoryText() },
+                        { key: 'memory', name: 'tool-management:scene-memory', label: '场景和记忆', form: 'snapshot', text: () => rulesService.memoryText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
                         { key: 'mcp', name: 'tool-management:mcp-state', label: 'MCP 服务器', form: 'catalog', text: () => mcpStateCatalog.text() },
                         { key: 'skills', name: 'tool-management:skill-catalog', label: '技能目录', form: 'catalog', text: () => skillCatalog.text() },
-                        { key: 'subagents', name: 'tool-management:subagents', label: '子智能体', form: 'catalog', text: () => subagentCatalog.text() },
-                        { key: 'prompt', name: 'tool-management:prompt', label: '提示词', form: 'instructions', text: () => rulesService.promptText() },
+                        {
+                            key: 'subagents',
+                            name: 'tool-management:subagents',
+                            label: '子智能体',
+                            form: 'catalog',
+                            text: (agent) => subagentCatalog.text(agent),
+                            applicableTo: (agent) => subagentCatalog.catalogVisibleAt(subagentDepthOf(agent)),
+                        },
+                        { key: 'prompt', name: 'tool-management:prompt', label: '提示词', form: 'instructions', text: () => rulesService.promptText(), files: () => rulesService.promptFiles() },
                     ],
                     settings: () => injectSettingsSync(),
                     factsFor: (agent) => presetFactsForAgent(agent),
                 });
-                return () => injector.dispose();
+                contextInjectorLive = () => injector.live();
+                contextInjectorNote = (toolName, agent) => injector.noteToolUse(toolName, agent);
+                return () => { contextInjectorLive = null; contextInjectorNote = null; injector.dispose(); };
             }, 'dsh-plugin-tool-management: context injection');
         }
         catch (e) {
@@ -720,12 +816,51 @@ export default {
                 return 0;
             }
         }
+        /**
+         * 人设改名后同步运行时快照（F-025）：退出还原按 `subagentsAll` 逐名走，快照里
+         * 还留着旧名的话，退出会「旧名静默跳过、新名不还原」—— 被改名的人设停留在
+         * 场景期间状态。快照在进入场景时拍、改名发生在进入后，只能在改名时跟着改。
+         */
+        async function renameSubagentInSnapshot(from, to) {
+            try {
+                const slice = await rulesService.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 rulesService.patchIndex({ mode: { ...mode, snapshot: next } });
+            }
+            catch { /* 快照同步失败不阻断改名本身；残留与修复前一致 */ }
+        }
         const baseSubagentUpdate = subagentService.ops['subagent-update'];
         if (typeof baseSubagentUpdate === 'function') {
             subagentService.ops['subagent-update'] = async (args) => {
                 const res = await baseSubagentUpdate(args);
-                if (res && res.ok !== false && res.renamedFrom)
-                    void rebindSubagentInArchives(String(res.renamedFrom), String(res.name));
+                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;
             };
         }
@@ -788,7 +923,10 @@ export default {
                         if (toOn.length || toOff.length)
                             void subagentCatalog.refresh();
                         const snapshot = mode.snapshot;
-                        if (snapshot && (toOn.length || toOff.length)) {
+                        // 新快照带**全量映射**（`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)
@@ -817,6 +955,10 @@ export default {
             'mcpm-add', 'mcpm-edit', 'mcpm-remove', 'mcpm-set-enabled', 'mcpm-set-all', 'mcpm-restart',
             'mcpm-compact',
             'mcpm-export', 'mcpm-import', 'mcpm-note', 'mcpm-settings', 'mcpm-tool-enabled',
+            // mcpm-tools-refresh 为了拿实时工具表会临时启用目标服务器、结束后恢复原状（两次
+            // writePatch），恢复失败还会停留在启用态 —— 是写不是读，按写门禁（与 mcpm-restart
+            // 已在清单同理；0.6.0/0.7.0 已有两次写 op 漏列前科）。
+            'mcpm-tools-refresh',
             // mcpm-reveal returns UNMASKED secrets; even though it is a read, it is
             // token-gated like a write — on a LAN-exposed port the token must be the
             // last line of defense for plaintext credentials too, not just writes.
@@ -912,22 +1054,29 @@ export default {
         /**
          * **应用提示词预设的唯一入口**（界面 op 与模型工具共用）。
          *
-         * 场景接管期间（启用场景 / 全局绑定在驱动基线）只允许「重新应用场景绑定的那一份」：
-         * 应用别的预设会绕过场景绑定，于是「场景页显示 A、实际注入 B、A 不可删而 B 可删」
-         * 四套状态各说各话（用户实测）。同一份 = 修复（把被手改的基线写回去），走场景同步
-         * 而不是裸写 —— 同步会在写之前补上「进场景前的基线」快照，退出场景才恢复得回来。
-         * 换提示词的唯一正路在场景设置里改绑定（`rules-update-scene`，成功后同样同步基线）。
+         * 场景接管期间（启用场景 / 全局绑定在驱动基线）：
+         *   - 应用**同一份** = 重新应用（把被手改的基线写回去），走场景同步；
+         *   - 应用**别的份** = 换掉这个场景的绑定（用户裁定 2026-09-17：未锁定时切换要可用，
+         *     并且同步写进场景档案）。绑定改完再走一次场景同步，于是「场景页显示什么 / 实际注入
+         *     什么 / 谁是引用方」三处立刻重新对齐（此前的做法是直接拒绝，用户得先退出场景）。
+         * 锁定由 `guardLockedOps` 挡住（agentsmd-apply 在冻结清单里）；模型工具
+         * `prompt_manager_apply` 不经过 handlers，execute 里自带 `lockedSceneGuard`（F-001）。
          */
         async function applyPresetGuarded(id) {
-            const blocked = await scenePromptSync.applyGuard(id);
-            if (blocked) {
-                return {
-                    ok: false,
-                    code: 'error.agentsMd.scenePromptLocked',
-                    error: `提示词基线当前由场景「${blocked.label}」绑定的预设「${blocked.presetId}」接管，不能直接应用其他预设：要换提示词，请到场景页修改该场景的绑定，或先退出场景。`,
-                };
-            }
-            if (await scenePromptSync.driver()) {
+            const driver = await scenePromptSync.driver();
+            if (driver) {
+                const target = String(id ?? '').trim();
+                if (driver.presetId !== target) {
+                    const rebound = await rulesService.ops['rules-update-scene']({ name: driver.scene, prompt: target });
+                    if (!rebound || rebound.ok === false) {
+                        return {
+                            ok: false,
+                            code: 'error.agentsMd.sceneRebindFailed',
+                            error: `无法把场景「${driver.label}」的提示词绑定改成「${target}」：${(rebound && rebound.error) || '未知原因'}`,
+                            params: { scene: driver.label, target, reason: String((rebound && rebound.error) || '未知原因') },
+                        };
+                    }
+                }
                 const r = await scenePromptSync.sync();
                 if (r.error)
                     return { ok: false, error: r.error };
@@ -1142,7 +1291,6 @@ export default {
             catch (e) { /* pruning is best-effort */ }
         }
         async function writePatch(abs, content) {
-            const t = await fs.resolve(abs);
             const policy = await sandboxPolicy.resolve({ mode: 'danger-full-access' });
             try {
                 const previous = await readPatch(abs);
@@ -1150,7 +1298,20 @@ export default {
                     await backupPatchFile(abs, previous);
             }
             catch (e) { /* a failed backup must never block the write */ }
-            await fs.writeText(t, content, undefined, undefined, policy);
+            // 同目录临时文件 + rename 原子替换：进程中断/磁盘满最坏留下一个 .tmp 兄弟，
+            // 不会截断补丁本体。官方 app-boot 写这两个补丁文件用的是同一套模式
+            // （`filename + '.tmp'` → rename + 瞬时错误重试，lib/index.js `_writeFile`），
+            // 所以 HMR 对 rename 的容忍不需要额外验证。内容写仍走宿主 fs 服务
+            // （沙箱策略与审批语义不变），rename 只是元数据动作。
+            const temp = abs + '.' + randomUUID().slice(0, 8) + '.dsh-tmp';
+            try {
+                await fs.writeText(await fs.resolve(temp), content, undefined, undefined, policy);
+                await renameWithRetry(temp, abs);
+            }
+            catch (e) {
+                await rm(temp, { force: true }).catch(() => undefined);
+                throw e;
+            }
         }
         // ---------- duplicate loader-id guard ----------
         // Two rows with the same loader id make the plugin composition fail to
@@ -1330,7 +1491,6 @@ export default {
                     managedIds.add(m[1].trim());
             }
             const rows = [];
-            const overrides = [];
             const blocks = [];
             let current = null;
             for (const line of lines) {
@@ -1369,16 +1529,18 @@ export default {
                     }
                 }
                 else {
+                    // 覆盖块按**文件顺序**生效，不是"收集后统一回填"：官方
+                    // `@deepseek-ai/dsh-app-boot` 的 applyEntryPatches 只给此刻已入索引的 id 打补丁
+                    // （insert 是插入时立即入索引），命中不到就 warn + skip。所以写在 insert 之前的
+                    // 覆盖块在宿主侧是 no-op —— 这里同样丢弃，界面才和生效值一致。
                     const entry = parseEntry(block.text.split('\n'));
-                    if (entry && entry.name === '@deepseek-ai/dsh-mcp-client')
-                        overrides.push({ id: entry.id, disabled: entry.disabled });
+                    if (entry && entry.name === '@deepseek-ai/dsh-mcp-client' && entry.disabled !== undefined) {
+                        const row = rows.find((r) => r.id === entry.id);
+                        if (row)
+                            row.disabled = entry.disabled;
+                    }
                 }
             }
-            for (const o of overrides) {
-                const row = rows.find((r) => r.id === o.id);
-                if (row && o.disabled !== undefined)
-                    row.disabled = o.disabled;
-            }
             return { rows };
         }
         // ---------- line-based block editing ----------
@@ -2038,7 +2200,9 @@ export default {
                 toolsList.push({
                     name: known.name,
                     description: known.description || '（服务器未运行；这个名字来自上次运行记录）',
-                    enabled: !disabledHere.has(known.name),
+                    // 与上方 live 行同一口径：整台停用（`*`）时 stale 行同样报停用，
+                    // 否则同页「live 行停用、stale 行启用」自相矛盾。
+                    enabled: wildcardHere ? false : !disabledHere.has(known.name),
                     parameters: [],
                     stale: true,
                 });
@@ -2133,6 +2297,24 @@ export default {
             }
             const toolCounts = {};
             const enabledToolCounts = {};
+            // 只来自**真实 schema** 的两个数，以及只来自**「已知工具」缓存**的一个数。
+            //
+            // 为什么必须与上面那两个分开（2026-09-17 用户实测发现）：`toolCounts` 是三处并集
+            // （live ∪ 停用表 ∪ 缓存），把"这台 server 曾经有什么工具"与"它现在有什么工具"混成了
+            // 一个数。界面状态胶囊与注入段此前读的就是它，于是**一台已经连不上的 server 会被报成
+            // 「已运行」并注入上下文**，模型照着去调 `mcp__X__*`，而那个工具根本没注册 —— 白烧一轮。
+            //
+            // 分开之后三个数各有明确含义：
+            //   liveToolCounts        当前真实注册的工具数（0 = 一个都没注册）
+            //   liveEnabledToolCounts 上面这个数里未被停用表扣减的（真正能调到的）
+            //   knownToolCounts       缓存里的工具数 —— 它是**曾经真的连上过**的证据（缓存只在真实
+            //                         schema 里见到工具时才写入），0 = 从未连上过
+            //
+            // 前两个给状态胶囊与注入段用；`toolCounts` / `enabledToolCounts` 语义不变，继续给场景
+            // 档案挑工具、详情页清单用（那里"上次见过哪些工具"正是需要的，且已标 `stale`）。
+            const liveToolCounts = {};
+            const liveEnabledToolCounts = {};
+            const knownToolCounts = {};
             try {
                 const schemas = await tools.schemas();
                 const knownCache = await readKnownMcpTools();
@@ -2183,6 +2365,17 @@ export default {
                     // 否则收窄后模型看到的数字比它能调的工具多，页面与详情页也会互相矛盾。
                     enabledToolCounts[server] = countEnabledTools(set, disabledMap[server] || []);
                 }
+                // 真实来源的两个数：只数 `liveNames`（schema 里真正注册了的），再按停用表扣减。
+                for (const [server, list] of Object.entries(liveNames)) {
+                    const set = new Set(list);
+                    liveToolCounts[server] = set.size;
+                    liveEnabledToolCounts[server] = countEnabledTools(set, disabledMap[server] || []);
+                }
+                // 「曾经连上过」的证据：缓存里这台 server 见过几个工具。注意读的是**回写之前**的
+                // `knownCache` —— 回写会把这次 live 见到的并进去，而这次 live 见到的本来就已经算在
+                // liveToolCounts 里了，不需要它来充当"曾经"。
+                for (const [server, list] of Object.entries(knownCache))
+                    knownToolCounts[server] = list.length;
                 // 回写「已知工具」：live 见到的名字与描述并入缓存（有变化才写盘，读路径上的 best-effort）。
                 // 名字集合变化，或某个已知工具这次拿到了描述而缓存里没有 → 都算变化。
                 let cacheChanged = false;
@@ -2238,7 +2431,21 @@ export default {
                     row.toolCount = toolCounts[row.serverName] || 0;
                 if (row.enabledToolCount === undefined)
                     row.enabledToolCount = enabledToolCounts[row.serverName] || 0;
-            }
+                // 这三个**总是**覆盖：它们描述的是"此刻的真实状态"，而缓存合并出来的那两个数
+                // 描述的是"这台 server 有过哪些工具"。两者混淆过一次，代价是注入段谎报可用。
+                row.liveToolCount = liveToolCounts[row.serverName] || 0;
+                row.liveEnabledToolCount = liveEnabledToolCounts[row.serverName] || 0;
+                row.knownToolCount = knownToolCounts[row.serverName] || 0;
+            }
+            // 列表顺序（用户要求 2026-09-17）：**全局在前、应用级在后**，各级按服务器名排，
+            // 当前在跑的 loader 行垫底。放在服务端而不是页面里：同一个顺序也是场景档案勾选器
+            // （`scene-inventory`）与模型侧 `mcp_manager_list` 的顺序 —— 三处说同一件事。
+            // 名字比较与技能页同一套（localeCompare），大小写混排时不会把大写全顶到前面。
+            const levelRank = { global: 0, project: 1, loader: 2 };
+            const serverNameOf = (row) => String(row.serverName || row.id || '');
+            rows.sort((a, b) => (levelRank[a.level] ?? 3) - (levelRank[b.level] ?? 3) ||
+                serverNameOf(a).localeCompare(serverNameOf(b)) ||
+                String(a.id).localeCompare(String(b.id)));
             // A loader id that appears twice (same id in both patch files, or twice in
             // one) makes the composition fail to boot. Surface it instead of hiding it.
             const idCounts = new Map();
@@ -2353,6 +2560,17 @@ export default {
             }
             const oldAbs = cur.level === 'global' ? p.globalPatch : p.projectPatch;
             const newAbs = level === 'global' ? p.globalPatch : p.projectPatch;
+            // 编辑表单不建模 config 里的全部键：手写补丁可能带 toolCallTimeoutMs 这类字段，
+            // 重建前从旧条目原样带回，否则一次「编辑」就把它静默删掉。只透传 buildInsertBlock
+            // 已有发射路径的键 —— 其余未知键的保真需要值保持式序列化（裸布尔/数字经
+            // unquote/yq 往返会漂成字符串），不在此处理，宁可如实丢弃也不写错类型。
+            try {
+                const curRaw = parseRows(await readPatch(oldAbs)).rows.find((r) => r.id === id);
+                if (curRaw && curRaw.config && curRaw.config.toolCallTimeoutMs != null) {
+                    row.toolCallTimeoutMs = curRaw.config.toolCallTimeoutMs;
+                }
+            }
+            catch { /* 旧文件读不了时按建模字段重建，与原行为一致 */ }
             const block = buildInsertBlock(row);
             return withWriteLock(async () => {
                 // Per-tool disable state is keyed by the serverName namespace: migrate
@@ -2368,6 +2586,20 @@ export default {
                         catch (e) { /* non-fatal */ }
                         disabledToolsCache = { at: Date.now(), value: toolMap };
                     }
+                    // F-025：运行时快照的 mcp 停用表同样按 serverName 键 —— 改名不跟着改，
+                    // 退出场景整体回写时旧键成死键、新名工具的停用状态丢失（回到全启用）。
+                    try {
+                        const slice = await rulesService.readArchiveSlice();
+                        const mode = slice && slice.mode;
+                        const mcpMap = mode && mode.snapshot && mode.snapshot.mcp;
+                        if (mcpMap && Object.prototype.hasOwnProperty.call(mcpMap, cur.serverName)) {
+                            const next = {};
+                            for (const [k, v] of Object.entries(mcpMap))
+                                next[k === cur.serverName ? serverName : k] = v;
+                            await rulesService.patchIndex({ mode: { ...mode, snapshot: { ...mode.snapshot, mcp: next } } });
+                        }
+                    }
+                    catch { /* 快照同步失败不阻断改名本身；残留与修复前一致 */ }
                 }
                 if (oldAbs !== newAbs) {
                     // Level migration: remove from the old file, insert into the new one.
@@ -2550,6 +2782,16 @@ export default {
             // waits deliberately run OUTSIDE the write lock — holding the global
             // write lock for up to ~11s stalled every other write op.
             await withWriteLock(async () => {
+                // 并发护栏：阶段 1 的强制写自身必然把 effective 状态置为停用，所以走到这里时
+                // 若读到「已启用」，只可能是等待窗口内别的写操作重新启用了它 —— 以现状为准并
+                // 警告，绝不按重启前快照把用户的显式选择改回去。其余情形按 wasDisabled 原样恢复。
+                // （已知残留：窗口内被「停用」与阶段 1 的写不可区分，仍按快照恢复 —— 重启语义
+                // 本就是「状态与重启前一致」，方向性无害。）
+                const currentDisabled = await isRowDisabled(id, level);
+                if (!currentDisabled && wasDisabled) {
+                    warnings.push('重启等待窗口内该服务被重新启用：已保留启用状态，未按重启前状态恢复');
+                    return;
+                }
                 let c = await readPatch(abs);
                 c = removeMarked(c, id, 'disable');
                 if (wasDisabled)
@@ -2693,9 +2935,13 @@ export default {
                         return { skipped: true, reason: 'serverName 已存在' };
                     if (idTaken && !overwrite)
                         return { skipped: true, reason: 'id 已存在' };
+                    // Overwrite: purge every trace of the id from BOTH patch files first,
+                    // then insert the imported row at its own level. The purge is not
+                    // atomic with the insert, so keep the pre-purge content of both files
+                    // and restore it when the insert fails — same trade-off as mcpmEdit's
+                    // level migration: losing the old entries is worse than a transient dup.
+                    const origs = [];
                     if (idTaken && overwrite) {
-                        // Purge every trace of the id from BOTH patch files first, then
-                        // insert the imported row at its own level.
                         for (const lvl of ['project', 'global']) {
                             const lAbs = lvl === 'global' ? p.globalPatch : p.projectPatch;
                             let lContent = '';
@@ -2705,24 +2951,50 @@ export default {
                             catch (e) {
                                 continue;
                             }
-                            lContent = removeEntryAll(lContent, row.id);
+                            origs.push({ abs: lAbs, content: lContent });
                             try {
-                                await writePatch(lAbs, lContent);
+                                await writePatch(lAbs, removeEntryAll(lContent, row.id));
                             }
                             catch (e) {
-                                return { skipped: true, reason: '覆盖旧条目失败: ' + message(e) };
+                                // 前面已清掉的文件也要恢复：purge 中途失败同样不能留下「旧条目没了」的状态。
+                                for (const o of origs) {
+                                    try {
+                                        await writePatch(o.abs, o.content);
+                                    }
+                                    catch { /* best effort */ }
+                                }
+                                return { skipped: true, reason: '覆盖旧条目失败（已回滚）: ' + message(e) };
                             }
                         }
                     }
                     const abs = row.level === 'global' ? p.globalPatch : p.projectPatch;
-                    let c = await readPatch(abs);
-                    const before = c;
-                    c = appendBlock(c, buildInsertBlock(row));
-                    if (row.disabled)
-                        c = appendBlock(c, buildDisableBlock(row.id, true));
-                    if (duplicateGuard(before, c))
-                        return { skipped: true, reason: '会产生重复的 loader id' };
-                    await writePatch(abs, c);
+                    try {
+                        let c = await readPatch(abs);
+                        const before = c;
+                        c = appendBlock(c, buildInsertBlock(row));
+                        if (row.disabled)
+                            c = appendBlock(c, buildDisableBlock(row.id, true));
+                        const guard = duplicateGuard(before, c);
+                        if (guard) {
+                            for (const o of origs) {
+                                try {
+                                    await writePatch(o.abs, o.content);
+                                }
+                                catch { /* best effort */ }
+                            }
+                            return { skipped: true, reason: guard.error };
+                        }
+                        await writePatch(abs, c);
+                    }
+                    catch (e) {
+                        for (const o of origs) {
+                            try {
+                                await writePatch(o.abs, o.content);
+                            }
+                            catch { /* best effort */ }
+                        }
+                        return { skipped: true, reason: '写入失败（已回滚）: ' + message(e) };
+                    }
                     return { added: true, wasOverwrite: idTaken && overwrite };
                 });
                 if (res.added) {
@@ -3354,10 +3626,12 @@ export default {
                     ctx.logger?.warn?.('agents-md: reference probe failed; remove allowed');
                 const why = refs ? refs.get(id) || [] : [];
                 if (why.length) {
+                    const refsText = why.map(promptRefReason).join('；');
                     return {
                         ok: false,
                         code: 'error.agentsMd.referenced',
-                        error: `「${id}」仍被引用，不能删除：${why.map(promptRefReason).join('；')}。先改掉引用（换绑提示词 / 退出场景 / 应用别的预设）再删除。`,
+                        error: `「${id}」仍被引用，不能删除：${refsText}。先改掉引用（换绑提示词 / 退出场景 / 应用别的预设）再删除。`,
+                        params: { id, refs: refsText },
                     };
                 }
                 return agentsMdService.remove(id);
@@ -3612,6 +3886,18 @@ export default {
             },
             // 注入设置（读 / 写）：压制型预设下是否仍然注入 + 各域开关。界面在「兼容」页。
             'inject-settings': (args) => injectSettingsOp(args),
+            // 注入实况（只读）：最近活跃会话里模型**真正看到**的五域文本 + 本次运行的投递统计。
+            // 回答"勾了开关到底送没送到"——界面配置与实际注入不一致时，这里一眼可见。
+            'injection-live': async () => {
+                if (contextInjectorLive === null)
+                    return { ok: false, error: '注入通道未装配' };
+                try {
+                    return { ok: true, ...contextInjectorLive() };
+                }
+                catch (e) {
+                    return { ok: false, error: message(e) };
+                }
+            },
             'history-unarchive': async (args) => {
                 const registry = getHistoryRegistry();
                 if (!registry)
@@ -4009,33 +4295,327 @@ export default {
                 return null;
             }
         }
-        /** 「场景内开关一律禁用」的拒绝文案（界面 / 模型工具共用；不在场景里返回 null）。 */
-        async function sceneSwitchBlock() {
+        /** 「当前场景已锁定」的拒绝文案（模型工具用；无活动场景 / 未锁定 → null）。 */
+        async function lockedSceneGuard() {
             const scene = await activeSceneName();
             if (!scene)
                 return null;
-            return `当前处于场景「${scene}」：开关由场景档案定义，不能在页面上直接改。请到场景页的档案编辑器里改（改完立即生效；退出场景仍按进场景前的状态还原），或先退出场景。`;
+            const locked = await lockedSceneNames();
+            return locked.includes(scene) ? `场景「${scene}」已锁定：先到场景页解锁再改。` : null;
+        }
+        // ---------- 场景内改开关 = 同步改档案（v0.9.2）----------
+        /**
+         * 用户裁定（2026-09-17）：场景**未锁定**时，页面上的开关（MCP / 技能 / 子智能体 / 提示词）
+         * 照常可用，改动**同步写进当前场景的档案**；只有「锁定」才冻结这些开关。
+         * 记忆不在此列 —— 它的开关是 `rules[*].enabled` 单一真相源，本来就不经过场景档案。
+         *
+         * 为什么必须同步：档案的语义是「勾选集 = 该场景下开着的东西，段未定义 = 全关」（见
+         * archive-engine 的四域同口径）。只改运行时、不改档案，退出场景会被快照整体回滚 ——
+         * 用户看到的「改了」是假的；写进档案才既当下生效、下次进这个场景又照样生效。
+         * 新增 / 改名 / 删除 / 备注 / 导入导出这些**内容**操作不进档案（它们不是场景维度）。
+         */
+        /**
+         * 技能档案 key 映射：`<来源 key>\u0000<条目名>` → `{ 档案 key, selectable }`。
+         *
+         * `selectable=false` = 被同名技能覆盖的副本，或结构不完整（core 拒绝启停）——
+         * 这两种都**不可能生效**，勾进档案只会让「档案说开着、技能页说没启动」（用户实测）。
+         * `skill-disable` 不受此限：它只是把键从档案里删掉，任何键都可以删。
+         */
+        async function skillArchiveKeys() {
+            const map = new Map();
+            try {
+                const r = await skillsService.ops['skill-state']({});
+                for (const root of ((r && r.data && r.data.roots) || [])) {
+                    const rootKey = String((root && root.key) || '');
+                    if (!rootKey)
+                        continue;
+                    for (const sk of ((root && root.skills) || [])) {
+                        const entry = String((sk && sk.name) || '');
+                        if (!entry)
+                            continue;
+                        // 与 skillRows / skillScan 同口径：档案里存**声明名**（frontmatter name）。
+                        // 用条目名拼 key 会被保存时的 stale 校验当成未知键丢掉。
+                        map.set(rootKey + '\u0000' + entry, {
+                            key: rootKey + '/' + String(sk.declaredName || entry),
+                            selectable: !sk.shadowedBy && sk.loadable !== false,
+                        });
+                    }
+                }
+            }
+            catch { /* 读不到状态 → 调用方退化为原样拼 key */ }
+            return map;
+        }
+        /**
+         * 某个来源下的技能档案 key（来源级开关用）：
+         *  - `all`：该来源下**全部**键 —— 停用来源时按它清理（连历史残留一起清掉）；
+         *  - `selectable`：真正**生效得了**的那些 —— 启用来源时只并入这一批。
+         */
+        async function skillArchiveKeysOfRoot(rootKey) {
+            const all = [];
+            const selectable = [];
+            try {
+                const r = await skillsService.ops['skill-state']({});
+                for (const root of ((r && r.data && r.data.roots) || [])) {
+                    if (String((root && root.key) || '') !== rootKey)
+                        continue;
+                    for (const sk of ((root && root.skills) || [])) {
+                        const name = String((sk && sk.declaredName) || (sk && sk.name) || '');
+                        if (!name)
+                            continue;
+                        const key = rootKey + '/' + name;
+                        all.push(key);
+                        if (!sk.shadowedBy && sk.loadable !== false)
+                            selectable.push(key);
+                    }
+                }
+            }
+            catch { /* 读不到 → 空列表 */ }
+            return { all, selectable };
+        }
+        /** 字符串数组的「勾上 / 取消」（已处于目标状态时原样返回，避免无谓的档案写入）。 */
+        function toggleInList(list, key, on) {
+            if (!key)
+                return list;
+            const has = list.indexOf(key) >= 0;
+            if (on === has)
+                return list;
+            return on ? [...list, key] : list.filter((x) => x !== key);
+        }
+        /** loader 条目 id → 服务器名（档案的 mcp 段按 serverName 存）。 */
+        async function serverNameOfId(id) {
+            try {
+                const r = await mcpmListView();
+                for (const row of ((r && r.rows) || [])) {
+                    if (String((row && row.id) || '') === id)
+                        return String(row.serverName || row.id);
+                }
+            }
+            catch { /* 读不到 → null（这一笔不同步，如实跳过） */ }
+            return null;
         }
         /**
-         * 场景内「开关」类操作一律禁用（用户裁定 2026-09-16）。
+         * 某台服务器当前**启用**的工具名（把档案里的 `'*'` 具化成具体名单时用）。
          *
-         * 场景里的环境由**档案**定义，页面开关在场景里本来就是"白改"：退出场景时 MCP 停用表、
-         * 技能表按快照整体写回，那些改动会被静默丢弃，而档案又不会跟着变 —— 于是「页面开关 /
-         * 实际生效 / 档案勾选」三处各说各话（用户实测数次）。要改就改档案：那里改完立即生效、
-         * 且档案持久化（下次进这个场景照旧生效）；退出场景时运行时仍按进场景前的快照还原。
-         * 只拦**启停**：新增 / 改名 / 删除 / 备注 / 重启 / 导入导出这些内容操作照旧可用
-         * （要整体冻结用场景「锁定」）。
+         * live schema 优先（就是此刻真的存在的工具）；服务器没跑起来时退回「最后见过的工具名单 −
+         * 停用表」——与 `computeMcpPlan` 的 `knownTools` 同源，别把「不知道」当成「一个都没有」。
+         */
+        async function enabledToolNames(server) {
+            const live = await (async () => {
+                try {
+                    const r = await mcpmTools({ serverName: server });
+                    return ((r && r.tools) || []).filter((t) => t.enabled !== false).map((t) => String(t.name));
+                }
+                catch {
+                    return [];
+                }
+            })();
+            if (live.length)
+                return live;
+            try {
+                const known = (await readKnownMcpTools())[server] || [];
+                const off = new Set(await readDisabledTools().then((m) => m[server] || []));
+                if (off.has('*'))
+                    return [];
+                return known.map((item) => String(item.name)).filter((n) => !off.has(n));
+            }
+            catch {
+                return [];
+            }
+        }
+        /**
+         * 把一次开关落到当前场景的档案上。
+         * 返回 null = 无需改动（没有活动场景 / 已锁定 / 这一笔不影响档案）；
+         * 返回字符串 = 档案没跟上（运行时已经生效，如实告诉用户，而不是假装成功）。
+         */
+        async function syncSwitchToScene(opName, args) {
+            const scene = await activeSceneName();
+            if (!scene)
+                return null;
+            if ((await lockedSceneNames()).includes(scene))
+                return null;
+            // 开关方向。**先按 op 名判定「动词即方向」的那几个**，再看 `args.enabled`：
+            // `skill-enable` / `skill-disable` / `skill-source-enable` / `skill-source-disable`
+            // 的参数里**根本没有 `enabled` 字段**（只有 root / name），早先统一读 `args.enabled`
+            // 会把它们一律读成 false，于是「在场景里打开某个技能」被同步成「关闭」——目标集合
+            // 一次变化都没有 → 直接早退不写盘，用户看到的就是「开关了但档案不跟着变」
+            // （2026-09-17 用真实产物复现）。反向更糟：启用一个来源会被同步成「把该来源下的
+            // 技能全部从档案里删掉」，档案与运行时当场对不上。
+            // 其余 op 仍按宿主逐字对齐：`mcpm-tool-enabled` 的语义是「缺省 = 启用」（`enabled !== false`）。
+            const enabled = opName === 'skill-enable' || opName === 'skill-source-enable'
+                ? true
+                : opName === 'skill-disable' || opName === 'skill-source-disable'
+                    ? false
+                    : args && typeof args.enabled === 'boolean'
+                        ? args.enabled === true
+                        : opName === 'mcpm-tool-enabled';
+            let next;
+            let cur = {};
+            try {
+                const slice = await rulesService.readArchiveSlice();
+                cur = (slice.archives && slice.archives[scene]) || {};
+                next = { ...cur };
+                switch (opName) {
+                    case 'skill-enable':
+                    case 'skill-disable': {
+                        const root = String((args && args.root) || 'dsh');
+                        const entry = String((args && args.name) || '');
+                        const hit = (await skillArchiveKeys()).get(root + '\u0000' + entry);
+                        const key = (hit && hit.key) || root + '/' + entry;
+                        // 勾进来这件事只对**生效得了**的技能做：被同名覆盖的副本、结构不完整的技能
+                        // 写进去也永远不生效（运行时那一步本来就跳过了它们），档案就会开始说谎。
+                        // 取消勾选（enabled=false）不受限——它只是把键删掉，历史残留正好顺手清掉。
+                        if (enabled && hit && !hit.selectable)
+                            return null;
+                        next.skills = toggleInList(Array.isArray(next.skills) ? next.skills.slice() : [], key, enabled);
+                        break;
+                    }
+                    case 'skill-set-all': {
+                        const items = Array.isArray(args && args.items) ? args.items : [];
+                        const map = await skillArchiveKeys();
+                        let list = Array.isArray(next.skills) ? next.skills.slice() : [];
+                        for (const item of items) {
+                            const root = String((item && item.root) || '');
+                            const entry = String((item && item.name) || '');
+                            if (!root || !entry)
+                                continue;
+                            const hit = map.get(root + '\u0000' + entry);
+                            if (enabled && hit && !hit.selectable)
+                                continue;
+                            list = toggleInList(list, (hit && hit.key) || root + '/' + entry, enabled);
+                        }
+                        next.skills = list;
+                        break;
+                    }
+                    case 'skill-source-enable':
+                    case 'skill-source-disable': {
+                        // 来源级没有独立字段：档案靠「来源下有没有被勾的技能」反推（computeSkillsPlan）。
+                        // 启用时只并入**生效得了**的技能（被覆盖的副本/结构不完整的整批不进档案）；
+                        // 停用时按**全部**键清（连历史残留一起清掉）。
+                        const keys = await skillArchiveKeysOfRoot(String((args && args.root) || ''));
+                        const pick = enabled ? keys.selectable : keys.all;
+                        let list = Array.isArray(next.skills) ? next.skills.slice() : [];
+                        if (enabled) {
+                            for (const k of pick)
+                                if (list.indexOf(k) < 0)
+                                    list.push(k);
+                        }
+                        else {
+                            const drop = new Set(pick);
+                            list = list.filter((k) => !drop.has(k));
+                        }
+                        next.skills = list;
+                        break;
+                    }
+                    case 'mcpm-set-enabled': {
+                        const server = await serverNameOfId(String((args && args.id) || ''));
+                        if (!server)
+                            return null;
+                        next.mcp = { ...(next.mcp || {}) };
+                        if (enabled)
+                            next.mcp[server] = '*';
+                        else
+                            delete next.mcp[server];
+                        break;
+                    }
+                    case 'mcpm-set-all': {
+                        if (!enabled) {
+                            next.mcp = {};
+                            break;
+                        }
+                        const all = {};
+                        try {
+                            const r = await mcpmListView();
+                            for (const row of ((r && r.rows) || [])) {
+                                const n = String((row && row.serverName) || '');
+                                if (n)
+                                    all[n] = '*';
+                            }
+                        }
+                        catch {
+                            return null;
+                        }
+                        next.mcp = all;
+                        break;
+                    }
+                    case 'mcpm-tool-enabled': {
+                        const server = String((args && args.serverName) || '');
+                        const tool = String((args && args.tool) || '');
+                        if (!server || !tool)
+                            return null;
+                        const has = next.mcp && Object.prototype.hasOwnProperty.call(next.mcp, server);
+                        // 服务器没勾 = 该场景下这台服务器关着，工具级开关在运行时本来就不生效（工具不存在）。
+                        if (!has)
+                            return null;
+                        const spec = next.mcp[server];
+                        if (spec === '*') {
+                            // '*' = 全部工具。只有「关掉某个工具」才需要具化；否则 '*' 已经涵盖了启用这一笔。
+                            if (enabled)
+                                return null;
+                            const live = await enabledToolNames(server);
+                            next.mcp = { ...next.mcp, [server]: live.filter((t) => t !== tool) };
+                        }
+                        else {
+                            const list = Array.isArray(spec) ? spec.slice() : [];
+                            next.mcp = {
+                                ...next.mcp,
+                                [server]: enabled
+                                    ? (list.indexOf(tool) < 0 ? [...list, tool] : list)
+                                    : list.filter((t) => t !== tool),
+                            };
+                        }
+                        break;
+                    }
+                    case 'subagent-toggle': {
+                        const name = String((args && args.name) || '');
+                        next.subagents = toggleInList(Array.isArray(next.subagents) ? next.subagents.slice() : [], name, enabled);
+                        break;
+                    }
+                    default: return null;
+                }
+            }
+            catch (e) {
+                return message(e);
+            }
+            // 空段 = 未定义（「一个都没勾 = 全关」），删掉以免两种语义并存（与 scene-archive-save 同口径）。
+            for (const seg of ['skills', 'subagents']) {
+                const list = next[seg];
+                if (Array.isArray(list) && list.length === 0)
+                    delete next[seg];
+            }
+            if (next.mcp && Object.keys(next.mcp).length === 0)
+                delete next.mcp;
+            if (JSON.stringify(next) === JSON.stringify(cur))
+                return null; // 档案本来就是这样 → 不写盘
+            // 与「在档案弹窗里点保存」走同一条路：落盘 + 就地重应用 + 快照并入（退出仍按进场景前还原）。
+            try {
+                const save = archiveService.ops['scene-archive-save'];
+                const res = await save({ scene, archive: next });
+                if (res && res.ok === false)
+                    return String(res.error || '场景档案保存失败');
+                if (res && res.applyError)
+                    return String(res.applyError);
+            }
+            catch (e) {
+                return message(e);
+            }
+            return null;
+        }
+        /**
+         * 包一层：开关成功后把改动同步进当前场景档案（见 syncSwitchToScene）。
+         * 失败只挂 `sceneSyncError`，不改写原操作的成功结论 —— 运行时确实改了，档案没跟上要说得清。
+         * 锁定仍由 `guardLockedOps` 挡住（更靠内的那层包装先执行）。
          */
-        function guardSceneSwitches(opNames, what) {
+        function syncSceneArchiveOnSwitch(opNames) {
             for (const opName of opNames) {
                 const original = handlers[opName];
                 if (typeof original !== 'function')
                     continue;
                 handlers[opName] = async (args) => {
-                    const blocked = await sceneSwitchBlock();
-                    if (blocked)
-                        return { ok: false, code: 'error.sceneSwitchesLocked', error: blocked };
-                    return original(args);
+                    const res = await original(args);
+                    if (!res || res.ok === false)
+                        return res;
+                    const err = await syncSwitchToScene(opName, args);
+                    return err ? { ...res, sceneSyncError: err } : res;
                 };
             }
         }
@@ -4055,9 +4635,9 @@ export default {
         guardLockedOps([
             // MCP：改配置 / 服务器启停 / 工具启停 / 导入导出配置 / 备注 / 设置。restart 只重连不改配置，放行。
             'mcpm-add', 'mcpm-edit', 'mcpm-remove', 'mcpm-set-enabled', 'mcpm-set-all', 'mcpm-tool-enabled', 'mcpm-import', 'mcpm-compact', 'mcpm-note', 'mcpm-settings',
-            // 技能：启停 / 来源启停与移除恢复 / 首选 / 删除 / 创建导入 / 自定义目录 / 回收站。
+            // 技能：启停 / 来源启停与移除恢复 / 首选 / 删除 / 创建导入 / 自定义目录 / 回收站 / 批量启停。
             'skill-enable', 'skill-disable', 'skill-source-enable', 'skill-source-disable', 'skill-source-remove', 'skill-source-restore',
-            'skill-prefer', 'skill-unprefer', 'skill-delete', 'skill-create', 'skill-import', 'skill-upload',
+            'skill-prefer', 'skill-unprefer', 'skill-delete', 'skill-create', 'skill-import', 'skill-upload', 'skill-set-all',
             'skill-custom-add', 'skill-custom-remove', 'skill-trash-restore', 'skill-trash-delete',
             // 子智能体：开关 / 改名保存 / 删除 / 导入 / 回收站。
             'subagent-create', 'subagent-update', 'subagent-delete', 'subagent-toggle', 'subagent-import', 'subagent-trash-restore', 'subagent-trash-delete',
@@ -4066,14 +4646,13 @@ export default {
             // 提示词：建改删 / 应用（切换生效基线）/ 导入 / 回收站。
             'agentsmd-create', 'agentsmd-update', 'agentsmd-remove', 'agentsmd-apply', 'agentsmd-import', 'agentsmd-trash-restore', 'agentsmd-trash-delete',
         ], '修改');
-        // 场景内「开关」类操作一律禁用（用户裁定）：改开关请去场景档案编辑器。
-        // 与「锁定」正交：锁定冻结全部写操作，这里只拦启停，内容编辑照旧。
-        guardSceneSwitches([
+        // 场景内「开关」类操作（用户裁定 2026-09-17）：未锁定时**可用**，改动同步进当前场景档案。
+        // 与「锁定」正交：锁定冻结全部写操作，这里只是把页面开关的意图也写进档案。
+        syncSceneArchiveOnSwitch([
             'mcpm-set-enabled', 'mcpm-set-all', 'mcpm-tool-enabled',
-            'skill-enable', 'skill-disable', 'skill-source-enable', 'skill-source-disable',
-            'skill-prefer', 'skill-unprefer',
+            'skill-enable', 'skill-disable', 'skill-set-all', 'skill-source-enable', 'skill-source-disable',
             'subagent-toggle',
-        ], '开关');
+        ]);
         // 被锁场景自身的档案与删除：只挡它自己，别的场景照常。
         for (const [opName, pickScene, what] of [
             ['scene-archive-save', (args) => (args && args.scene) || '', '改档案'],
@@ -4107,9 +4686,50 @@ export default {
         }
         // ---------- agent-facing tools (standard ctx.tools.register + defineTool) ----------
         const text = (value) => [{ type: 'text', text: value }];
+        /**
+         * 采纳遥测：把每个工具包一层，模型一调就记一笔"哪个域被伸手了"（见 context-inject 的
+         * `noteToolUse`）。计数在宿主工具对象之外，所以**参数校验失败也算**——我们要测的是
+         * "模型知不知道有这个域、会不会去用"，不是"调用写得对不对"。
+         *
+         * 只统计本插件自己的工具，不走 `tools/result` 这类宿主事件：事件的作用域语义一旦变化，
+         * 遥测会静默变成 0，而 0 恰好会被读成"模型从来不用"——一个假结论比没有结论更糟。
+         * 包自己的工具是确定性的：工具在，观测就在。
+         */
+        const trackAdoption = (def) => {
+            const name = String(def.name ?? '');
+            const run = def.execute;
+            if (name === '' || typeof run !== 'function')
+                return def;
+            return {
+                ...def,
+                async execute(args, exec) {
+                    try {
+                        if (contextInjectorNote !== null)
+                            contextInjectorNote(name, exec && exec.agent);
+                    }
+                    catch { /* 遥测绝不能影响工具 */ }
+                    return run(args, exec);
+                },
+            };
+        };
+        /**
+         * 与宿主 `defineTool` **同签名的**本地包装。
+         *
+         * 为什么用同名遮蔽而不是逐个改 14 个注册点：采纳遥测必须覆盖**每一个**域工具，
+         * 漏一个就得到"这个域从来没用过"的假结论。遮蔽 import 让"新加工具自动被统计"成为
+         * 默认，而不是靠后来者记得手动加。
+         *
+         * 类型上刻意**不重写签名**，而是把箭头函数断言成 `typeof hostDefineTool`：宿主签名带
+         * `const S/O` 类型参数，照着写一遍会让 TS 在每个调用点上多展开一层 `InferObject<S, ?>`，
+         * 直接撞 "Excessive stack depth comparing types"（实测）。断言成宿主自己的类型之后，
+         * 14 个调用点的参数表推断与改造前**完全一致** —— 宿主改签名时该报错的地方照旧报错；
+         * 包装体本身只是转发（参数收 `unknown`、原样交给宿主），不参与推断，也就没有可失效的类型。
+         */
+        const hostDefineToolAny = hostDefineTool;
+        const defineTool = ((options) => trackAdoption(hostDefineToolAny(options)));
         tools.register(defineTool({
             name: 'mcp_manager_list',
-            description: 'List configured MCP servers (level, enabled state, live loader status, tool count excluding switched-off tools, note). Read a server\'s note before choosing it. Defaults to enabled servers; pass all=true for every configured server.',
+            description: 'List configured MCP servers (level, enabled state, live loader status, tool count excluding switched-off tools, note). Read a server\'s note before choosing it. The same list is injected into your context each turn (the「本机 MCP 服务器的当前状态」system-reminder); this tool is the raw view — all=true includes disabled servers. Defaults to enabled servers; pass all=true for every configured server.',
             parameters: {
                 all: { type: 'boolean', description: 'Include disabled servers (default false).' },
             },
@@ -4159,13 +4779,16 @@ export default {
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
             async execute(args) {
-                const blocked = await sceneSwitchBlock();
+                const blocked = await lockedSceneGuard();
                 if (blocked)
                     throw new Error(blocked);
                 const r = await mcpmSetEnabled({ id: args.id, level: args.level, enabled: args.enabled });
                 if (!r.ok)
                     throw new Error(r.error);
-                return 'OK: ' + args.id + ' now ' + (args.enabled ? 'enabled' : 'disabled');
+                // 场景未锁定时，页面 / 模型改的开关都要落进当前场景的档案（与 handlers 层同一套同步）。
+                const syncErr = await syncSwitchToScene('mcpm-set-enabled', args);
+                return 'OK: ' + args.id + ' now ' + (args.enabled ? 'enabled' : 'disabled') +
+                    (syncErr ? '\nWARN: 当前场景档案未同步（' + syncErr + '）' : '');
             },
         }));
         tools.register(defineTool({
@@ -4198,6 +4821,9 @@ export default {
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
             async execute(args) {
+                const blocked = await lockedSceneGuard();
+                if (blocked)
+                    throw new Error(blocked);
                 const r = await mcpmAdd(args);
                 if (!r.ok)
                     throw new Error(r.error);
@@ -4208,7 +4834,7 @@ export default {
         // tools/pre-execute hook below (the model must ask before writing files).
         tools.register(defineTool({
             name: 'skill_manager_list',
-            description: 'List DSH skills with enabled state, effective/shadowed status and source file path. Defaults to enabled skills only; pass all=true for every entry. A copy marked "shadowed by <root>" stays inactive even if enabled.',
+            description: 'List DSH skills with enabled state, effective/shadowed status and source file path. The injected「本机技能目录」system-reminder carries callable skills and summaries only; use this tool to get a source file path (read the file for the full body) and to see entries that are off. Defaults to enabled skills only; pass all=true for every entry. A copy marked "shadowed by <root>" stays inactive even if enabled.',
             parameters: {
                 all: { type: 'boolean', description: 'Include disabled and shadowed entries (default false).' },
             },
@@ -4278,7 +4904,7 @@ export default {
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
             async execute(args) {
-                const blocked = await sceneSwitchBlock();
+                const blocked = await lockedSceneGuard();
                 if (blocked)
                     throw new Error(blocked);
                 const root = String(args.root || 'dsh');
@@ -4286,6 +4912,8 @@ export default {
                 const r = await skillsService.ops[op]({ name: args.name, root });
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || 'skill toggle failed');
+                // 场景未锁定时同步进当前场景档案（与 handlers 层同一套同步）。
+                const syncErr = await syncSwitchToScene(op, { name: args.name, root, enabled: args.enabled === true });
                 // 静默无效是这个工具最容易骗人的地方：同名胜负只由「首选 > 来源优先级」决定，
                 // 与启用状态无关。对影子副本操作会返回 OK，但技能依然不可用。如实说一句。
                 let shadowedBy = '';
@@ -4308,7 +4936,8 @@ export default {
                 const warn = shadowedBy
                     ? ' — BUT this copy is shadowed by the same-name skill in "' + shadowedBy + '", so it stays inactive: enable that copy instead, or make this root the preferred copy in the panel'
                     : '';
-                return 'OK: ' + args.name + ' now ' + (args.enabled ? 'enabled' : 'disabled') + warn;
+                const sceneWarn = syncErr ? '\nWARN: 当前场景档案未同步（' + syncErr + '）' : '';
+                return 'OK: ' + args.name + ' now ' + (args.enabled ? 'enabled' : 'disabled') + warn + sceneWarn;
             },
         }));
         tools.register(defineTool({
@@ -4324,6 +4953,9 @@ export default {
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
             async execute(args) {
+                const blocked = await lockedSceneGuard();
+                if (blocked)
+                    throw new Error(blocked);
                 const r = await skillsService.ops['skill-create']({ name: args.name, description: args.description, body: args.body });
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || 'skill create failed');
@@ -4334,7 +4966,7 @@ export default {
         // AGENTS.md 预设库：模型可查/切，不能造/删（避免模型乱删用户预设）。
         tools.register(defineTool({
             name: 'prompt_manager_list',
-            description: 'List AGENTS.md presets (id, active state, file path). Read that file to see a preset body. Defaults to the preset currently in effect; pass all=true for the whole library.',
+            description: 'List AGENTS.md presets (id, active state, file path). Read that file to see a preset body. The preset in effect right now is injected into your context each turn (the「本机提示词」system-reminder, whose「来源：」line names the file). Defaults to the preset currently in effect; pass all=true for the whole library.',
             parameters: {
                 all: { type: 'boolean', description: 'Include inactive presets (default false).' },
             },
@@ -4379,6 +5011,9 @@ export default {
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
             async execute(args) {
+                const blocked = await lockedSceneGuard();
+                if (blocked)
+                    throw new Error(blocked);
                 const r = await applyPresetGuarded(args.id);
                 if (!r.ok)
                     throw new Error(r.error);
@@ -4391,7 +5026,7 @@ export default {
         // 路径锚点：$DSH_HOME/tool-management/memories/<场景>/…（场景 `global` = 界面「全局」）。
         tools.register(defineTool({
             name: 'memory_manager_list',
-            description: 'List memories under ~/.dsh/tool-management/memories (id, scene, enabled, description). Defaults to the memories that will actually be injected; pass all=true for every entry.',
+            description: 'List memories under ~/.dsh/tool-management/memories (id, scene, enabled, description). The ones actually injected are carried in your context each turn (the「本机当前的场景和记忆」system-reminder); use this tool to find ids/paths or to see entries that are off. Defaults to the memories that will actually be injected; pass all=true for every entry.',
             parameters: {
                 group: { type: 'string', description: 'Optional scene filter.' },
                 all: { type: 'boolean', description: 'Include memories that are off, in an inactive scene, or shadowed (default false).' },
@@ -4457,6 +5092,9 @@ export default {
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
             async execute(args) {
+                const blocked = await lockedSceneGuard();
+                if (blocked)
+                    throw new Error(blocked);
                 const r = await rulesService.ops['rules-create'](args);
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || '创建规则失败');
@@ -4537,11 +5175,13 @@ export default {
                         .catch(() => ({ kind: 'ask', reason: 'Write a memory under ~/.dsh/tool-management/memories' }));
                 }
                 // subagent_manager_run：子代理运行花真 token：默认确认（requireConfirmForModelSubagentRun !== false），可关。
+                // `inherit: true` 时子代理会读到本次会话已完成的对话 —— 卡里如实说明（用户批准的是
+                // "把这段对话交给它"，不只是"跑个子代理"）。文案只在与 fork 有关的部分分叉。
+                const inherits = !!(exec && exec.arguments && exec.arguments.inherit);
+                const ask = { kind: 'ask', reason: inherits ? 'Run a subagent on this conversation (it inherits the conversation; consumes tokens)' : 'Run a subagent (consumes tokens)' };
                 return readPluginSettings()
-                    .then((s) => (s.requireConfirmForModelSubagentRun !== false
-                    ? { kind: 'ask', reason: 'Run a subagent (consumes tokens)' }
-                    : next()))
-                    .catch(() => ({ kind: 'ask', reason: 'Run a subagent (consumes tokens)' }));
+                    .then((s) => (s.requireConfirmForModelSubagentRun !== false ? ask : next()))
+                    .catch(() => ask);
             });
         }
         // ---------- per-tool MCP switches: execution guard + visibility ----------
@@ -4658,7 +5298,7 @@ export default {
                             res.end(JSON.stringify({ ok: false, error: 'missing plugin gate header' }));
                             return;
                         }
-                        const tokenAccepted = TOKEN !== '' && hdr('x-dsh-token') === TOKEN;
+                        const tokenAccepted = TOKEN !== '' && tokenMatches(hdr('x-dsh-token'));
                         if (!tokenAccepted) {
                             const fence = fenceRejection(req, connection);
                             if (fence) {
@@ -4692,7 +5332,7 @@ export default {
                                     return;
                                 }
                             }
-                            if (TOKEN && WRITE_OPS.has(op) && hdr('x-dsh-token') !== TOKEN) {
+                            if (TOKEN && WRITE_OPS.has(op) && !tokenMatches(hdr('x-dsh-token'))) {
                                 res.end(JSON.stringify({ ok: false, error: '缺少或错误的访问令牌（x-dsh-token）' }));
                                 return;
                             }