dsh-plugin-tool-management 0.8.5 → 0.9.1

package/lib/index.js

@@ -20,22 +20,67 @@ 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 { SECTION_ORDER, createPromptSectionRegistrar } from './prompt-sections.js';
+import { createSkillCatalog } from './skills/catalog.js';
+import { DEFAULT_INJECT_SETTINGS, createContextInjector, normalizeInjectSettings, } 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, presetRosterOf, reachNoticeForAgent } from './compat/preset-reach.js';
+import { assessPresetReach, injectionFactsOf, presetRosterOf, readCompositionFacts, reachNoticeForAgent } from './compat/preset-reach.js';
 import { fenceRejection, secretOpRejection } from './http-fence.js';
 import { planOverrideCompaction } from './mcp/override-blocks.js';
-import { createMcpStateCatalog, mcpStateSectionOf } from './mcp/state-section.js';
-import { hubPath, hubRoot, relocateEntries } from './hub.js';
+import { DEFAULT_MCP_NOTE_MAX_LENGTH, createMcpStateCatalog, normalizeMcpNote } from './mcp/state-section.js';
+import { hubBackupDir, hubPath, hubRoot, migrateHubLayoutSync, relocateEntries } from './hub.js';
 import { createScenePromptSync } from './scene-prompt-sync.js';
-import { defineSubagentListTool, defineSubagentRunTool } from './subagents/tools.js';
+import { defineSubagentManagerListTool, defineSubagentManagerRunTool } from './subagents/tools.js';
 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, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { zipSync } from 'fflate';
+/**
+ * 归一化「已知工具」侧车的一行值。
+ *
+ * 兼容两种格式：旧版 `string[]`（只存名字，v0.8.5 及以前）与新版 `Array<{name, description?}>`。
+ * 非法名字、重复名字一律丢掉并去重后按名字排序 —— 排序保证写盘内容稳定（不会因为枚举顺序
+ * 变化而反复重写侧车）。导出仅为测试接缝（与 client 的 `memDefaultPickIds` 同一用意）。
+ */
+export function normalizeKnownTools(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of raw) {
+        const name = typeof item === 'string'
+            ? item
+            : String(item?.name ?? '');
+        if (!name || !/^[A-Za-z0-9_-]{1,128}$/.test(name) || seen.has(name))
+            continue;
+        seen.add(name);
+        const description = typeof item === 'object' && item !== null && typeof item.description === 'string'
+            ? String(item.description)
+            : undefined;
+        out.push({ name, ...(description ? { description } : {}) });
+    }
+    return out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+/**
+ * 「当前可用」工具数：已知工具名里未被停用表扣减的个数；`*` = 整台停用 → 0。
+ *
+ * 场景档案收窄与手动逐工具开关写的是同一张停用表，所以**段、页面、`mcp_manager_list`
+ * 三处的「N 个工具」都必须是这个数** —— 用扣减前的总数会让模型看到自己 schema 里
+ * 并不存在的工具（数字与能调的工具对不上），页面也会和详情页的开关自相矛盾。
+ * 导出仅为测试接缝（与 `normalizeKnownTools` 同一用意）。
+ */
+export function countEnabledTools(known, disabled) {
+    const off = Array.isArray(disabled) ? disabled : [];
+    if (off.indexOf('*') >= 0)
+        return 0;
+    let n = 0;
+    for (const tool of known)
+        if (off.indexOf(tool) < 0)
+            n++;
+    return n;
+}
 // ---------------------------------------------------------------------------
 // Transcript export helpers — mirror the import parsers (src/imports/parsers.js)
 // so an exported file can be imported back losslessly. Pure Node, no ctx.
@@ -71,6 +116,10 @@ export default {
     name: 'dsh-plugin-tool-management-host',
     inject: ['timer', 'fs', 'settings', 'sandboxPolicy', 'webServer', 'tools', 'skills', 'sessions', 'agents', 'workspaceRegistry', 'sessionProjectionCache', 'sessionPersistence'],
     apply(ctx, config) {
+        // 布局迁移必须**先于任何读盘**：hub 内的旧名（`agents-md/` → `prompts/` 等）与
+        // `$DSH_HOME` 根下的插件侧车 / 日志 / patch 备份，都要在服务读它们之前搬到位。
+        // 同步执行：一次性的几次 stat/rename，换来「没有并发窗口」；失败只跳过该项，不抛错。
+        migrateHubLayoutSync();
         const fs = ctx.fs;
         const settings = ctx.settings;
         const sandboxPolicy = ctx.sandboxPolicy;
@@ -125,11 +174,11 @@ export default {
         catch (e) {
             console.error('[dsh-plugin-tool-management] skills provider setup failed:', message(e));
         }
-        // ---------- agents-md 预设库 + 切换 ----------
+        // ---------- 提示词预设库（hub/prompts/）+ 切换 ----------
         // DSH 全局指令基线只有 ~/.dsh/AGENTS.md 一个文件，无内置多预设切换；
-        // 本服务在 hub 内 agents-md/ 维护预设库，「应用」= 写入 ~/.dsh/AGENTS.md，
+        // 本服务在 hub 内 prompts/ 维护预设库，「应用」= 写入 ~/.dsh/AGENTS.md，
         // 下一轮对话生效：宿主 dsh-agent-instructions 每个 agent/pre-step 都会 stat 并重读该文件。
-        // presetsDir 可由 config 注入（测试用），否则落到 $DSH_HOME/tool-management/agents-md。
+        // presetsDir 可由 config 注入（测试用），否则落到 $DSH_HOME/tool-management/prompts。
         // v0.4：旧位置（插件目录 data/agents-md-presets/）在启动时搬入 hub——
         // 插件目录在 npm 安装下会被覆盖，放用户数据在那里本身就丢数据风险。
         const PLUGIN_ROOT = (() => {
@@ -141,7 +190,7 @@ export default {
             }
         })();
         const legacyAgentsMdPresetsDir = join(PLUGIN_ROOT, 'data', 'agents-md-presets');
-        const agentsMdPresetsDir = String(config?.presetsDir || hubPath('agents-md'));
+        const agentsMdPresetsDir = String(config?.presetsDir || hubPath('prompts'));
         void relocateEntries(legacyAgentsMdPresetsDir, agentsMdPresetsDir, (n) => n !== '__last-applied__')
             .catch(() => 0);
         const agentsMdService = createAgentsMdService(ctx, {
@@ -154,9 +203,9 @@ export default {
         });
         // ---------- rules（规则/记忆，v0.4）----------
         // 记忆真源 $DSH_HOME/tool-management/memories/<场景>/<name>.md（仅用户级，D1）。
-        // **场景是显式记录**（rules-index.json 的 scenes 切片）：含保留场景 `global`（界面「全局」，
+        // **场景是显式记录**（memories-index.json 的 scenes 切片）：含保留场景 `global`（界面「全局」，
         // 其记忆注入任何对话），空场景也合法存在——不再是"恰好有这个目录名"的隐式约定。
-        // 单投影 = 活动场景记忆 → per-agent systemPrompt 段（自动在场，模型无需调用任何工具）。
+        // 单投影 = 活动场景记忆 → 上下文注入（自动在场，模型无需调用任何工具；见下方注入通道）。
         // 原"始终层写 ~/.dsh/AGENTS.md"已下线（变更单 01 §4/§10）：公共基线由 _shared/ 承担。
         // 旧的 $DSH_HOME/scene-memory 与 $DSH_HOME/rules 由服务在首次读盘前搬入本目录。
         // rulesRoot / rulesStateDir / rulesScenesDir 仅测试注入，生产留空由服务按 DSH_HOME 解析。
@@ -169,12 +218,7 @@ export default {
                 ? { maxBytes: Number(config.rulesMaxBytes) }
                 : {}),
         });
-        try {
-            ctx.effect(() => rulesService.registerProviders(), 'dsh-plugin-tool-management: rules providers');
-        }
-        catch (e) {
-            console.error('[dsh-plugin-tool-management] rules provider setup failed:', message(e));
-        }
+        // 场景记忆段的注册/生命周期由下面的注入通道统一管（rulesService.memoryText / promptText）。
         // ---------- 场景档案引擎（设计 §2）----------
         // deps 把既有写通道（MCP 单工具启停 / 技能启停）注入引擎；引擎自身串行，
         // 状态机与纯逻辑在 ./rules/archive*.ts。mcpmToolEnabled / readDisabledTools
@@ -240,12 +284,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;
@@ -256,7 +306,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 需要**全量键**（含被覆盖的副本）：场景档案里允许勾选任意一条技能，
@@ -289,6 +356,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) } : {}),
@@ -321,7 +389,7 @@ export default {
                     out[server] = list.filter((t) => t !== '*');
                 // 「已知工具」缓存：未运行服务器也能按最后见过的名单计算补集。
                 for (const [server, list] of Object.entries(await readKnownMcpTools())) {
-                    out[server] = [...new Set([...(out[server] || []), ...list])].sort();
+                    out[server] = [...new Set([...(out[server] || []), ...list.map((item) => item.name)])].sort();
                 }
                 let schemas = [];
                 try {
@@ -342,28 +410,37 @@ export default {
             applyMcpEntries: async (entries) => {
                 const p = await ensurePaths();
                 await withWriteLock(async () => {
-                    await writeJsonFile(sidecarPath(p.home, DISABLED_TOOLS_FILE), entries);
+                    await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), entries);
                 });
                 disabledToolsCache = { at: Date.now(), value: entries };
                 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);
@@ -403,7 +480,7 @@ export default {
                 // 补丁改动由宿主热重载（实测 ≤5s）。这里**不等**，避免进入模式被拖住十几秒；
                 // 界面在应用完成后即可用，工具集合会在数秒内补齐。
             },
-            // 场景备注（v0.8.1）：备注写在 `dsh-plugin-tool-management-notes.json`（按 loader id），
+            // 场景备注（v0.8.1）：备注写在 hub 内的 `mcp-notes.json`（按 loader id），
             // 场景档案按 serverName 存 —— 引擎负责映射与读写，与 mcpm-note 同一条写锁。
             currentMcpNotes: async () => ({ ...(await readNotes()) }),
             applyMcpNotes: async (entries) => {
@@ -416,7 +493,7 @@ export default {
                             delete map[e.id];
                     }
                     const p = await ensurePaths();
-                    await writeJsonFile(sidecarPath(p.home, 'dsh-plugin-tool-management-notes.json'), map);
+                    await writeJsonFile(mcpSidecar(MCP_NOTES_FILE), map);
                     notesCache = { at: Date.now(), value: map };
                 });
             },
@@ -443,12 +520,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) => {
@@ -457,8 +560,9 @@ export default {
             },
             // 人设名全集（保存 subagents 段时校验并报 stale，与 mcp/skills 两段同口径）。
             knownPersonas: async () => new Set((await subagentService.list()).map((p) => p.name)),
-            // 人设开关读/写（进入模式启用档案勾选的人设；退出按快照停回）。
+            // 人设开关读/写（进入模式：勾了的启用、未勾的停用；退出按快照两个方向还原）。
             disabledPersonas: async (names) => subagentService.enabledStore.disabledAmong(names),
+            enabledPersonas: async (names) => subagentService.enabledStore.enabledAmong(names),
             applySubagentSwitches: async (switches) => {
                 const off = switches.filter((s) => !s.enabled).map((s) => s.name);
                 const on = switches.filter((s) => s.enabled).map((s) => s.name);
@@ -475,9 +579,9 @@ export default {
             },
         });
         // ---------- 轻量子智能体（设计 §3）----------
-        // 人设 = $DSH_HOME/tool-management/agents/<name>.md；运行走官方 ctx.subagents.start（spawn provider）。
+        // 人设 = $DSH_HOME/tool-management/subagents/<name>.md；运行走官方 ctx.subagents.start（spawn provider）。
         // sceneLists 供场景绑定校验：启用场景（rules-list 的 active 行）档案里的 subagents 并集。
-        // stateDir 与 rules 共用同一个覆盖键（测试注入一致）；子智能体开关存 <stateDir>/agents-index.json。
+        // stateDir 与 rules 共用同一个覆盖键（测试注入一致）；子智能体开关存 <stateDir>/subagents-index.json。
         const subagentService = createSubagentService(ctx, { stateDir: String(config?.rulesStateDir || '') });
         const subagentSceneLists = async () => {
             const slice = await rulesService.readArchiveSlice();
@@ -488,13 +592,17 @@ export default {
                 .filter((s) => s.active)
                 .map((s) => slice.archives[s.name]?.subagents ?? []);
         };
-        // ---------- 注入类段（P1 人设目录 + P2 MCP 状态）----------
-        // 两者是同一类缺陷的两端：**某个域的配置状态没有在场陈述**，模型只能靠用户口头提醒。
-        //   - 人设：本插件自造的概念，宿主没有对应物 → 模型不知道有哪些人设，subagent_run 不会被触发。
+        // ---------- 注入通道（场景和记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
+        // 这些文本以前是 systemPrompt 段（persona complete 会整段压掉）。现在改走官方的
+        // 「每步注入一条合成消息」通道（skill-catalog / AGENTS.md / 时间上下文同款）：
+        // 任何预设都到得了，内容没变不重发。**每个域一条自己的消息**（来源 kind 各不同，
+        // 轨迹里各自一行），见 src/context-inject.ts 的文件头。
+        //   - 场景和记忆：场景名 + 场景说明 + 记忆正文（同一份文本；场景与记忆是绑定的）。
+        //   - 人设：本插件自造的概念，宿主没有对应物 → 模型不知道有哪些人设，subagent_manager_run 不会被触发。
         //   - MCP：启停只改工具 schema，没有任何显式状态陈述 → 模型不知道有哪些 server，
         //     更拿不到用户写的**备注**（那是写给「未来的模型」的决策提示，工具 schema 永远传达不到）。
-        // 两个段都只列「名字 + 摘要」，正文/工具清单绝不进上下文。
-        // 口径与理由分别见 src/subagents/catalog.ts、src/mcp/state-section.ts 的文件头。
+        // 各域只列「名字 + 摘要」，正文/工具清单绝不进上下文。
+        // 口径与理由分别见 src/subagents/catalog.ts、src/mcp/state-section.ts。
         const subagentCatalog = createSubagentCatalog({
             list: () => subagentService.list(),
             sceneLists: subagentSceneLists,
@@ -503,24 +611,140 @@ export default {
         const mcpStateCatalog = createMcpStateCatalog({
             rows: () => mcpmRowsWithNotes(false),
         });
+        // 技能目录与提示词两个域是**官方载体的兜底**：预设挂得到官方
+        // dsh-tool-skill / dsh-agent-instructions 时注入侧会跳过它们（见 context-inject.ts 的
+        // CARRIER_FACT_OF），挂不到（极简）时才由这里送 —— 所以极简下也能按开关决定要不要。
+        const skillCatalog = createSkillCatalog({
+            state: () => skillsService.ops['skill-state']({}),
+        });
+        // 注入设置（侧车 `inject-settings.json`，界面在「兼容」页）：
+        //   - underSuppressingPresets：压制型预设（persona complete / 关运行时上下文，如极简）
+        //     下是否仍然注入。默认 false = 跟随预设。
+        //   - domains：各域开关（任何预设下都生效；界面五个勾选）。
+        // 注入器每个 step 都要同步读一次设置 → 走 TTL 缓存；未加载时先给默认值并异步预热。
+        const INJECT_SETTINGS_FILE = 'inject-settings.json';
+        const INJECT_SETTINGS_TTL_MS = 3000;
+        let injectSettingsCache = null;
+        async function readInjectSettings(force = false) {
+            if (injectSettingsCache && !force && Date.now() - injectSettingsCache.at < INJECT_SETTINGS_TTL_MS)
+                return injectSettingsCache.value;
+            await ensurePaths();
+            const raw = await readJsonFile(hubPath(INJECT_SETTINGS_FILE));
+            injectSettingsCache = { at: Date.now(), value: normalizeInjectSettings(raw) };
+            return injectSettingsCache.value;
+        }
+        /** 同步快照（注入器取用）；还没加载时先返回默认值，并顺手预热一次。 */
+        function injectSettingsSync() {
+            if (injectSettingsCache)
+                return injectSettingsCache.value;
+            void readInjectSettings().catch(() => { });
+            return DEFAULT_INJECT_SETTINGS;
+        }
+        /** 边界提示要的注入设置快照（总开关 + 各域开关）。 */
+        const injectNoticeOptions = () => {
+            const s = injectSettingsSync();
+            return { underSuppressingPresets: s.underSuppressingPresets, domains: s.domains };
+        };
+        async function injectSettingsOp(args) {
+            const current = await readInjectSettings();
+            if (!args || args.set !== true)
+                return { ok: true, settings: current };
+            const next = normalizeInjectSettings({
+                underSuppressingPresets: typeof args.underSuppressingPresets === 'boolean'
+                    ? args.underSuppressingPresets
+                    : current.underSuppressingPresets,
+                domains: { ...current.domains, ...(args.domains && typeof args.domains === 'object' ? args.domains : {}) },
+            });
+            await ensurePaths();
+            return withWriteLock(async () => {
+                try {
+                    await writeJsonFile(hubPath(INJECT_SETTINGS_FILE), next);
+                }
+                catch (e) {
+                    return { ok: false, error: '设置保存失败: ' + message(e) };
+                }
+                injectSettingsCache = { at: Date.now(), value: next };
+                return { ok: true, settings: next };
+            });
+        }
+        // 注入判定要的两条预设事实（压制型？挂得到 AGENTS.md 通道？）。读取走 TTL 缓存：
+        // 组合文件可以随时被编辑（patchReload: live），但每个 step 读一次盘没有必要。
+        const PRESET_FACTS_TTL_MS = 15_000;
+        const presetFactsCache = new Map();
+        async function presetFactsForAgent(agent) {
+            const roster = presetRoster();
+            if (!roster || typeof roster.composedPreset !== 'function' || typeof roster.read !== 'function')
+                return undefined;
+            let presetId = '';
+            try {
+                presetId = String(roster.composedPreset(agent?.ctx) ?? '');
+            }
+            catch {
+                return undefined;
+            }
+            if (presetId === '')
+                return undefined;
+            const hit = presetFactsCache.get(presetId);
+            if (hit && Date.now() - hit.at < PRESET_FACTS_TTL_MS)
+                return hit.value;
+            try {
+                const text = String((await roster.read(presetId)) ?? '');
+                const value = injectionFactsOf(readCompositionFacts(text));
+                presetFactsCache.set(presetId, { at: Date.now(), value });
+                return value;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        // 注入实况（只读诊断）：注入器的 live() 读回"最近活跃会话"可见表面上的五域文本。
+        // 挂在 apply 作用域：`injection-live` op 与注入器不在同一层（effect 内部）。
+        let contextInjectorLive = null;
         try {
             ctx.effect(() => {
-                const registrar = createPromptSectionRegistrar(ctx, [
-                    { name: 'tool-management:subagents', order: SECTION_ORDER.subagents, text: () => subagentCatalog.text() },
-                    mcpStateSectionOf(mcpStateCatalog, SECTION_ORDER.mcpState),
-                ]);
-                return () => registrar.dispose();
-            }, 'dsh-plugin-tool-management: prompt sections');
+                const injector = createContextInjector({
+                    ctx,
+                    // 顺序即界面勾选与消息顺序（用户裁定 2026-09-16）：场景和记忆 → MCP → 技能 →
+                    // 子智能体 → 提示词。form 是宿主语义轴：记忆是「当前状态」（snapshot，后发取代先发），
+                    // 三个目录是 catalog，提示词是 instructions（与官方 AGENTS.md 那条行同一形态）。
+                    domains: () => [
+                        { key: 'memory', name: 'tool-management:scene-memory', label: '场景和记忆', form: 'snapshot', text: () => rulesService.memoryText() },
+                        { 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() },
+                    ],
+                    settings: () => injectSettingsSync(),
+                    factsFor: (agent) => presetFactsForAgent(agent),
+                });
+                contextInjectorLive = () => injector.live();
+                return () => { contextInjectorLive = null; injector.dispose(); };
+            }, 'dsh-plugin-tool-management: context injection');
         }
         catch (e) {
-            console.error('[dsh-plugin-tool-management] prompt section setup failed:', message(e));
+            console.error('[dsh-plugin-tool-management] context injection setup failed:', message(e));
         }
+        void readInjectSettings().catch(() => { });
         // 预热放到下一轮事件循环：此时 apply 的同步初始化（补丁路径、tools 服务…）已全部完成，
         // 避免在初始化中途就去读 MCP 补丁与工具 schema。
         setTimeout(() => {
             void subagentCatalog.warm();
             void mcpStateCatalog.warm();
+            void skillCatalog.warm();
         }, 0);
+        // 技能写操作成功后立即重算目录（SWR：text() 同步返回缓存值，写后主动 refresh）。
+        // 与下面人设目录同一手法：写入口只有 service 的 writeOps，不需要在界面层逐个补。
+        for (const opName of skillsService.writeOps) {
+            const original = skillsService.ops[opName];
+            if (typeof original !== 'function')
+                continue;
+            skillsService.ops[opName] = async (args) => {
+                const result = await original(args);
+                if (result && result.ok !== false)
+                    void skillCatalog.refresh();
+                return result;
+            };
+        }
         // 人设写操作成功后立即重算目录（SWR：text() 同步返回缓存值，写后主动 refresh）。
         // 包装在 service 的 ops 上：写入口只有这一处，不需要在界面层逐个补。
         for (const opName of subagentService.writeOps) {
@@ -537,7 +761,7 @@ export default {
         /**
          * 人设改名后同步场景绑定：场景档案的 `subagents` 名单存的是**人设名**，
          * 不跟着改就会留一个悬空引用（界面把它报成 stale，用户看到「人设不存在」却找不到地方改）。
-         * 绑定存在 rules-index.json 里，人设服务看不到它，所以在这一层补一次（同提示词改名的做法）。
+         * 绑定存在 memories-index.json 里，人设服务看不到它，所以在这一层补一次（同提示词改名的做法）。
          */
         async function rebindSubagentInArchives(from, to) {
             try {
@@ -601,9 +825,11 @@ export default {
             };
         }
         /**
-         * 模式进行中保存当前场景的档案时，联动人设开关：subagents 段新勾进来的名字**立即启用**，
-         * 并追加进快照的「模式期间自动启用」名单（退出时停回）。只启用、不停用 —— 用户手动
-         * 关掉的开关不该被一次档案保存悄悄改回去。
+         * 模式进行中保存当前场景的档案时，联动人设开关：**档案 = 这个场景开着的人设**
+         * （与进入场景时同一口径，见 archive-engine）——
+         *   新勾进来的立即启用，并追加进快照的「退出时停回」名单；
+         *   取消勾选的立即停用；其中「进场景前就开着」的那些追加进快照的「退出时开回」名单
+         *   （在停回名单里的说明是本次进场景才打开的，退出本来就该关，不进开回名单）。
          */
         const baseSceneArchiveSave = archiveService.ops['scene-archive-save'];
         if (typeof baseSceneArchiveSave === 'function') {
@@ -611,23 +837,33 @@ export default {
                 const res = await baseSceneArchiveSave(args);
                 try {
                     const bound = res && res.ok !== false && res.archive && Array.isArray(res.archive.subagents) ? res.archive.subagents : [];
-                    if (bound.length) {
-                        const slice = await rulesService.readArchiveSlice();
-                        const mode = slice.mode;
-                        if (mode && mode.scene === res.scene) {
-                            const disabled = await subagentService.enabledStore.disabledAmong(bound);
-                            if (disabled.length) {
-                                await subagentService.enabledStore.setEnabled(disabled, true);
-                                void subagentCatalog.refresh();
-                                const snapshot = mode.snapshot;
-                                if (snapshot) {
-                                    const merged = Array.isArray(snapshot.subagents) ? snapshot.subagents.slice() : [];
-                                    for (const n of disabled)
-                                        if (merged.indexOf(n) < 0)
-                                            merged.push(n);
-                                    await rulesService.patchIndex({ mode: { ...mode, snapshot: { ...snapshot, subagents: merged } } });
-                                }
-                            }
+                    const slice = await rulesService.readArchiveSlice();
+                    const mode = slice.mode;
+                    if (mode && mode.scene === res.scene) {
+                        const every = (await subagentService.list()).map((p) => p.name);
+                        const unbound = every.filter((n) => bound.indexOf(n) < 0);
+                        const toOn = await subagentService.enabledStore.disabledAmong(bound);
+                        const toOff = await subagentService.enabledStore.enabledAmong(unbound);
+                        if (toOn.length)
+                            await subagentService.enabledStore.setEnabled(toOn, true);
+                        if (toOff.length)
+                            await subagentService.enabledStore.setEnabled(toOff, false);
+                        if (toOn.length || toOff.length)
+                            void subagentCatalog.refresh();
+                        const snapshot = mode.snapshot;
+                        // 新快照带**全量映射**（`subagentsAll`，v0.9.1）→ 退出按映射逐个精确还原，这两个
+                        // 部分名单不再需要，也不再往新快照里写（老快照没有映射，仍然照旧维护，见
+                        // archive-engine 的 restoreSnapshot 兼容分支）。
+                        if (snapshot && !snapshot.subagentsAll && (toOn.length || toOff.length)) {
+                            const backOn = Array.isArray(snapshot.subagents) ? snapshot.subagents.slice() : [];
+                            const offList = Array.isArray(snapshot.subagentsOn) ? snapshot.subagentsOn.slice() : [];
+                            for (const n of toOn)
+                                if (backOn.indexOf(n) < 0)
+                                    backOn.push(n);
+                            for (const n of toOff)
+                                if (backOn.indexOf(n) < 0 && offList.indexOf(n) < 0)
+                                    offList.push(n);
+                            await rulesService.patchIndex({ mode: { ...mode, snapshot: { ...snapshot, subagents: backOn, subagentsOn: offList } } });
                         }
                     }
                 }
@@ -652,7 +888,7 @@ export default {
             // last line of defense for plaintext credentials too, not just writes.
             'mcpm-reveal',
             'skill-open',
-            // agents-md 写操作（create/update/remove 改预设库；apply 写全局 AGENTS.md；import 从外部内容建预设）
+            // 提示词写操作（create/update/remove 改预设库；apply 写全局 AGENTS.md；import 从外部内容建预设）
             'agentsmd-create', 'agentsmd-update', 'agentsmd-apply', 'agentsmd-remove', 'agentsmd-import',
             // 提示词预设的回收站（恢复 / 永久删除都是写）
             'agentsmd-trash-restore', 'agentsmd-trash-delete',
@@ -663,6 +899,8 @@ export default {
             // 通用导出：往用户指定的目录写文件，按写操作门禁（token）。
             'bundle-export',
             'history-archive-batch', 'history-workspace-register',
+            // 注入设置（五个域开关 / 压制型预设口径）写侧车，按写操作门禁。
+            'inject-settings',
         ]);
         // 会泄露明文凭据 / 完整配置的 op：**必须**带对的访问令牌，没配令牌就一律拒绝
         // （判定在 http-fence.ts 的 secretOpRejection，含两种情况的区分与理由）。
@@ -677,7 +915,7 @@ export default {
         // 历史侧车三件套（归档时刻账本 / 保留期设置 / 工作区登记快照）统一放 hub 根
         // （`$DSH_HOME/tool-management/`），**不放插件目录**：npm 安装下插件目录会被
         // `dsh plugin update` 整体替换，放那里等于"升级即丢账本"——账本一丢，保留期基线
-        // 就从 archivedAt 退回 createdAt，归档会话会被提前清掉（v0.4 把 agents-md 预设
+        // 就从 archivedAt 退回 createdAt，归档会话会被提前清掉（v0.4 把提示词预设
         // 搬进 hub 是同一条理由，见上方注释；这三个是当时漏掉的）。
         // 旧位置（插件目录 data/）在启动时一次性搬入：只搬不删、绝不覆盖、失败下次再试。
         const historyArchivedAtFile = String(config?.archivedAtFile || hubPath('history-archived-at.json'));
@@ -738,31 +976,44 @@ export default {
             }
         }
         /**
-         * **当前生效的提示词预设 id**（界面「生效中」的那一份），供写操作做门禁：
-         *   ① 启用的场景绑定了它 → 就是它（场景优先级最高，与 agentsmd-list 的标记同一口径）；
-         *   ② 否则回退到文件比对（`~/.dsh/AGENTS.md` 内容 == 某份预设）。
-         * 探测失败返回 `null`（调用方决定放行还是拒绝；当前只在删除上使用，放行 + warn）。
+         * **应用提示词预设的唯一入口**（界面 op 与模型工具共用）。
+         *
+         * 场景接管期间（启用场景 / 全局绑定在驱动基线）：
+         *   - 应用**同一份** = 重新应用（把被手改的基线写回去），走场景同步；
+         *   - 应用**别的份** = 换掉这个场景的绑定（用户裁定 2026-09-17：未锁定时切换要可用，
+         *     并且同步写进场景档案）。绑定改完再走一次场景同步，于是「场景页显示什么 / 实际注入
+         *     什么 / 谁是引用方」三处立刻重新对齐（此前的做法是直接拒绝，用户得先退出场景）。
+         * 锁定仍由 `guardLockedOps` 挡住（agentsmd-apply 在冻结清单里）。
          */
-        async function effectivePresetId() {
-            try {
-                const r = await rulesService.ops['rules-list']({});
-                const sp = r && r.ok ? r.scenePrompt : null;
-                if (sp && sp.scene && !sp.missing && sp.presetId)
-                    return String(sp.presetId);
-            }
-            catch (e) {
-                ctx.logger?.warn?.(`agents-md: scene prompt probe failed: ${message(e)}`);
-            }
-            try {
-                const cur = await agentsMdService.getCurrent();
-                if (cur && cur.ok && cur.presetId)
-                    return String(cur.presetId);
-            }
-            catch (e) {
-                ctx.logger?.warn?.(`agents-md: global baseline probe failed: ${message(e)}`);
+        async function applyPresetGuarded(id) {
+            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) || '未知原因'}`,
+                        };
+                    }
+                }
+                const r = await scenePromptSync.sync();
+                if (r.error)
+                    return { ok: false, error: r.error };
+                return { ok: true, id, viaScene: true };
             }
-            return null;
+            return agentsMdService.apply(id);
         }
+        /** 删除拒绝里的引用说明（人话；与界面标签同一套结构化事实）。 */
+        const promptRefReason = (ref) => {
+            if (ref && ref.kind === 'scene')
+                return `场景「${ref.label || ''}」${ref.active ? '（已启用）' : ''}绑定了它`;
+            if (ref && ref.kind === 'restore')
+                return '它就是退出场景后要恢复的全局提示词';
+            return '~/.dsh/AGENTS.md 当前内容就是它';
+        };
         async function readHistoryRetention() {
             try {
                 await historyStandby;
@@ -867,7 +1118,6 @@ export default {
             catch (e) { /* ignore */ }
             if (!home)
                 throw new Error('无法确定 DSH 主目录（settings.prepareDocument 未返回路径）');
-            await migrateRenamedData(home);
             const sep = home.indexOf('\\') >= 0 ? '\\' : '/';
             let profileDir = null;
             let profileName = 'web';
@@ -914,33 +1164,9 @@ export default {
                 return false;
             }
         }
-        // ---------- one-time data migration (pre-rename sidecars & state) ----------
-        // The plugin used to ship under the name dsh-skill-mcp-manager: its sidecar
-        // JSON files and the skills state directory lived under the old prefix. On
-        // first boot pull them to the new names so an upgraded install keeps its
-        // data. Best effort — any failure just starts the new layout from scratch.
-        async function migrateRenamedData(home) {
-            const sep = home.indexOf('\\') >= 0 ? '\\' : '/';
-            const pairs = [
-                // 状态目录经历过两次改名：skill-mcp-manager → dsh-plugin-tool-management → tool-management
-                ['skill-mcp-manager', 'tool-management'],
-                ['dsh-plugin-tool-management', 'tool-management'],
-                ['skill-mcp-manager-notes.json', 'dsh-plugin-tool-management-notes.json'],
-                ['skill-mcp-manager-settings.json', 'dsh-plugin-tool-management-settings.json'],
-                ['skill-mcp-manager-disabled-tools.json', 'dsh-plugin-tool-management-disabled-tools.json'],
-                ['skill-mcp-manager-export.json', 'dsh-plugin-tool-management-export.json'],
-            ];
-            for (const [oldName, newName] of pairs) {
-                try {
-                    const oldAbs = home + sep + oldName;
-                    const newAbs = home + sep + newName;
-                    if (!(await exists(oldAbs)) || (await exists(newAbs)))
-                        continue;
-                    await rename(oldAbs, newAbs);
-                }
-                catch (e) { /* best effort */ }
-            }
-        }
+        // 一次性数据迁移（旧插件名 / 旧侧车名 / 旧 hub 目录名）已统一收进 hub.ts 的
+        // `migrateHubLayoutSync()`（在 apply() 开头、任何读盘之前同步跑一次）——
+        // 这里不再维护第二份迁移表，避免两处口径漂移。
         async function readPatch(abs) {
             try {
                 const t = await fs.resolve(abs);
@@ -961,17 +1187,27 @@ export default {
             const p = (n) => String(n).padStart(2, '0');
             return '' + d.getFullYear() + p(d.getMonth() + 1) + p(d.getDate()) + '-' + p(d.getHours()) + p(d.getMinutes()) + p(d.getSeconds());
         }
+        // 改 patch 前的自动备份：写在 `hub/backups/`（不再堆在 `$DSH_HOME` 根下）。
+        // 两个 patch 都叫 `cordis.patch.yml`（全局 + `profiles/<名字>/`），所以备份名里带上层级，
+        // 否则两处在同一个目录里互相撞名、互相挤掉。最坏情况（配置写坏导致 DSH 起不来）
+        // 按文档里的路径找回：`~/.dsh/tool-management/backups/`。
         async function backupPatchFile(abs, previous) {
             const i = Math.max(abs.lastIndexOf('\\'), abs.lastIndexOf('/'));
             if (i <= 0)
                 return;
-            const dir = abs.slice(0, i);
             const base = abs.slice(i + 1);
-            await writeFile(abs + '.bak-' + backupStamp(), previous, 'utf8');
+            const profile = /(?:^|[\\/])profiles[\\/]([^\\/]+)$/.exec(abs.slice(0, i));
+            const tag = profile ? 'profile-' + profile[1].replace(/[^A-Za-z0-9._-]/g, '_') : 'global';
+            const stem = base + '.' + tag;
+            const dir = hubBackupDir();
+            await mkdir(dir, { recursive: true });
+            await writeFile(join(dir, stem + '.bak-' + backupStamp()), previous, 'utf8');
             try {
-                const names = (await readdir(dir)).filter((name) => name.startsWith(base + '.bak-')).sort();
+                // 旧位置的备份没有层级后缀（迁移搬进来的），只统计不删错别人的。
+                const mine = (name) => name.startsWith(stem + '.bak-') || (tag === 'global' && name.startsWith(base + '.bak-'));
+                const names = (await readdir(dir)).filter(mine).sort();
                 for (const stale of names.slice(0, Math.max(0, names.length - KEEP_PATCH_BACKUPS))) {
-                    await unlink(dir + abs[i] + stale);
+                    await unlink(join(dir, stale));
                 }
             }
             catch (e) { /* pruning is best-effort */ }
@@ -1439,12 +1675,7 @@ export default {
         // for display. Only the direct `properties` of the parameters object are
         // summarized — nested object/array children are omitted (one level is enough
         // for a preview, keeps the dialog readable).
-        // ---------- plugin-owned side-car data (notes / settings) ----------
-        // The patch file carries loader config only, so user-facing extras live in
-        // small JSON files under the DSH home, next to the patch files they describe.
-        function sidecarPath(home, name) {
-            return home + (home.indexOf('\\') >= 0 ? '\\' : '/') + name;
-        }
+        // ---------- plugin-owned side-car data (notes / settings / disabled tools) ----------
         async function readJsonFile(abs) {
             try {
                 return JSON.parse(await readFile(abs, 'utf8'));
@@ -1463,13 +1694,24 @@ export default {
         // hit the cache, but every WRITE re-reads the file (force=true) and merges
         // on top of the fresh on-disk state. Without the forced re-read, a manual
         // edit of the sidecar file would be silently overwritten by a stale cache.
+        //
+        // 落点：**hub 内**（`~/.dsh/tool-management/`），文件名按域取（`mcp-*`）。
+        // 它们曾经躺在 `$DSH_HOME` 根下、还带着插件名前缀（`dsh-plugin-tool-management-notes.json`），
+        // 2026-09-16 用户要求「插件产生的文件全部收进 hub、名字与当前代码一致」——
+        // 旧文件由 hub.ts 的 `migrateHubLayoutSync()` 在启动时搬进来（见 apply()）。
         const SIDECAR_TTL_MS = 3000;
+        const MCP_NOTES_FILE = 'mcp-notes.json';
+        const MCP_SETTINGS_FILE = 'mcp-settings.json';
+        const MCP_DISABLED_TOOLS_FILE = 'mcp-disabled-tools.json';
+        const MCP_KNOWN_TOOLS_FILE = 'mcp-known-tools.json';
+        const MCP_EXPORT_FILE = 'mcp-export.json';
+        /** MCP 侧车绝对路径（都在 hub 内）。 */
+        const mcpSidecar = (name) => hubPath(name);
         let notesCache = null;
         async function readNotes(force = false) {
             if (notesCache && !force && Date.now() - notesCache.at < SIDECAR_TTL_MS)
                 return notesCache.value;
-            const p = await ensurePaths();
-            const raw = await readJsonFile(sidecarPath(p.home, 'dsh-plugin-tool-management-notes.json'));
+            const raw = await readJsonFile(mcpSidecar(MCP_NOTES_FILE));
             const out = {};
             if (raw && typeof raw === 'object') {
                 for (const key of Object.keys(raw)) {
@@ -1495,7 +1737,7 @@ export default {
                 else
                     delete map[id];
                 try {
-                    await writeJsonFile(sidecarPath(p.home, 'dsh-plugin-tool-management-notes.json'), map);
+                    await writeJsonFile(mcpSidecar(MCP_NOTES_FILE), map);
                 }
                 catch (e) {
                     return { ok: false, error: '备注保存失败: ' + message(e) };
@@ -1519,7 +1761,7 @@ export default {
             if (pluginSettingsCache && !force && Date.now() - pluginSettingsCache.at < SIDECAR_TTL_MS)
                 return pluginSettingsCache.value;
             const p = await ensurePaths();
-            const raw = await readJsonFile(sidecarPath(p.home, 'dsh-plugin-tool-management-settings.json'));
+            const raw = await readJsonFile(mcpSidecar(MCP_SETTINGS_FILE));
             pluginSettingsCache = {
                 at: Date.now(),
                 value: {
@@ -1555,7 +1797,7 @@ export default {
             const p = await ensurePaths();
             return withWriteLock(async () => {
                 try {
-                    await writeJsonFile(sidecarPath(p.home, 'dsh-plugin-tool-management-settings.json'), next);
+                    await writeJsonFile(mcpSidecar(MCP_SETTINGS_FILE), next);
                 }
                 catch (e) {
                     return { ok: false, error: '设置保存失败: ' + message(e) };
@@ -1570,13 +1812,12 @@ export default {
         // every scope's model-visible schema list, and `tools.guard` denies the call
         // before the body runs. Disabled tools therefore become invisible AND
         // uncallable — no patch rewrite, no DSH restart.
-        const DISABLED_TOOLS_FILE = 'dsh-plugin-tool-management-disabled-tools.json';
         let disabledToolsCache = null;
         async function readDisabledTools(force = false) {
             if (disabledToolsCache && !force && Date.now() - disabledToolsCache.at < SIDECAR_TTL_MS)
                 return disabledToolsCache.value;
             const p = await ensurePaths();
-            const raw = await readJsonFile(sidecarPath(p.home, DISABLED_TOOLS_FILE));
+            const raw = await readJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE));
             const out = {};
             if (raw && typeof raw === 'object') {
                 for (const serverName of Object.keys(raw)) {
@@ -1607,19 +1848,18 @@ export default {
         // 场景档案里既显示 0 工具、工具明细也空空如也 —— 用户没法给未运行服务器挑工具。
         // 每次枚举到 live 工具时按 serverName 记一份「最后见过的工具名」，未运行时用它兜底：
         // 场景档案能列出/勾选，进入场景后按实际注册的工具生效（restrict 会过滤掉不存在的名字）。
-        const KNOWN_MCP_TOOLS_FILE = 'dsh-plugin-tool-management-mcp-tools.json';
         let knownMcpToolsCache = null;
         async function readKnownMcpTools(force = false) {
             if (knownMcpToolsCache && !force && Date.now() - knownMcpToolsCache.at < SIDECAR_TTL_MS)
                 return knownMcpToolsCache.value;
             const p = await ensurePaths();
-            const raw = await readJsonFile(sidecarPath(p.home, KNOWN_MCP_TOOLS_FILE));
+            const raw = await readJsonFile(mcpSidecar(MCP_KNOWN_TOOLS_FILE));
             const out = {};
             if (raw && typeof raw === 'object') {
                 for (const serverName of Object.keys(raw)) {
-                    const list = raw[serverName];
-                    if (Array.isArray(list))
-                        out[serverName] = list.map((name) => String(name)).filter((name) => /^[A-Za-z0-9_-]{1,128}$/.test(name)).sort();
+                    const list = normalizeKnownTools(raw[serverName]);
+                    if (list.length)
+                        out[serverName] = list;
                 }
             }
             knownMcpToolsCache = { at: Date.now(), value: out };
@@ -1627,7 +1867,7 @@ export default {
         }
         async function writeKnownMcpTools(value) {
             const p = await ensurePaths();
-            await writeJsonFile(sidecarPath(p.home, KNOWN_MCP_TOOLS_FILE), value);
+            await writeJsonFile(mcpSidecar(MCP_KNOWN_TOOLS_FILE), value);
             knownMcpToolsCache = { at: Date.now(), value: value };
         }
         /** 单工具停用判定（含整服务器通配 `*`——场景档案的"MCP 工具集=整台"写的就是它）。 */
@@ -1667,7 +1907,7 @@ export default {
                 else
                     delete map[serverName];
                 try {
-                    await writeJsonFile(sidecarPath(p.home, DISABLED_TOOLS_FILE), map);
+                    await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), map);
                 }
                 catch (e) {
                     return { ok: false, error: '保存失败: ' + message(e) };
@@ -1861,12 +2101,19 @@ export default {
                 }
             }
             // 「已知工具」缓存兜底：服务器没运行时 schemas() 里没有它任何工具 —— 场景档案里
-            // 想给未运行服务器挑工具就全靠这份最后见过的名单（描述/参数不可用，按名字勾选）。
-            for (const name of (await readKnownMcpTools())[serverName] || []) {
-                if (listed.has(name))
+            // 想给未运行服务器挑工具就全靠这份最后见过的名单。描述也一并带上（v0.9.0 起缓存），
+            // 并标 `stale: true`：界面据此说明「上次运行时」，不假装是实时数据。
+            for (const known of (await readKnownMcpTools())[serverName] || []) {
+                if (listed.has(known.name))
                     continue;
-                toolsList.push({ name, description: '（服务器未运行；描述暂不可用）', enabled: !disabledHere.has(name), parameters: [] });
-                listed.add(name);
+                toolsList.push({
+                    name: known.name,
+                    description: known.description || '（服务器未运行；这个名字来自上次运行记录）',
+                    enabled: !disabledHere.has(known.name),
+                    parameters: [],
+                    stale: true,
+                });
+                listed.add(known.name);
             }
             return { ok: true, tools: toolsList };
         }
@@ -1903,13 +2150,19 @@ export default {
                 for (;;) {
                     const t = await mcpmTools({ serverName });
                     if (t && t.ok && (t.tools || []).length) {
-                        // 记进「已知工具」缓存：以后未运行时场景档案也能列出。
-                        const names = t.tools.map((x) => String(x.name)).filter(Boolean);
-                        if (names.length) {
+                        // 记进「已知工具」缓存：以后未运行时场景档案也能列出（名字 + 这次的描述）。
+                        const known = t.tools
+                            .filter((x) => String(x && x.name))
+                            .map((x) => ({ name: String(x.name), ...(typeof x.description === 'string' && x.description ? { description: x.description } : {}) }));
+                        if (known.length) {
                             try {
                                 const cache = await readKnownMcpTools();
-                                const merged = [...new Set([...(cache[serverName] || []), ...names])].sort();
-                                cache[serverName] = merged;
+                                const byName = new Map((cache[serverName] || []).map((item) => [item.name, item]));
+                                for (const item of known) {
+                                    const old = byName.get(item.name);
+                                    byName.set(item.name, old && old.description && !item.description ? old : { ...old, ...item });
+                                }
+                                cache[serverName] = [...byName.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
                                 await writeKnownMcpTools(cache);
                             }
                             catch { /* 缓存写失败不影响本次返回 */ }
@@ -1950,10 +2203,13 @@ export default {
                     rows.push(normalizeRow(r, level, abs));
             }
             const toolCounts = {};
+            const enabledToolCounts = {};
             try {
                 const schemas = await tools.schemas();
                 const knownCache = await readKnownMcpTools();
+                const disabledMap = await readDisabledTools();
                 const liveNames = {};
+                const liveTools = {};
                 const seen = new Set();
                 for (const s of schemas) {
                     const fullName = String(s && s.name || '');
@@ -1966,6 +2222,11 @@ export default {
                     const list = liveNames[m[1]] || (liveNames[m[1]] = []);
                     if (list.indexOf(m[2]) < 0)
                         list.push(m[2]);
+                    // 顺手把描述记下来：未运行时详情页就有东西可显示，不必再重复「描述暂不可用」。
+                    const bucket = liveTools[m[1]] || (liveTools[m[1]] = []);
+                    const desc = typeof s.description === 'string' ? s.description : '';
+                    if (!bucket.some((t) => t.name === m[2]))
+                        bucket.push({ name: m[2], ...(desc ? { description: desc } : {}) });
                 }
                 // 工具数 = live ∪ 停用表里的单个工具名 ∪ 「已知工具」缓存 —— 未运行的服务器
                 // 也能显示最后一次见过的工具数，而不是永远 0。
@@ -1979,24 +2240,42 @@ export default {
                 for (const [server, list] of Object.entries(liveNames))
                     for (const t of list)
                         addTool(server, t);
-                for (const [server, list] of Object.entries(await readDisabledTools()))
+                for (const [server, list] of Object.entries(disabledMap))
                     for (const t of list)
                         if (t !== '*')
                             addTool(server, t);
                 for (const [server, list] of Object.entries(knownCache))
                     for (const t of list)
-                        addTool(server, t);
-                for (const [server, set] of Object.entries(union))
+                        addTool(server, t.name);
+                for (const [server, set] of Object.entries(union)) {
                     toolCounts[server] = set.size;
-                // 回写「已知工具」：live 见到的名字并入缓存（有变化才写盘，读路径上的 best-effort）。
+                    // 可用数 = 已知工具里未被停用表扣减的（`*` = 整台停用 → 0）。场景档案收窄与
+                    // 手动逐工具开关写的是同一张停用表，段与页面的「N 个工具」都必须按它扣减，
+                    // 否则收窄后模型看到的数字比它能调的工具多，页面与详情页也会互相矛盾。
+                    enabledToolCounts[server] = countEnabledTools(set, disabledMap[server] || []);
+                }
+                // 回写「已知工具」：live 见到的名字与描述并入缓存（有变化才写盘，读路径上的 best-effort）。
+                // 名字集合变化，或某个已知工具这次拿到了描述而缓存里没有 → 都算变化。
                 let cacheChanged = false;
-                for (const [server, list] of Object.entries(liveNames)) {
+                for (const [server, list] of Object.entries(liveTools)) {
                     const prev = knownCache[server] || [];
-                    const next = [...new Set([...prev, ...list])].sort();
-                    if (next.join('\u0000') !== prev.join('\u0000')) {
-                        knownCache[server] = next;
-                        cacheChanged = true;
+                    const byName = new Map(prev.map((t) => [t.name, t]));
+                    for (const tool of list) {
+                        const old = byName.get(tool.name);
+                        if (!old) {
+                            byName.set(tool.name, tool);
+                            cacheChanged = true;
+                            continue;
+                        }
+                        if (tool.description && old.description !== tool.description) {
+                            byName.set(tool.name, { ...old, description: tool.description });
+                            cacheChanged = true;
+                        }
                     }
+                    const next = [...byName.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+                    if (next.length !== prev.length)
+                        cacheChanged = true;
+                    knownCache[server] = next;
                 }
                 if (cacheChanged)
                     void writeKnownMcpTools(knownCache).catch(() => { });
@@ -2013,14 +2292,23 @@ export default {
             for (const e of live) {
                 const bid = bareEntryId(e.entryId);
                 const found = rows.find((r) => r.id === bid);
-                if (found)
-                    found.live = { enabled: e.enabled, phase: e.fiberPhase };
+                if (found) {
+                    // **补丁说停用 → 它不可能在运行。** loader 的清单偶尔停在上一帧（用户实测：退出场景后
+                    // 开关已关、进程已停、AI 也调不到，页面却仍显示「已运行」）——同一个响应里两处矛盾时
+                    // 以**补丁**为准：开关是真正生效的控制面，显示跟着它走，四者（实际 / 显示 / 开关 / AI）
+                    // 才一致。反方向的偏差（刚停用、进程还在收尾的几秒）同样由补丁给出的答案兜住。
+                    found.live = found.disabled
+                        ? { enabled: false, phase: e.fiberPhase }
+                        : { enabled: e.enabled, phase: e.fiberPhase };
+                }
                 else
                     rows.push({ id: e.entryId, serverName: e.entryId, transport: null, url: null, command: null, args: null, env: null, headers: null, level: 'loader', disabled: !e.enabled, managed: false, live: { enabled: e.enabled, phase: e.fiberPhase } });
             }
             for (const row of rows) {
                 if (row.toolCount === undefined)
                     row.toolCount = toolCounts[row.serverName] || 0;
+                if (row.enabledToolCount === undefined)
+                    row.enabledToolCount = enabledToolCounts[row.serverName] || 0;
             }
             // 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.
@@ -2146,7 +2434,7 @@ export default {
                         toolMap[serverName] = toolMap[cur.serverName];
                         delete toolMap[cur.serverName];
                         try {
-                            await writeJsonFile(sidecarPath(p.home, DISABLED_TOOLS_FILE), toolMap);
+                            await writeJsonFile(mcpSidecar(MCP_DISABLED_TOOLS_FILE), toolMap);
                         }
                         catch (e) { /* non-fatal */ }
                         disabledToolsCache = { at: Date.now(), value: toolMap };
@@ -2433,7 +2721,7 @@ export default {
             const json = JSON.stringify({ exportedAt: new Date().toISOString(), rows }, null, 2);
             let savedTo = null;
             try {
-                const abs = p.home + (p.home.indexOf('\\') >= 0 ? '\\' : '/') + 'dsh-plugin-tool-management-export.json';
+                const abs = mcpSidecar(MCP_EXPORT_FILE);
                 await writePatch(abs, json);
                 savedTo = abs;
             }
@@ -2834,7 +3122,7 @@ export default {
          * 单个预设的工具名（列表里含 MCP 与宿主平面的工具，因为子代理的可见集合是
          * "宿主平面 ∪ 该预设"的并集）。枚举会为该预设建立 standing mount —— 官方语义：
          * 一个预设每进程只挂一次，正常创建会话时同样会挂，所以这里按 id 缓存 60 秒；
-         * `subagent_run` 每次委派都要用它校验名单，不能每次都重新枚举。
+         * `subagent_manager_run` 每次委派都要用它校验名单，不能每次都重新枚举。
          */
         const presetNamesCache = new Map();
         async function presetToolNames(id) {
@@ -3077,11 +3365,20 @@ export default {
                 // 场景驱动时**只有场景绑的那份**算生效中（用户裁定）；文件里那份降级为「文件里是它」，
                 // 因为场景的提示词已经接管基线。没有场景驱动时才按文件比对定「生效中」。
                 const sceneDrives = sceneId !== null;
+                // 引用清单与删除保护同源（scene-prompt-sync）：界面据此禁用删除并说明「谁在用」，
+                // 不必自己再拼一遍判定（那正是这次四处状态各说各话的根源）。探测失败 = 空清单。
+                const refs = await scenePromptSync.refs();
                 const presets = base.presets.map((p) => {
                     const fileApplied = p.active === true;
                     const byScene = sceneDrives && sceneId === p.id;
                     const active = sceneDrives ? byScene : fileApplied;
-                    return { ...p, active, fileApplied, activeVia: byScene ? 'scene' : (active && fileApplied ? 'file' : null) };
+                    return {
+                        ...p,
+                        active,
+                        fileApplied,
+                        activeVia: byScene ? 'scene' : (active && fileApplied ? 'file' : null),
+                        refs: refs ? refs.get(p.id) || [] : [],
+                    };
                 });
                 return { ...base, presets, ...(scenePrompt ? { scenePrompt } : {}) };
             },
@@ -3093,7 +3390,7 @@ export default {
                 ...(args && typeof args.description === 'string' ? { description: String(args.description) } : {}),
             }),
             // 保存：改正文 + 可选改名（nextId）。改名成功顺带把场景绑定一起改名 ——
-            // 绑定存在 rules-index.json 里，预设库自己看不到，不叫这一声就会留悬空绑定。
+            // 绑定存在 memories-index.json 里，预设库自己看不到，不叫这一声就会留悬空绑定。
             // 保存后同步一次全局基线：若改的正是「正在驱动基线的那份」，正文要跟着写进
             // `~/.dsh/AGENTS.md`（否则页面标着「生效中」而文件里还是旧内容）。
             'agentsmd-update': async (args) => {
@@ -3112,24 +3409,37 @@ export default {
                 }
                 return withAgentsMdSync({ ...res, ...renamed });
             },
-            'agentsmd-apply': (args) => agentsMdService.apply(String((args && args.id) || '')),
+            // 应用 = 写全局基线文件；场景接管期间只放行「场景绑定的那一份」（见 applyPresetGuarded）。
+            'agentsmd-apply': (args) => applyPresetGuarded(String((args && args.id) || '')),
             'agentsmd-get-current': () => agentsMdService.getCurrent(),
-            // 删除：**正在生效的那份拒绝删除**（用户裁定）。生效 = 启用的场景绑定了它，
-            // 否则 = 文件内容就是它。禁用的按钮只是提示，真正的门在这里（模型与旧页面也会走这条路）。
-            // 探测失败时放行并记一条 warn：删预设不动 ~/.dsh/AGENTS.md，最坏是少一份副本，可重建。
+            // 删除：**被引用的那份一律拒绝**（用户裁定，2026-09-16 扩到引用清单）。三类引用：
+            // 场景绑定（含恒常的 `_shared` / `global`）、`~/.dsh/AGENTS.md` 的当前内容、
+            // 进场景前保存的基线（退出场景后要恢复的那一份）。拒绝时逐条说明「谁在用」，
+            // 用户知道该先改哪里。引用清单由 scene-prompt-sync 与显示/注入同源算出。
+            // 探测失败（refs() 返回 null）时放行并记 warn：删预设不动 ~/.dsh/AGENTS.md，
+            // 最坏是少一份副本，可重建 —— 不因一次探测故障把删除堵死。
             'agentsmd-remove': async (args) => {
                 const id = String((args && args.id) || '');
-                const effective = await effectivePresetId();
-                if (effective !== null && effective === id) {
-                    return { ok: false, error: `「${id}」正在生效，不能删除：先启用别的场景或换绑提示词，或先把别的预设应用上去。` };
+                const refs = await scenePromptSync.refs();
+                if (refs === null)
+                    ctx.logger?.warn?.('agents-md: reference probe failed; remove allowed');
+                const why = refs ? refs.get(id) || [] : [];
+                if (why.length) {
+                    return {
+                        ok: false,
+                        code: 'error.agentsMd.referenced',
+                        error: `「${id}」仍被引用，不能删除：${why.map(promptRefReason).join('；')}。先改掉引用（换绑提示词 / 退出场景 / 应用别的预设）再删除。`,
+                    };
                 }
                 return agentsMdService.remove(id);
             },
             'agentsmd-import': (args) => agentsMdService.importPreset(String((args && args.id) || ''), String((args && args.content) ?? ''), args && typeof args.description === 'string' ? String(args.description) : undefined),
-            // 提示词预设的回收站：删预设 = 把整个预设目录移入 `hub/trash/agents-md-trash/<id>/`，
+            // 提示词预设的回收站：删预设 = 把整个预设目录移入 `hub/trash/prompts-trash/<id>/`，
             // 误删可从「提示词」页的回收站里恢复（同 id 已存在时拒绝恢复，绝不覆盖）。
             'agentsmd-trash-list': () => agentsMdService.trashList(),
-            'agentsmd-trash-restore': (args) => agentsMdService.trashRestore(String((args && args.id) || '')),
+            // 恢复也要同步：把一个「场景绑定着、但曾被删掉」的预设恢复回来 → 绑定重新变活，
+            // 基线要跟着写回它（否则场景页说「生效中：它」而文件里并不是）。
+            'agentsmd-trash-restore': async (args) => withAgentsMdSync(await agentsMdService.trashRestore(String((args && args.id) || ''))),
             'agentsmd-trash-delete': (args) => agentsMdService.trashDelete(String((args && args.id) || '')),
             // History（归档会话管理）ops。只读：history-list / history-retention-get；
             // 写：history-archive / history-unarchive / history-delete / history-retention-set。
@@ -3344,7 +3654,8 @@ export default {
             },
             // 预设可达性矩阵：每个 Agent 预设下，本插件的注入类能力到不到得了模型。
             // 只读预设组合文本，不挂载任何预设、不改任何数据。回答的是"面板上说注入了，
-            // 模型真的看得到吗" —— minimal 这类 persona complete 的预设会压制全部提示词段。
+            // 模型真的看得到吗" —— 压制型预设（persona complete / includeRuntimeContext:false，
+            // 如极简）默认不注入，可在「注入」设置里改成强制注入。
             'preset-reach': async () => {
                 try {
                     // 宿主平面的 MCP 工具数：四个官方预设都不在组合里挂 MCP，MCP 由
@@ -3359,13 +3670,31 @@ export default {
                     catch {
                         mcpTools = undefined;
                     }
-                    const report = await assessPresetReach(presetRoster(), { mcpTools });
+                    const settings = await readInjectSettings();
+                    const report = await assessPresetReach(presetRoster(), {
+                        mcpTools,
+                        inject: { underSuppressingPresets: settings.underSuppressingPresets, domains: settings.domains },
+                    });
                     return { ok: true, ...report };
                 }
                 catch (e) {
                     return { ok: false, error: message(e) };
                 }
             },
+            // 注入设置（读 / 写）：压制型预设下是否仍然注入 + 各域开关。界面在「兼容」页。
+            '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)
@@ -3548,7 +3877,7 @@ export default {
                         }
                     }
                     else if (kind === 'memories') {
-                        // 记忆有 flat（`<场景>/<name>.md`）与 bundle（`<场景>/<name>/SKILL.md`）两种形态，
+                        // 记忆有 flat（`<场景>/<name>.md`）与 bundle（`<场景>/<name>/<name>.md`）两种形态，
                         // 且场景名本身可含 '/' —— 按 id 拼路径会把 bundle 读成 `<场景>/<name>.md`，读不到
                         // 就静默丢项（详见 planMemoryExport）。所以走索引拿那条规则自己的真实路径。
                         const r = await rulesService.ops['rules-list']({});
@@ -3753,6 +4082,340 @@ export default {
             const r = await rulesService.ops['rules-list']({});
             return ((r && r.scenes) || []).filter((s) => s.locked === true).map((s) => String(s.name));
         }
+        /** 当前启用（= 已进入）的那个场景名；没有则 null。 */
+        async function activeSceneName() {
+            try {
+                const r = await rulesService.ops['rules-list']({});
+                return r && r.ok && r.activeScene ? String(r.activeScene) : null;
+            }
+            catch {
+                return null;
+            }
+        }
+        /** 「当前场景已锁定」的拒绝文案（模型工具用；无活动场景 / 未锁定 → null）。 */
+        async function lockedSceneGuard() {
+            const scene = await activeSceneName();
+            if (!scene)
+                return null;
+            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;
+        }
+        /**
+         * 某台服务器当前**启用**的工具名（把档案里的 `'*'` 具化成具体名单时用）。
+         *
+         * 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 syncSceneArchiveOnSwitch(opNames) {
+            for (const opName of opNames) {
+                const original = handlers[opName];
+                if (typeof original !== 'function')
+                    continue;
+                handlers[opName] = async (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;
+                };
+            }
+        }
         function guardLockedOps(opNames, what) {
             for (const opName of opNames) {
                 const original = handlers[opName];
@@ -3769,9 +4432,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',
@@ -3780,6 +4443,13 @@ export default {
             // 提示词：建改删 / 应用（切换生效基线）/ 导入 / 回收站。
             'agentsmd-create', 'agentsmd-update', 'agentsmd-remove', 'agentsmd-apply', 'agentsmd-import', 'agentsmd-trash-restore', 'agentsmd-trash-delete',
         ], '修改');
+        // 场景内「开关」类操作（用户裁定 2026-09-17）：未锁定时**可用**，改动同步进当前场景档案。
+        // 与「锁定」正交：锁定冻结全部写操作，这里只是把页面开关的意图也写进档案。
+        syncSceneArchiveOnSwitch([
+            'mcpm-set-enabled', 'mcpm-set-all', 'mcpm-tool-enabled',
+            '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) || '', '改档案'],
@@ -3796,10 +4466,13 @@ export default {
                 return original(args);
             };
         }
-        // 各页列表响应带上 anyLocked：界面据此禁用写控件（读 op，附加字段不影响既有消费方）。
+        // 各页列表响应带上 anyLocked + activeScene：界面据此禁用写控件、并说明
+        // 「当前处于场景 X，开关请到档案里改」（读 op，附加字段不影响既有消费方）。
         async function annotateLocked(res) {
-            if (res && res.ok !== false)
+            if (res && res.ok !== false) {
                 res.anyLocked = (await lockedSceneNames()).length > 0;
+                res.activeScene = await activeSceneName();
+            }
             return res;
         }
         for (const opName of ['mcpm-list', 'mcpm-reveal', 'skill-state', 'subagent-list', 'agentsmd-list']) {
@@ -3811,22 +4484,49 @@ export default {
         // ---------- agent-facing tools (standard ctx.tools.register + defineTool) ----------
         const text = (value) => [{ type: 'text', text: value }];
         tools.register(defineTool({
-            name: 'skill_mcp_manager_list',
-            description: 'List all configured MCP servers (level, enabled state, live loader status, registered tool count).',
-            parameters: {},
+            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.',
+            parameters: {
+                all: { type: 'boolean', description: 'Include disabled servers (default false).' },
+            },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
-            async execute() {
-                const r = await mcpmList();
+            async execute(args, exec) {
+                const showAll = Boolean(args && args.all === true);
+                // 必须走 mcpmListView()（= mcpmRowsWithNotes(false)）：备注在这里合入，且未打码的
+                // url/headers/env 已被打码。备注是本插件 MCP 这一项的真正价值（用户写给未来模型的
+                // 决策提示，如「A 挂了改用 B」），而它只走注入通道 —— 压制型预设下不注入时，
+                // 这里就是唯一的读取路径。
+                const r = await mcpmListView();
                 if (!r.ok)
                     throw new Error(r.error);
-                const summary = (r.rows || []).map((x) => (x.id + ' | ' + x.serverName + ' | ' + x.level + ' | ' + (x.disabled ? 'disabled' : 'enabled') +
-                    (x.live ? ' | loader:' + (x.live.enabled ? 'on' : 'off') + (x.live.phase ? ':' + x.live.phase : '') : '') +
-                    (typeof x.toolCount === 'number' ? ' | tools:' + x.toolCount : '')));
-                return 'MCP servers:\n' + (summary.join('\n') || '(none)');
+                const all = r.rows || [];
+                // 默认只列「已启用」的（用户裁定 2026-09-16，与技能 / 记忆列表同口径）：停用的服务器
+                // 模型调不到，列出来只是噪音。表头给出全量口径，所以不会变成盲区。
+                const shown = showAll ? all : all.filter((x) => !x.disabled);
+                const summary = shown.map((x) => {
+                    const note = normalizeMcpNote(x.notes, DEFAULT_MCP_NOTE_MAX_LENGTH);
+                    // 工具数 = 可用数（停用表扣减后）：段里给模型的是同一个口径，模型据此与
+                    // 自己 schema 里的 `mcp__*` 工具对得上；被场景收窄 / 手动关掉的工具不算。
+                    const usableTools = typeof x.enabledToolCount === 'number' ? x.enabledToolCount : x.toolCount;
+                    return x.id + ' | ' + x.serverName + ' | ' + x.level + ' | ' + (x.disabled ? 'disabled' : 'enabled') +
+                        (x.live ? ' | loader:' + (x.live.enabled ? 'on' : 'off') + (x.live.phase ? ':' + x.live.phase : '') : '') +
+                        (typeof usableTools === 'number' ? ' | tools:' + usableTools : '') +
+                        (note ? ' | user-hint:' + note : '');
+                });
+                const header = 'MCP servers: ' + (showAll
+                    ? all.length + ' configured'
+                    : shown.length + ' enabled of ' + all.length + ' configured' +
+                        (shown.length === all.length ? '' : ' (pass all=true for every configured server)')) + '\n';
+                // 注入边界：压制型预设（persona complete / 关闭运行时上下文，如极简）下本插件
+                // 默认不注入 —— 模型只有 mcp__* 的工具名与参数，没有服务级信息。不说明的话，
+                // 模型会把「能调用这些工具」当成「已经知道有哪些 server、用户给它们写了什么备注」。
+                // 提示本身不点名任何工具，所以挂在哪个发现型工具上都不会出现循环指引。
+                const notice = await reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx, injectNoticeOptions());
+                return header + (summary.join('\n') || '(none)') + notice;
             },
         }));
         tools.register(defineTool({
-            name: 'skill_mcp_manager_set_enabled',
+            name: 'mcp_manager_set_enabled',
             description: 'Enable or disable one configured MCP server (writes the patch file; takes effect via HMR).',
             parameters: {
                 id: { type: 'string', required: true, description: 'Entry id of the MCP server, e.g. mcp-stepfun-web-search.' },
@@ -3835,14 +4535,20 @@ 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 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({
-            name: 'skill_mcp_manager_restart',
+            name: 'mcp_manager_restart',
             description: 'Restart one configured MCP server (disable + re-enable; reconnect and re-sync tools).',
             parameters: {
                 id: { type: 'string', required: true, description: 'Entry id of the MCP server, e.g. mcp-stepfun-web-search.' },
@@ -3857,7 +4563,7 @@ export default {
             },
         }));
         tools.register(defineTool({
-            name: 'skill_mcp_manager_add',
+            name: 'mcp_manager_add',
             description: 'Add a new MCP server (streamable-http or stdio) at project or global level.',
             parameters: {
                 serverName: { type: 'string', required: true, description: 'Unique server name (1-32 chars, [A-Za-z0-9_-]).' },
@@ -3881,26 +4587,69 @@ 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 across all sources (dsh/agents/codex/claude user roots and project roots) with their enabled state.',
-            parameters: {},
+            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.',
+            parameters: {
+                all: { type: 'boolean', description: 'Include disabled and shadowed entries (default false).' },
+            },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
-            async execute() {
+            async execute(args, exec) {
+                const showAll = Boolean(args && args.all === true);
                 const r = await skillsService.ops['skill-state']({});
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || 'skill-state failed');
                 const data = r.data || {};
-                const lines = [];
+                // 同名（canonical = declaredName || name）跨根重复时只有**一份**生效，排序规则是
+                // 「同名首选 > 来源优先级 rank」，**与启用状态无关**（core 的 groupLoadableSkillsByName）。
+                // 于是「启用被覆盖的那份」是静默无效的：工具会回 OK，技能却依然不可用 —— 用户实测
+                // 踩到的正是这个坑（同一技能在 dsh/agents/claude/custom 各有一份，启错根等于没启）。
+                // 这里把生效/被覆盖如实标出来，让模型（和人）不必猜。
+                //
+                // 默认只列启用的（2026-09-16 用户裁定）：本机 36 条里只有 1 条启用，全列一次约 4.3k
+                // 字符且永久留在 transcript。表头始终给出全量口径（多少条 / 多少同名组），所以
+                // 「还有没列出来的」不会变成盲区 —— 要看就传 all=true。
+                const rows = [];
+                const counts = new Map();
                 for (const root of data.roots || []) {
                     for (const skill of root.skills || []) {
-                        lines.push((skill.name || skill.declaredName || '') + ' | ' + (root.key || '') + ' | ' + (skill.enabled ? 'enabled' : 'disabled'));
+                        const key = String(skill.declaredName || skill.name || '');
+                        counts.set(key, (counts.get(key) || 0) + 1);
+                        // `enabled` 只写在「胜出者」上（core 的 markWinners）；影子副本与不可加载的技能
+                        // 没有这个字段。原先直接读 skill.enabled，这些技能一律被报成 disabled ——
+                        // 这里改用与界面同口径的兜底推导（client 的 isSkillEnabled）。
+                        const enabled = skill.enabled !== undefined
+                            ? skill.enabled === true
+                            : (skill.invocationPolicyValid && skill.modelInvocable && skill.userInvocable && skill.managerEnabled !== false);
+                        const marks = [];
+                        if (skill.shadowedBy && skill.shadowedBy.root)
+                            marks.push('shadowed by ' + skill.shadowedBy.root);
+                        if (skill.preferred === true)
+                            marks.push('preferred');
+                        rows.push({
+                            root: String(root.key || ''),
+                            enabled,
+                            text: (skill.name || skill.declaredName || '') + ' | ' + (root.key || '') + ' | ' + (enabled ? 'enabled' : 'disabled') +
+                                (marks.length ? ' | ' + marks.join(' ') : '') +
+                                (skill.path ? ' | ' + skill.path : ''),
+                        });
                     }
                 }
-                return 'Skills:\n' + (lines.join('\n') || '(none)');
+                const dupGroups = [...counts.values()].filter((n) => n > 1).length;
+                const shown = showAll ? rows : rows.filter((row) => row.enabled);
+                const header = 'Skills: ' + (showAll
+                    ? rows.length + ' entries'
+                    : shown.length + ' enabled of ' + rows.length + ' entries') +
+                    (dupGroups ? ' · ' + dupGroups + ' duplicated names' : '') +
+                    (showAll || shown.length === rows.length ? '' : ' (pass all=true to include disabled and shadowed entries)') + '\n';
+                // 注入边界：预设没挂 dsh-tool-skill（如极简）时官方技能目录不在，本插件的
+                // 「技能目录」注入域会在开关打开时兜底（见上面的注入通道）；两者都没有时模型看到的
+                // 只是这份名单 —— 说清边界，别让它以为上下文里已经有技能正文（正文用路径读）。
+                const notice = await reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx, injectNoticeOptions());
+                return header + (shown.map((row) => row.text).join('\n') || '(none)') + notice;
             },
         }));
         tools.register(defineTool({
             name: 'skill_manager_set_enabled',
-            description: 'Enable or disable one DSH skill (manager policy only; skill source files are never modified).',
+            description: 'Enable or disable one DSH skill (manager policy only; source files are never modified). Enabling a shadowed copy has no effect.',
             parameters: {
                 name: { type: 'string', required: true, description: 'Skill name (kebab-case).' },
                 enabled: { type: 'boolean', required: true, description: 'true to enable, false to disable.' },
@@ -3908,11 +4657,40 @@ 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 root = String(args.root || 'dsh');
                 const op = args.enabled ? 'skill-enable' : 'skill-disable';
-                const r = await skillsService.ops[op]({ name: args.name, root: args.root || 'dsh' });
+                const r = await skillsService.ops[op]({ name: args.name, root });
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || 'skill toggle failed');
-                return 'OK: ' + args.name + ' now ' + (args.enabled ? 'enabled' : 'disabled');
+                // 场景未锁定时同步进当前场景档案（与 handlers 层同一套同步）。
+                const syncErr = await syncSwitchToScene(op, { name: args.name, root, enabled: args.enabled === true });
+                // 静默无效是这个工具最容易骗人的地方：同名胜负只由「首选 > 来源优先级」决定，
+                // 与启用状态无关。对影子副本操作会返回 OK，但技能依然不可用。如实说一句。
+                let shadowedBy = '';
+                try {
+                    const state = await skillsService.ops['skill-state']({});
+                    for (const rt of (state && state.data && state.data.roots) || []) {
+                        for (const skill of rt.skills || []) {
+                            if (String(skill.declaredName || skill.name || '') !== String(args.name))
+                                continue;
+                            if (String(rt.key || '') !== root)
+                                continue;
+                            if (skill.shadowedBy && skill.shadowedBy.root)
+                                shadowedBy = String(skill.shadowedBy.root);
+                        }
+                    }
+                }
+                catch {
+                    shadowedBy = '';
+                }
+                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'
+                    : '';
+                const sceneWarn = syncErr ? '\nWARN: 当前场景档案未同步（' + syncErr + '）' : '';
+                return 'OK: ' + args.name + ' now ' + (args.enabled ? 'enabled' : 'disabled') + warn + sceneWarn;
             },
         }));
         tools.register(defineTool({
@@ -3920,7 +4698,7 @@ export default {
             // 落点必须和 UI「创建技能」一致：两者都走 core 的默认落点（hub 的
             // tool-management/skills/，hub 缺失时退回 DSH_HOME/skills）。以前这里硬编码
             // root:'dsh'，于是同一个「新建技能」动作，人点界面和模型调用会落到两个不同的根。
-            description: 'Create a new local DSH skill under the tool-management skills root (DSH_HOME/tool-management/skills). Use only when the user explicitly asks to create or save a reusable skill.',
+            description: 'Create a new DSH skill under DSH_HOME/tool-management/skills. Use only when the user explicitly asks to create or save a reusable skill.',
             parameters: {
                 name: { type: 'string', required: true, description: 'Skill name; normalized to kebab-case.' },
                 description: { type: 'string', required: true, description: 'A concise routing description for when to use the skill.' },
@@ -3937,63 +4715,108 @@ export default {
         }));
         // AGENTS.md 预设库：模型可查/切，不能造/删（避免模型乱删用户预设）。
         tools.register(defineTool({
-            name: 'agentsmd_list',
-            description: 'List AGENTS.md presets in the plugin preset library (id, active state).',
-            parameters: {},
+            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.',
+            parameters: {
+                all: { type: 'boolean', description: 'Include inactive presets (default false).' },
+            },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
-            async execute(_args, exec) {
+            async execute(args, exec) {
+                const showAll = Boolean(args && args.all === true);
                 const r = await agentsMdService.list();
                 if (!r.ok)
                     throw new Error(r.error);
-                const summary = r.presets.map((p) => p.id + (p.active ? ' [active]' : ''));
-                // 同上：AGENTS.md 由 dsh-agent-instructions 行承载，预设没挂这一行（或 persona
-                // 是 complete）时文件内容不会进提示词。
-                const notice = await reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx);
-                return 'AGENTS.md presets:\n' + (summary.join('\n') || '(none)') + '\n(DSH re-reads ~/.dsh/AGENTS.md every turn, so applying takes effect on the next turn.)' + notice;
+                const all = r.presets || [];
+                // 默认只列「当前这份 ~/.dsh/AGENTS.md 是从哪个预设来的」（用户裁定 2026-09-16）。
+                // 判定分两级：内容逐字节相同 = 生效；否则看服务层记下的「最近一次应用」——
+                // 用户手改过全局文件时，第二级仍能给出答案，不必退化成全列（那会白烧上下文）。
+                const active = all.filter((p) => p.active === true);
+                const fallback = active.length ? active : all.filter((p) => p.lastApplied === true);
+                const shown = showAll ? all : fallback;
+                // 路径这一列是「名单 → 全文」的闭环：预设正文既不进提示词、也没有读取工具，
+                // 给出文件路径让模型用宿主的文件工具读，比再造一个 read 工具省一条常驻 schema。
+                const summary = shown.map((p) => {
+                    const mark = p.active ? ' [active]'
+                        : p.lastApplied ? ' [last applied — ~/.dsh/AGENTS.md has changed since]'
+                            : '';
+                    return p.id + mark + ' | ' + join(agentsMdPresetsDir, p.id, 'AGENTS.md');
+                });
+                const header = 'AGENTS.md presets: ' + (showAll
+                    ? all.length + ' in the library'
+                    : fallback.length
+                        ? fallback.length + (active.length ? ' active' : ' last applied') + ' of ' + all.length +
+                            (fallback.length === all.length ? '' : ' (pass all=true for the whole library)')
+                        : '0 active of ' + all.length + ' (pass all=true for the whole library)') + '\n';
+                // 同上：AGENTS.md 由官方 dsh-agent-instructions 行承载（极简没挂这一行），
+                // 这一行不在时文件内容不会进上下文。
+                const notice = await reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx, injectNoticeOptions());
+                return header + (summary.join('\n') || '(none)') + '\n(DSH re-reads ~/.dsh/AGENTS.md every turn, so applying takes effect on the next turn.)' + notice;
             },
         }));
         tools.register(defineTool({
-            name: 'agentsmd_apply',
-            description: 'Apply one AGENTS.md preset by writing it to ~/.dsh/AGENTS.md. DSH re-reads that file every turn, so it takes effect on the next turn.',
+            name: 'prompt_manager_apply',
+            description: 'Apply one AGENTS.md preset by writing it to ~/.dsh/AGENTS.md; effective on the next turn. Refused while a scene drives the baseline, unless it is that scene\'s bound preset (change the scene binding instead).',
             parameters: {
                 id: { type: 'string', required: true, description: 'Preset id (lowercase letters, digits, hyphens).' },
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
             async execute(args) {
-                const r = await agentsMdService.apply(args.id);
+                const r = await applyPresetGuarded(args.id);
                 if (!r.ok)
                     throw new Error(r.error);
                 return 'OK: preset ' + args.id + ' applied to ~/.dsh/AGENTS.md (next session; current session unchanged' + (r.backedUp ? '; previous backed up to __last-applied__' : '') + ')';
             },
         }));
         // ---------- rules model tools（v0.4）----------
-        // 活动场景的记忆正文会自动进入系统提示词（无需调用工具读取）；这里的工具用于
-        // 查询/编辑规则本身。rule_manager_write 受 tools/pre-execute 审批门禁（D2）。
+        // 活动场景的记忆正文会自动注入上下文（无需调用工具读取）；这里的工具用于
+        // 查询/编辑规则本身。memory_manager_write 受 tools/pre-execute 审批门禁（D2）。
         // 路径锚点：$DSH_HOME/tool-management/memories/<场景>/…（场景 `global` = 界面「全局」）。
         tools.register(defineTool({
-            name: 'rule_manager_list',
-            description: 'List memories under ~/.dsh/tool-management/memories (id, scene, enabled, description).',
+            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.',
             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).' },
             },
             output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
             async execute(args, exec) {
+                const showAll = Boolean(args && args.all === true);
                 const r = await rulesService.ops['rules-list'](args);
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || '读取规则失败');
-                const lines = (r.rules || []).map((x) => ('- ' + x.id + ' [' + (x.group || '未归属场景') + '] ' + (x.enabled ? '已启用' : '已停用') +
+                // 「会注入」的判定与记忆段同源（renderSceneMemory）：global 场景恒常注入，其余场景要
+                // 在 index.active 里，再叠加单条 enabled 与同名 bundle 的 shadowed。默认只列这些，
+                // 全列一次会把没启用的条目也算进上下文（用户裁定 2026-09-16，与技能列表同口径）。
+                const sceneOn = (group) => group === 'global' ||
+                    (group !== '' && (r.activeMode === 'all' || String(r.activeScene || '') === group));
+                const stateOf = (x) => {
+                    if (x.shadowed === true)
+                        return { injects: false, label: '被同名覆盖' };
+                    if (x.enabled === false)
+                        return { injects: false, label: '已停用' };
+                    if (!sceneOn(String(x.group || '')))
+                        return { injects: false, label: '场景未启用' };
+                    return { injects: true, label: '已启用' };
+                };
+                const rows = (r.rules || []).map((x) => ({ x, ...stateOf(x) }));
+                const shown = showAll ? rows : rows.filter((row) => row.injects);
+                const lines = shown.map(({ x, label }) => ('- ' + x.id + ' [' + (x.group || '未归属场景') + '] ' + label +
                     (x.description ? ' — ' + x.description : '')));
                 const scenes = (r.scenes || []).map((s) => (s.label || s.name) + (s.active ? '(启用)' : '(未启用)')).join('、');
-                // 注入边界：预设可能压制提示词段（complete persona，或未挂 agent-instructions），
+                const header = '记忆：' + (showAll
+                    ? rows.length + ' 条'
+                    : shown.length + ' 条会注入 / 共 ' + rows.length + ' 条' +
+                        (shown.length === rows.length ? '' : '（传 all=true 看全部）')) + '\n';
+                // 注入边界：压制型预设（persona complete / 关闭运行时上下文）下本插件默认不注入，
                 // 此时列出的记忆**不在**模型上下文里。必须说出来，否则模型会假设自己已经看到正文。
-                const notice = await reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx);
-                return '记忆（' + (r.rules || []).length + '）：\n' + (lines.join('\n') || '(无记忆)') +
+                const notice = await reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx, injectNoticeOptions());
+                return header + (lines.join('\n') || '(无记忆)') +
                     '\n场景：' + (scenes || '(无)') + (r.activeMode === 'all' ? '（默认全部启用）' : '（已收窄）') + notice;
             },
         }));
         tools.register(defineTool({
-            name: 'rule_manager_read',
-            description: 'Read the full body of one memory under ~/.dsh/tool-management/memories.',
+            name: 'memory_manager_read',
+            description: 'Read the full body of one memory under ~/.dsh/tool-management/memories. Call it only for memories that are not already in your context (disabled, unassigned to a scene, or dropped by the injection budget).',
             parameters: {
                 id: { type: 'string', required: true, description: 'Memory id like <scene>/<name>.' },
             },
@@ -4006,11 +4829,11 @@ export default {
             },
         }));
         tools.register(defineTool({
-            name: 'rule_manager_write',
-            description: 'Create a new memory as ~/.dsh/tool-management/memories/<scene>/<name>.md. The scene must already exist (use global for the always-on scene). It becomes active automatically once its scene is enabled. Requires user confirmation (configurable).',
+            name: 'memory_manager_write',
+            description: 'Create a new memory as ~/.dsh/tool-management/memories/<scene>/<name>.md. The scene must already exist (use global for the always-on scene).',
             parameters: {
-                group: { type: 'string', required: true, description: 'Scene name under ~/.dsh/tool-management/memories; `global` = the always-on scene (any Unicode except path separators and < > : " | ? *).' },
-                name: { type: 'string', required: true, description: 'Memory name = the .md file name without the extension; any Unicode is fine (Chinese included), <=64 chars, no path separators or < > : " | ? *, must not start with a dot.' },
+                group: { type: 'string', required: true, description: 'Scene name (no path separators or < > : " | ? *); `global` = the always-on scene.' },
+                name: { type: 'string', required: true, description: 'Memory name = .md file name without extension; <=64 chars, no path separators or < > : " | ? *, must not start with a dot.' },
                 description: { type: 'string', required: true, description: 'One-sentence description (<=500 chars).' },
                 body: { type: 'string', required: true, description: 'Markdown body (<=256 KiB).' },
             },
@@ -4022,15 +4845,21 @@ export default {
                 return 'OK: memory ' + r.rule.id + '（场景「' + (r.rule.group || '未归属') + '」启用后自动生效）';
             },
         }));
-        // ---------- 子智能体工具（subagent_list / subagent_run）----------
+        // ---------- 子智能体工具（subagent_manager_list / subagent_manager_run）----------
         // exec.agent / exec.signal 由工具运行时提供（parent 与取消信号的官方通道）。
         try {
             // 与其余 12 个工具同一条注册通道：defineTool 负责编译 parameters（object root + required），
             // 裸 register 会把未编译的参数声明直接发给模型 API。
-            tools.register(defineTool(defineSubagentListTool({ list: () => subagentService.list(), sceneLists: subagentSceneLists })));
+            tools.register(defineTool(defineSubagentManagerListTool({
+                list: () => subagentService.list(),
+                sceneLists: subagentSceneLists,
+                // 与其余发现型工具同口径：压制型预设下不注入时，人设目录不在模型上下文里，
+                // 只有工具可用。挂上边界提示，模型才不会把「看不到人设」当成「没有人设」。
+                noticeFor: (exec) => reachNoticeForAgent(presetRoster(), exec && exec.agent && exec.agent.ctx, injectNoticeOptions()),
+            })));
             // 工具限制按**当前会话的 Agent 预设**下发：父会话跑在哪个预设，就用那个预设那一行的
             // 白/黑名单（`decideToolFilter`），名单里已消失的工具名会被丢掉并在结果里如实说明。
-            tools.register(defineTool(defineSubagentRunTool({ ...subagentService, sceneLists: subagentSceneLists, toolFilterFor: subagentToolFilterFor })));
+            tools.register(defineTool(defineSubagentManagerRunTool({ ...subagentService, sceneLists: subagentSceneLists, toolFilterFor: subagentToolFilterFor })));
         }
         catch (e) {
             console.error('[dsh-plugin-tool-management] subagent tool registration failed:', message(e));
@@ -4044,8 +4873,8 @@ export default {
             // 不能用 ctx.approval——inject 未声明该服务时 cordis 代理会抛 "cannot get property without inject"）。
             const CONFIRM_LABELS = {
                 skill_manager_create: '「新建技能」',
-                rule_manager_write: '「写入记忆」',
-                subagent_run: '「运行子代理」',
+                memory_manager_write: '「写入记忆」',
+                subagent_manager_run: '「运行子代理」',
             };
             const bypassedByFullAccess = (exec) => {
                 if (!isApprovalNever(ctx, exec))
@@ -4054,11 +4883,11 @@ export default {
                 pluginLog()('confirm-bypass', `完全权限（approval=never）：跳过${CONFIRM_LABELS[String(exec && exec.name)]}的确认，直接放行`).catch(() => { });
                 return true;
             };
-            // subagent_run 的目标人设是否真实存在。确认门是「问用户要不要做」，如果这个请求
+            // subagent_manager_run 的目标人设是否真实存在。确认门是「问用户要不要做」，如果这个请求
             // 本来就做不成（人设不存在），弹卡 / 写 bypass 日志只会产生一次无效审批：
             // 用户批准之后模型收到的是「人设不可用」。所以先校验，再决定要不要问。
             // 校验本身不可用时返回 true（保持原行为，绝不因为探测失败而少问一次）。
-            const subagentRunTargetExists = async (exec) => {
+            const subagentManagerRunTargetExists = async (exec) => {
                 try {
                     const name = String((exec && exec.arguments && exec.arguments.agent) || '').trim();
                     if (!name)
@@ -4073,14 +4902,14 @@ export default {
             ctx.on('tools/pre-execute', async (exec, next) => {
                 if (!exec || !CONFIRM_LABELS[String(exec.name)])
                     return next();
-                if (exec.name === 'subagent_run' && !(await subagentRunTargetExists(exec)))
+                if (exec.name === 'subagent_manager_run' && !(await subagentManagerRunTargetExists(exec)))
                     return next();
                 if (bypassedByFullAccess(exec))
                     return next();
                 if (exec.name === 'skill_manager_create') {
                     return Promise.resolve({ kind: 'ask', reason: 'Create a new skill under ~/.dsh/tool-management/skills' });
                 }
-                if (exec.name === 'rule_manager_write') {
+                if (exec.name === 'memory_manager_write') {
                     // D2：模型写规则默认需确认；设置关闭后直接放行。ask 无应答者时降级为拒绝（fail-closed），
                     // 不在此处做任何兜底放行。
                     return readPluginSettings()
@@ -4089,7 +4918,7 @@ export default {
                         : next()))
                         .catch(() => ({ kind: 'ask', reason: 'Write a memory under ~/.dsh/tool-management/memories' }));
                 }
-                // subagent_run：子代理运行花真 token：默认确认（requireConfirmForModelSubagentRun !== false），可关。
+                // subagent_manager_run：子代理运行花真 token：默认确认（requireConfirmForModelSubagentRun !== false），可关。
                 return readPluginSettings()
                     .then((s) => (s.requireConfirmForModelSubagentRun !== false
                     ? { kind: 'ask', reason: 'Run a subagent (consumes tokens)' }
@@ -4119,8 +4948,8 @@ export default {
             try {
                 // MCP servers (de)register their tools as instances come and go; the
                 // visible-set restriction must track that — and so must the MCP state
-                // section: 工具加载完成后若不重算，段会一直停留在「空/旧集合」的缓存值上
-                //（用户切 MCP 后立即看系统提示词就是空段 —— 2026-09-16 实测）。
+                // section: 工具加载完成后若不重算，注入文本会一直停留在「空/旧集合」的缓存值上
+                //（用户切 MCP 后立即看上下文注入就是空段 —— 2026-09-16 实测）。
                 ctx.effect(() => {
                     const stop = ctx.on('tools/change', () => {
                         scheduleToolRestrictions();