dsh-plugin-tool-management 0.6.0 → 0.8.0

package/lib/mcp/override-blocks.js

@@ -0,0 +1,195 @@
+// 补丁文件（cordis.patch.yml）里的「启停覆盖块」识别与收敛计划。
+//
+// 同一个 loader id 的启停状态有两种写法：insert 行自带的 `disabled:`，以及顶层
+// `- id: xxx` + `disabled:` 的独立覆盖块。补丁按顺序应用、**last-wins**
+// （见 @deepseek-ai/dsh-app-boot 的 applyEntryPatches：`target[key] = value`），
+// 所以覆盖块可以无限追加而每次都不报错 —— 代价是文件越用越长，生效值只能靠
+// "最后一条声明了 disabled 的块"推断。
+//
+// 这里只回答一个问题：要收敛的话，删哪些行区间**且生效值保证不变**。
+//
+// ⚠ 这个模块第一版出过一次事故：调用方把 `parseRows()` 合并覆盖块之后的**生效值**
+// 当基准传进来，而生效值恒等于 decider 的值 —— 于是"decider 的值 == 基准"永远成立，
+// 每个 decider 都被当成 no-op 删掉，6 台 MCP 全部被启用。为了从结构上杜绝这种传错，
+// 现在的接口是：`planOverrideCompaction(content, otherFileContents)` —— 基准只能由
+// 本模块自己从 **insert 行**读（`insertBaseRows`），调用方只能再补"另一份补丁文件的
+// 内容"，不能传任何现成的状态值进来。
+/**
+ * 顶层块扫描：每个 `- ` 开头的行都是新块的开始，块体延伸到下一个 `- ` 行之前。
+ *
+ * `end` 剔除块尾的注释/空行 —— 那些行属于"块与块之间"，其中就包括下一个块自己的
+ * `# dsh-…:disable:<id>` 标记注释。带上它们的话，删一个块会把下一个块的注释一起带走。
+ */
+export function scanBlockRanges(lines) {
+    const out = [];
+    let current = null;
+    const flush = () => {
+        if (!current)
+            return;
+        let end = current.start + current.lines.length;
+        while (end > current.start + 1 && (lines[end - 1].trim() === '' || /^\s*#/.test(lines[end - 1])))
+            end--;
+        out.push({ start: current.start, end, text: current.lines.slice(0, end - current.start).join('\n') });
+        current = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        if (/^- /.test(lines[i])) {
+            flush();
+            current = { start: i, lines: [lines[i]] };
+        }
+        else if (current)
+            current.lines.push(lines[i]);
+    }
+    flush();
+    return out;
+}
+/**
+ * 读一个覆盖块三件事：id、disabled、是不是"纯块"。
+ *
+ * 只看**顶层/一层缩进**的锚定写法（`- id:`、`name:`、`disabled:`）：生成器写出来的
+ * 就是这几行，而 config 里的同名键缩进更深 —— 万一手工把 `disabled` 藏进 config，
+ * 这里会判成"非纯块"（保留不删），保守方向是对的。
+ *
+ * 不筛 `name:` —— 补丁是按 **loader id** 生效的，别的模块名写同一个 id 时改的仍是
+ * 那个条目；真正决定"能不能删"的是 pure 与 decider 两条规则，不是名字。
+ */
+export function readToggleEntry(lines) {
+    let id;
+    let disabled;
+    let pure = true;
+    for (const raw of lines) {
+        const line = raw.replace(/\s+$/, '');
+        if (!line.trim() || line.trimStart().startsWith('#'))
+            continue;
+        const head = line.match(/^- id:\s*(\S+)\s*$/);
+        if (head) {
+            id = head[1];
+            continue;
+        }
+        if (/^\s{2,}name:\s*\S+\s*$/.test(line))
+            continue;
+        const flag = line.match(/^\s{2,}disabled:\s*(true|false)\s*$/);
+        if (flag) {
+            disabled = flag[1] === 'true';
+            continue;
+        }
+        pure = false;
+    }
+    return { id, disabled, pure };
+}
+/** 覆盖块自己的标记注释（紧邻上方的 `# …:disable|enable:<id>`），删块时一起删。 */
+export function markerLinesAbove(lines, start) {
+    let i = start;
+    while (i > 0 && /^# (?:dsh-plugin-tool-management|dsh-mcp-manager):(?:disable|enable):/.test(lines[i - 1]))
+        i--;
+    return i;
+}
+/** 文件里所有顶层启停覆盖块（按出现顺序）。 */
+export function scanOverrideBlocks(content) {
+    const lines = content.split(/\r?\n/);
+    const out = [];
+    for (const block of scanBlockRanges(lines)) {
+        if (/^- insert:/.test(lines[block.start]))
+            continue;
+        const entry = readToggleEntry(lines.slice(block.start, block.end));
+        if (!entry.id)
+            continue;
+        out.push({ ...block, id: entry.id, disabled: entry.disabled, pure: entry.pure });
+    }
+    return out;
+}
+/**
+ * **insert 行自带的** 启停基准（`- insert:` 里每个子条目的 `disabled`，缺失 = 启用）。
+ *
+ * 这是收敛判定的唯一合法基准来源：绝不能用 `parseRows()` 那种"合并覆盖块之后的生效值"，
+ * 因为生效值就等于最后一条覆盖块的值，"覆盖块的值 == 基准"会恒成立，decider 会被全删。
+ */
+export function insertBaseRows(content) {
+    const lines = content.split(/\r?\n/);
+    const out = [];
+    for (const block of scanBlockRanges(lines)) {
+        if (!/^- insert:/.test(lines[block.start]))
+            continue;
+        let id;
+        let disabled;
+        const flush = () => { if (id)
+            out.push({ id, disabled }); };
+        for (const line of block.text.split('\n')) {
+            const child = line.match(/^ {4}- id:\s*(\S+)\s*$/);
+            if (child) {
+                flush();
+                id = child[1];
+                disabled = undefined;
+                continue;
+            }
+            if (!id)
+                continue;
+            const flag = line.match(/^\s+disabled:\s*(true|false)\s*$/);
+            if (flag)
+                disabled = flag[1] === 'true';
+        }
+        flush();
+    }
+    return out;
+}
+/**
+ * 收敛计划：算出"删掉也不改变生效状态"的覆盖块行区间。
+ *
+ * 为什么除最后一条外都能删：补丁按顺序应用，同一 id 的多个覆盖块 last-wins，真正
+ * 决定生效值的只有**最后一个声明了 disabled 的块**（decider）。于是：
+ *   - decider 之前的纯启停块 → 删（被 decider 盖住）；
+ *   - decider 本身 → 仅当它与 insert 行的 disabled 相同（纯 no-op）**且基准已知**时删；
+ *   - decider 之后的块 → 留着（它们不声明 disabled，可能改的是别的东西）；
+ *   - 带 config 的非纯块 → 一律留着（可能承载手工覆盖内容）。
+ *
+ * "基准未知"为什么要单列：覆盖块可以打在**补丁文件之外**定义的条目上（profile 的
+ * cordis.yml 原生行，或另一份补丁文件的 insert 行）。此时"删掉这条 disabled: false"
+ * 完全可能把它翻回原生状态的 disabled: true —— 所以基准未知时只删被 decider 盖住的
+ * 那些块，绝不删 decider 自己。
+ *
+ * @param content - 补丁文件全文。
+ * @param otherFileContents - 同一 id 的 insert 行**可能坐在里面**的其它补丁文件全文
+ *   （项目级与全局两份互查）。只用于补基准，绝不用来推断本文件要删什么。
+ * @returns `ranges` 为要删除的行区间；`ids` 为逐 id 统计。
+ */
+export function planOverrideCompaction(content, otherFileContents = []) {
+    const lines = content.split(/\r?\n/);
+    const byId = new Map();
+    for (const block of scanOverrideBlocks(content)) {
+        const list = byId.get(block.id);
+        if (list)
+            list.push(block);
+        else
+            byId.set(block.id, [block]);
+    }
+    const baseOf = new Map();
+    for (const row of insertBaseRows(content))
+        baseOf.set(row.id, row.disabled === true);
+    for (const other of otherFileContents) {
+        for (const row of insertBaseRows(other))
+            if (!baseOf.has(row.id))
+                baseOf.set(row.id, row.disabled === true);
+    }
+    const ranges = [];
+    const ids = {};
+    for (const [id, list] of byId) {
+        const baseKnown = baseOf.has(id);
+        const base = baseOf.get(id) === true;
+        let decider = -1;
+        for (let i = 0; i < list.length; i++)
+            if (list[i].disabled !== undefined)
+                decider = i;
+        const doomed = [];
+        if (decider >= 0) {
+            for (let i = 0; i < decider; i++)
+                if (list[i].pure)
+                    doomed.push(list[i]);
+            if (baseKnown && list[decider].pure && list[decider].disabled === base)
+                doomed.push(list[decider]);
+        }
+        ids[id] = { total: list.length, dropped: doomed.length };
+        for (const block of doomed)
+            ranges.push([markerLinesAbove(lines, block.start), block.end]);
+    }
+    return { ranges, ids };
+}

package/lib/mcp/state-section.js

@@ -0,0 +1,90 @@
+/** 段里最多列几台 server；超出部分只报数量。 */
+export const DEFAULT_MCP_MAX_ENTRIES = 50;
+/** 备注截断长度。备注是自由文本，界面侧另有 maxLength(500) 兜底，段侧再截一刀。 */
+export const DEFAULT_MCP_NOTE_MAX_LENGTH = 200;
+/**
+ * 备注的固定前缀。
+ *
+ * 备注是自由文本，注入后以**系统提示词的身份**生效。若用户写了指令式内容
+ * （如「忽略以上全部规则」），会被当作系统级指令执行。威胁模型上是**自伤**而非被攻击
+ * （内容由用户自己写、仅本机可写），但加固定前缀能降低被读成指令的概率。
+ */
+export const MCP_NOTE_PREFIX = '用户备注：';
+/** 备注压成单行（换行 → 空格）并截断。 */
+function normalizeNote(value, maxLength) {
+    const flat = String(value ?? '').replaceAll(/\s+/g, ' ').trim();
+    if (!flat)
+        return '';
+    return flat.length <= maxLength ? flat : `${flat.slice(0, maxLength - 3)}...`;
+}
+/**
+ * 渲染 MCP 状态段（纯函数，便于单独推理）。
+ *
+ * 返回 `''` 表示不注入 —— 没有可用 server 的用户零 token 成本。
+ */
+export function renderMcpStateSection(rows, opts = {}) {
+    const maxEntries = opts.maxEntries ?? DEFAULT_MCP_MAX_ENTRIES;
+    const noteMaxLength = opts.noteMaxLength ?? DEFAULT_MCP_NOTE_MAX_LENGTH;
+    // 「当前真正可用」= 已启用 且 有工具。任一不满足都不进段。
+    const usable = rows.filter((r) => !r.disabled && Number(r.toolCount) > 0);
+    if (!usable.length)
+        return '';
+    // 按展示名排序：即使补丁文件里的行序变化，段文本也保持逐字节稳定（前缀缓存契约）。
+    const sorted = [...usable].sort((a, b) => {
+        const x = String(a.serverName ?? '');
+        const y = String(b.serverName ?? '');
+        return x < y ? -1 : x > y ? 1 : 0;
+    });
+    const shown = sorted.slice(0, Math.max(0, maxEntries));
+    const lines = shown.map((r) => {
+        const count = Number(r.toolCount) || 0;
+        const head = '- **' + String(r.serverName ?? r.id) + '**（' + count + ' 个工具）';
+        const note = normalizeNote(r.notes, noteMaxLength);
+        return note ? head + ' — ' + MCP_NOTE_PREFIX + note : head;
+    });
+    const out = ['## MCP 服务器', '', ...lines];
+    const hidden = sorted.length - shown.length;
+    if (hidden > 0)
+        out.push('', `（另有 ${hidden} 台未列出。）`);
+    return out.join('\n');
+}
+/** 创建 SWR 的 MCP 状态目录。计算失败时保留上一次的值，不把段清空。 */
+export function createMcpStateCatalog(deps, opts = {}) {
+    const ttlMs = opts.ttlMs ?? 3000;
+    const now = opts.now ?? (() => Date.now());
+    let value = '';
+    let loadedAt = Number.NEGATIVE_INFINITY;
+    let inflight = null;
+    const recompute = async () => {
+        try {
+            const result = await deps.rows();
+            if (result && result.ok !== false) {
+                value = renderMcpStateSection(result.rows ?? [], opts);
+            }
+        }
+        catch { /* 保留上一次的值；首次失败则维持 '' */ }
+        loadedAt = now();
+    };
+    const revalidate = () => {
+        if (inflight)
+            return inflight;
+        inflight = recompute().finally(() => { inflight = null; });
+        return inflight;
+    };
+    return {
+        text: () => {
+            if (now() - loadedAt > ttlMs)
+                void revalidate();
+            return value;
+        },
+        refresh: () => {
+            loadedAt = Number.NEGATIVE_INFINITY;
+            return revalidate();
+        },
+        warm: () => revalidate(),
+    };
+}
+/** 供 `createPromptSectionRegistrar` 使用的段声明。 */
+export function mcpStateSectionOf(catalog, order) {
+    return { name: 'tool-management:mcp-state', order, text: () => catalog.text() };
+}

package/lib/prompt-sections.js

@@ -0,0 +1,148 @@
+// dsh-plugin-tool-management —— systemPrompt 段注册（通用骨架）。
+//
+// 本模块是「把插件状态投影为 system prompt 段（自动在场）」的**唯一实现**。
+// 场景记忆段（src/rules/service.ts）、子智能体人设段、MCP 状态段
+// （src/index.ts）都经它注册，避免每个域各抄一份 scope 遍历逻辑。
+//
+// 官方接口语义（@deepseek-ai/dsh-system-prompt）：
+//   - `section({ name, order, text })` 在**调用者的 scope** 注册；scoped 段遮蔽同名全局段。
+//   - `text` 可以是**每次装配时求值的 provider 函数** → 切换启用状态后**下一个请求即生效**，
+//     无需重开会话、无需重载插件。
+//   - `renderPrompt` 会**删除空段** → 无内容时返回 `''`，不产生空标题、零 token 成本。
+//
+// 为什么每个段都注册两处（全局 + per-agent）：
+//   全局注册覆盖所有 agent（含子 agent）；per-agent 注册保证即使插件 ctx 自带 scope
+//   （全局段对某些 agent 不可见）也能命中 —— 两者同名，scoped 遮蔽全局，不会重复注入。
+//
+// 缓存契约（§5.2）：段文本必须**会话级恒定**（只由持久化配置与文件内容决定），
+// 因此前缀逐字节稳定 → 前缀缓存可命中；**禁止**在段里放时间戳/计数/相对时间。
+// 异步数据源（人设目录、MCP 清单）走 stale-while-revalidate：`text()` 同步返回缓存值，
+// 由调用方在写操作后触发重算，绝不在 `text()` 里发起 IO。
+const GLOBAL_KEY = '@global';
+/** 复合 key 的分隔符：NUL 不会出现在 agent id 或段名里。 */
+const KEY_SEP = '\u0000';
+/** 取 scope 上的 systemPrompt 服务（Cordis 的 ctx.get 可能抛错，全部吞掉）。 */
+function systemPromptOf(scope) {
+    if (!scope)
+        return undefined;
+    try {
+        if (typeof scope.get === 'function')
+            return scope.get('systemPrompt');
+        return scope.systemPrompt;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 注册一组 systemPrompt 段：全局 scope + 每个活动 agent 的 scope。
+ *
+ * 任一 scope / 任一段注册失败都只降级为"该段不注入"，不影响其余段与其余 scope。
+ */
+export function createPromptSectionRegistrar(ctx, sections) {
+    const registrations = new Map();
+    const install = (scope, scopeKey) => {
+        if (!scope)
+            return;
+        const systemPrompt = systemPromptOf(scope);
+        if (!systemPrompt || typeof systemPrompt.section !== 'function')
+            return;
+        for (const spec of sections) {
+            const key = scopeKey + KEY_SEP + spec.name;
+            if (registrations.has(key))
+                continue;
+            try {
+                const dispose = systemPrompt.section({
+                    name: spec.name,
+                    order: spec.order,
+                    // 每次装配重读 → 切换启用状态后下一个请求即生效。
+                    // 包一层箭头函数：spec.text 自身若被替换（热更新）也能跟上。
+                    text: () => spec.text(),
+                });
+                registrations.set(key, { scope, dispose: typeof dispose === 'function' ? dispose : () => { } });
+            }
+            catch (e) {
+                // 同层重名注册会抛错：降级为"该段不注入"，不影响其余 scope 与其余段。
+                console.error(`[dsh-plugin-tool-management] ${spec.name} section registration failed:`, String((e && e.message) || e));
+            }
+        }
+    };
+    const uninstall = (scopeKey) => {
+        const prefix = scopeKey + KEY_SEP;
+        for (const key of [...registrations.keys()]) {
+            if (!key.startsWith(prefix))
+                continue;
+            const entry = registrations.get(key);
+            registrations.delete(key);
+            try {
+                entry?.dispose();
+            }
+            catch { /* ignore */ }
+        }
+    };
+    // ① 全局：插件 ctx 的 scope（覆盖所有 agent）
+    install(ctx, GLOBAL_KEY);
+    // ② per-agent：与既有 install/uninstall 生命周期一致（agent/created、agent/disposed）
+    const on = ctx && ctx.on;
+    let stopCreated;
+    let stopDisposed;
+    if (typeof on === 'function') {
+        stopCreated = on('agent/created', (payload) => {
+            const agent = payload && payload.agent;
+            if (agent && agent.id != null)
+                install(agent.ctx, String(agent.id));
+        });
+        stopDisposed = on('agent/disposed', (payload) => {
+            const agent = payload && payload.agent;
+            if (agent && agent.id != null)
+                uninstall(String(agent.id));
+        });
+    }
+    // 已存在的 agent（插件热加载场景）：补注册。
+    try {
+        const agents = typeof ctx.get === 'function' ? ctx.get('agents') : undefined;
+        if (agents && typeof agents.list === 'function') {
+            for (const agent of agents.list()) {
+                if (agent && agent.id != null)
+                    install(agent.ctx, String(agent.id));
+            }
+        }
+    }
+    catch { /* agents 服务不可用 → 仅靠事件 */ }
+    return {
+        invalidate: () => {
+            for (const entry of registrations.values()) {
+                try {
+                    entry.scope?.emit?.('system-prompt/change');
+                }
+                catch { /* 宿主无该事件 → 忽略 */ }
+            }
+        },
+        dispose: () => {
+            if (typeof stopCreated === 'function')
+                stopCreated();
+            if (typeof stopDisposed === 'function')
+                stopDisposed();
+            for (const key of [...registrations.keys()]) {
+                const entry = registrations.get(key);
+                registrations.delete(key);
+                try {
+                    entry?.dispose();
+                }
+                catch { /* ignore */ }
+            }
+        },
+    };
+}
+/**
+ * 官方 `SECTION_ORDERS` 里 2901–4999 是空档，本插件的段全部落在该区间。
+ * 数值本身无外部含义，只决定同一次装配里的相对顺序（小在前）。
+ */
+export const SECTION_ORDER = {
+    /** 场景记忆（rules 服务）。 */
+    sceneMemory: 3000,
+    /** 子智能体人设目录。 */
+    subagents: 3010,
+    /** MCP 服务器状态与用户备注。 */
+    mcpState: 3020,
+};

package/lib/rules/archive-engine.js

@@ -3,7 +3,7 @@
 //                     退出 = 恢复快照 → 落盘自由模式；切换 = 先退后进。
 // 失败语义（fail-closed）：任一步失败即反向恢复运行时并写回旧切片；回滚不全会如实写进错误文本。
 // v2：MCP 段两级（服务器勾选 + '*' / 工具明细），停用表存勾选集的补集，通配由 index.ts 的 guard/restrict 原生支持。
-import { computeMcpPlan, computeMemoriesPlan, computeSkillsPlan, normalizeArchive, snapshotRuntime, hasSection, } from './archive.js';
+import { computeMcpPlan, computeSkillsPlan, normalizeArchive, snapshotRuntime, hasSection, } from './archive.js';
 const msg = (e) => String((e && e.message) || e);
 export function createArchiveEngine(deps) {
     let chain = Promise.resolve();
@@ -20,9 +20,25 @@ export function createArchiveEngine(deps) {
      * 技能只写快照列出的键（这是既有批量通道的语义）：模式期间新增的技能保持现状。
      */
     async function restoreSnapshot(snapshot) {
+        // 顺序与进入时**相反**：先恢复服务器级 / 来源级，再恢复工具级 / 技能级 ——
+        // 来源还关着的时候写技能级策略会被吞掉（`skills/core.js` 的 sourceEnabled 判定）。
+        // 老 snapshot 没有这两栏 → `?? []`，按旧行为只恢复下层。
+        const servers = snapshot.mcpServers ?? [];
+        if (servers.length) {
+            await deps.applyMcpServerSwitches(servers.map((x) => ({ id: x.id, level: x.level, enabled: !x.disabled })));
+        }
+        const sources = snapshot.skillSources ?? [];
+        if (sources.length) {
+            await deps.applySkillSourceSwitches(sources.map((x) => ({ root: x.root, enabled: x.enabled })));
+        }
         const mcp = Object.fromEntries(Object.entries(snapshot.mcp).map(([k, v]) => [k, v.slice()]));
         await deps.applyMcpEntries(mcp);
         await deps.applySkills({ ...snapshot.skills });
+        // 子智能体开关：只停「进入时被这次启用过的」那些（老 snapshot 没有这栏 → []，按旧行为跳过）。
+        const personas = snapshot.subagents ?? [];
+        if (personas.length) {
+            await deps.applySubagentSwitches(personas.map((n) => ({ name: n, enabled: false })));
+        }
     }
     /**
      * 失败回滚：运行时还原 + 切片写回；每步失败都记下来，绝不谎报「已回滚」。
@@ -89,17 +105,11 @@ export function createArchiveEngine(deps) {
                 if (hadKeys && archive.subagents.length === 0)
                     delete archive.subagents;
             }
-            if (archive.memories) {
-                // 记忆段只影响投影（正文是否进 system prompt），不写任何运行时状态；
-                // 这里只把已不存在的记忆 id 剔掉并上报，避免档案里留下指向空气的勾选。
-                const known = await deps.knownMemoryIds();
-                const hadKeys = archive.memories.length > 0;
-                const { stale: memStale } = computeMemoriesPlan(archive.memories, known);
-                stale.push(...memStale);
-                archive.memories = archive.memories.filter((id) => known.has(id));
-                if (hadKeys && archive.memories.length === 0)
-                    delete archive.memories;
-            }
+            // 记忆段（P5 已废弃）：不再写入、不再校验。记忆的开关是 `rules[*].enabled` 单一真相源，
+            // 老档案里残留的 `memories` 字段被忽略（不迁移、不删除，回滚代码时仍可读）。
+            // 保存档案时顺手把残留字段清掉，避免新旧语义并存造成误读。
+            if (archive.memories !== undefined)
+                delete archive.memories;
             const slice = await deps.loadSlice();
             if (Object.keys(archive).length === 0)
                 delete slice.archives[scene];
@@ -147,10 +157,50 @@ export function createArchiveEngine(deps) {
             const archive = slice.archives[target];
             if (!(await deps.sceneExists(target)))
                 return { ok: false, error: `场景不存在: ${target}` };
-            if (!archive || (!hasSection(archive, 'mcp') && !hasSection(archive, 'skills'))) {
-                return { ok: false, error: `场景「${target}」的档案没有 MCP / 技能段（仅记忆或仅子智能体的场景不需要进入模式）` };
+            // 无档案段（纯记忆 / 纯人设场景）**也要能进入**：不应用档案、不建快照，但
+            // `mode.scene` 与 `active` 照常写入。原因有二：
+            //   ① 场景开关（P6）是唯一入口，纯记忆场景点开关不能报错；
+            //   ② 顶部「当前模式」横幅的渲染条件是 `mode.scene`，不写就永远不显示 ——
+            //      用户裁定：无档案场景开开关也要显示横幅，副标题走 `scenes.mode.noProfile`。
+            const appliesArchive = !!archive && (hasSection(archive, 'mcp') || hasSection(archive, 'skills') || hasSection(archive, 'subagents'));
+            // 先算计划、再拍快照：快照只记**将被改动**的服务器行 / 来源 / 人设（带改动前的状态），
+            // 退出时按记录精确恢复 —— 不动用户手动设置的其他行。
+            let mcpPlan = null;
+            let skillsPlan = null;
+            if (appliesArchive && archive) {
+                try {
+                    if (archive.mcp) {
+                        mcpPlan = computeMcpPlan(archive.mcp, {
+                            configuredServers: await deps.configuredServers(),
+                            knownTools: await deps.serverKnownTools(),
+                            serverStates: await deps.mcpServerStates(),
+                        });
+                    }
+                    if (archive.skills) {
+                        skillsPlan = computeSkillsPlan(archive.skills, await deps.knownSkillKeys(), await deps.skillSourceStates());
+                    }
+                }
+                catch (e) {
+                    return { ok: false, error: `读取运行时状态失败（未改动任何东西）：${msg(e)}` };
+                }
             }
-            const snapshot = snapshotRuntime(await deps.currentMcpRaw(), await deps.currentSkills());
+            // 子智能体段：进入时把档案勾选的人设**启用**（子智能体页同步亮起）。
+            // 快照只记「改动前停用」的那些 —— 退出时按名单停回，不动其他行。
+            const boundPersonas = archive && Array.isArray(archive.subagents) ? archive.subagents : [];
+            let personaRestore = [];
+            if (boundPersonas.length) {
+                try {
+                    personaRestore = await deps.disabledPersonas(boundPersonas);
+                }
+                catch (e) {
+                    return { ok: false, error: `读取人设开关状态失败（未改动任何东西）：${msg(e)}` };
+                }
+            }
+            const snapshot = appliesArchive
+                ? snapshotRuntime(await deps.currentMcpRaw(), await deps.currentSkills(), 
+                // 直接用计划带出的 `*Before`（改动前的状态），不在这里反推 —— 反推容易搞反方向。
+                (mcpPlan?.serverSwitches ?? []).map((s) => ({ id: s.id, level: s.level, disabled: s.disabledBefore })), (skillsPlan?.sourceSwitches ?? []).map((s) => ({ root: s.root, enabled: s.enabledBefore })), personaRestore)
+                : null;
             const entered = { ...slice, mode: { scene: target, snapshot }, active: [target] };
             try {
                 await deps.saveSlice({ ...slice, mode: entered.mode });
@@ -160,31 +210,51 @@ export function createArchiveEngine(deps) {
             }
             const stale = [];
             try {
-                if (archive.mcp) {
-                    const plan = computeMcpPlan(archive.mcp, {
-                        configuredServers: await deps.configuredServers(),
-                        knownTools: await deps.serverKnownTools(),
-                    });
-                    stale.push(...plan.stale);
-                    await deps.applyMcpEntries(plan.entries);
+                // ① 先切**上层**（服务器级 / 来源级）——下层只有在上层开着时才有意义：
+                //    服务器没起来，它的工具不存在，工具级停用无从谈起；来源关着，技能级 enable 会被吞掉。
+                if (mcpPlan && mcpPlan.serverSwitches.length) {
+                    await deps.applyMcpServerSwitches(mcpPlan.serverSwitches.map((s) => ({ id: s.id, level: s.level, enabled: s.enabled })));
+                }
+                if (skillsPlan && skillsPlan.sourceSwitches.length) {
+                    await deps.applySkillSourceSwitches(skillsPlan.sourceSwitches.map((s) => ({ root: s.root, enabled: s.enabled })));
+                }
+                // ② 再写**下层**（工具级停用表 / 技能级策略）。
+                if (mcpPlan) {
+                    stale.push(...mcpPlan.stale);
+                    await deps.applyMcpEntries(mcpPlan.entries);
+                }
+                if (skillsPlan) {
+                    stale.push(...skillsPlan.stale);
+                    await deps.applySkills(skillsPlan.target);
                 }
-                if (archive.skills) {
-                    const plan = computeSkillsPlan(archive.skills, await deps.knownSkillKeys());
-                    stale.push(...plan.stale);
-                    await deps.applySkills(plan.target);
+                // ③ 子智能体开关：把档案勾选的人设启用（子智能体页与目录段同步亮起）。
+                if (boundPersonas.length) {
+                    await deps.applySubagentSwitches(boundPersonas.map((n) => ({ name: n, enabled: true })));
                 }
             }
             catch (e) {
-                return await rollback(slice, snapshot, '应用档案', e);
+                // 无档案段时没有运行时改动可回滚（snapshot 为 null）。
+                return snapshot ? await rollback(slice, snapshot, '应用档案', e) : { ok: false, error: `应用档案失败：${String(e?.message || e)}` };
             }
             // ③ 记忆启用集收窄为 {S}（`_shared` 由 resolveActiveScenes 恒常加入；退出不恢复）。
             try {
                 await deps.saveSlice(entered);
             }
             catch (e) {
-                return await rollback(slice, snapshot, '记忆收窄落盘', e);
+                return snapshot ? await rollback(slice, snapshot, '记忆收窄落盘', e) : { ok: false, error: `记忆收窄落盘失败：${String(e?.message || e)}` };
             }
-            return { ok: true, mode: entered.mode, applied: { mcp: !!archive.mcp, skills: !!archive.skills }, stale, narrowedTo: [target] };
+            return {
+                ok: true,
+                mode: entered.mode,
+                applied: { mcp: !!(archive && archive.mcp), skills: !!(archive && archive.skills), subagents: !!(archive && archive.subagents) },
+                // 上层实际切换了几个（0 = 本来就已经是目标状态，界面不必提示"已停用 N 台"）。
+                switched: {
+                    mcpServers: mcpPlan ? mcpPlan.serverSwitches.length : 0,
+                    skillSources: skillsPlan ? skillsPlan.sourceSwitches.length : 0,
+                },
+                stale,
+                narrowedTo: [target],
+            };
         }),
     };
     return { ops, writeOps: new Set(['scene-archive-save', 'scene-mode-set']) };