dsh-plugin-tool-management 0.7.0 → 0.8.5

package/lib/index.js

@@ -16,14 +16,17 @@ import { randomUUID } from 'node:crypto';
 import { ArchiveWorkspaceRegistry as HistoryService, workspaceBaseName, workspacePathKey } from './history/workspace.js';
 import { createSkillsService, pluginLog } from './skills/service.js';
 import { createAgentsMdService } from './agents-md/service.js';
-import { createRulesService } from './rules/service.js';
+import { createRulesService, planMemoryExport } from './rules/service.js';
 import { createArchiveEngine } from './rules/archive-engine.js';
-import { createSubagentService, decideToolFilter } from './subagents/service.js';
+import { createSubagentService, decideToolFilter, defaultPersonasDir } from './subagents/service.js';
+import { createSubagentCatalog } from './subagents/catalog.js';
+import { SECTION_ORDER, createPromptSectionRegistrar } from './prompt-sections.js';
 import { isApprovalNever } from './approval-policy.js';
-import { EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, summarize } from './compat/probe.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 { 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 { createScenePromptSync } from './scene-prompt-sync.js';
 import { defineSubagentListTool, defineSubagentRunTool } from './subagents/tools.js';
@@ -31,7 +34,8 @@ import { detectFormat, extractText, parseGenericText, parseJsonlTranscript, pars
 import { homedir } from 'node:os';
 import { spawn } from 'node:child_process';
 import { mkdir, readdir, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
+import { zipSync } from 'fflate';
 // ---------------------------------------------------------------------------
 // Transcript export helpers — mirror the import parsers (src/imports/parsers.js)
 // so an exported file can be imported back losslessly. Pure Node, no ctx.
@@ -124,7 +128,7 @@ export default {
         // ---------- agents-md 预设库 + 切换 ----------
         // DSH 全局指令基线只有 ~/.dsh/AGENTS.md 一个文件，无内置多预设切换；
         // 本服务在 hub 内 agents-md/ 维护预设库，「应用」= 写入 ~/.dsh/AGENTS.md，
-        // 新会话生效（当前会话不变，DSH 本身如此）。
+        // 下一轮对话生效：宿主 dsh-agent-instructions 每个 agent/pre-step 都会 stat 并重读该文件。
         // presetsDir 可由 config 注入（测试用），否则落到 $DSH_HOME/tool-management/agents-md。
         // v0.4：旧位置（插件目录 data/agents-md-presets/）在启动时搬入 hub——
         // 插件目录在 npm 安装下会被覆盖，放用户数据在那里本身就丢数据风险。
@@ -315,11 +319,15 @@ export default {
                 const raw = await readDisabledTools();
                 for (const [server, list] of Object.entries(raw))
                     out[server] = list.filter((t) => t !== '*');
+                // 「已知工具」缓存：未运行服务器也能按最后见过的名单计算补集。
+                for (const [server, list] of Object.entries(await readKnownMcpTools())) {
+                    out[server] = [...new Set([...(out[server] || []), ...list])].sort();
+                }
                 let schemas = [];
                 try {
                     schemas = await tools.schemas();
                 }
-                catch { /* 无 live 工具 → 仅启停表 */ }
+                catch { /* 无 live 工具 → 仅停用表 + 缓存 */ }
                 for (const s of schemas) {
                     const p = toolKeyParts(String((s && s.name) || ''));
                     if (!p)
@@ -365,12 +373,101 @@ export default {
                         throw new Error(`技能 ${key} 应用失败: ${r.error}`);
                 }
             },
+            // ── 服务器级 / 来源级启停（P5）────────────────────────────────────────────
+            // 为什么档案必须能改**上层**：工具级停用只在「服务器已经加载」时才有意义 ——
+            // 服务器没起来，它的工具根本不存在，勾选与否毫无区别。技能同理：来源关闭时，
+            // 技能级的 enable 会被 core 的 sourceEnabled 判定直接吞掉。
+            // 只报**补丁文件里真实存在**的行（level = project/global）；loader 级条目改不了补丁。
+            mcpServerStates: async () => {
+                const r = await mcpmListView();
+                const out = [];
+                for (const row of ((r && r.rows) || [])) {
+                    const level = String((row && row.level) || '');
+                    if (level !== 'global' && level !== 'project')
+                        continue;
+                    out.push({
+                        id: String(row.id),
+                        serverName: String(row.serverName || row.id),
+                        level,
+                        disabled: !!row.disabled,
+                    });
+                }
+                return out;
+            },
+            applyMcpServerSwitches: async (switches) => {
+                for (const s of switches) {
+                    const r = await mcpmSetEnabled({ id: s.id, level: s.level, enabled: s.enabled });
+                    if (r && r.ok === false)
+                        throw new Error(`MCP 服务器 ${s.id} ${s.enabled ? '启用' : '停用'}失败：${r.error}`);
+                }
+                // 补丁改动由宿主热重载（实测 ≤5s）。这里**不等**，避免进入模式被拖住十几秒；
+                // 界面在应用完成后即可用，工具集合会在数秒内补齐。
+            },
+            // 场景备注（v0.8.1）：备注写在 `dsh-plugin-tool-management-notes.json`（按 loader id），
+            // 场景档案按 serverName 存 —— 引擎负责映射与读写，与 mcpm-note 同一条写锁。
+            currentMcpNotes: async () => ({ ...(await readNotes()) }),
+            applyMcpNotes: async (entries) => {
+                await withWriteLock(async () => {
+                    const map = Object.assign({}, await readNotes(true));
+                    for (const e of entries) {
+                        if (e.note)
+                            map[e.id] = e.note;
+                        else
+                            delete map[e.id];
+                    }
+                    const p = await ensurePaths();
+                    await writeJsonFile(sidecarPath(p.home, 'dsh-plugin-tool-management-notes.json'), map);
+                    notesCache = { at: Date.now(), value: map };
+                });
+            },
+            mcpIdOfServer: async (serverName) => {
+                const r = await mcpmListView();
+                for (const row of ((r && r.rows) || [])) {
+                    if (String(row.serverName || row.id) === serverName)
+                        return String(row.id);
+                }
+                return undefined;
+            },
+            skillSourceStates: async () => {
+                const r = await skillsService.ops['skill-state']({});
+                const roots = (r && r.data && r.data.roots) || [];
+                const out = [];
+                for (const root of roots) {
+                    const key = String((root && root.key) || '');
+                    if (!key)
+                        continue;
+                    // 默认来源（dsh / hub）不能停用（core 会拒绝）→ 不进切换集，避免无谓报错。
+                    if (root.defaultSource === true)
+                        continue;
+                    out.push({ root: key, enabled: root.enabled === true });
+                }
+                return out;
+            },
+            applySkillSourceSwitches: async (switches) => {
+                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)
+                        throw new Error(`技能来源 ${s.root} ${s.enabled ? '启用' : '停用'}失败：${r.error}`);
+                }
+            },
             sceneExists: async (name) => {
                 const r = await rulesService.ops['rules-list']({});
                 return !!(r && r.ok !== false && (r.scenes || []).some((s) => s.name === name));
             },
             // 人设名全集（保存 subagents 段时校验并报 stale，与 mcp/skills 两段同口径）。
             knownPersonas: async () => new Set((await subagentService.list()).map((p) => p.name)),
+            // 人设开关读/写（进入模式启用档案勾选的人设；退出按快照停回）。
+            disabledPersonas: async (names) => subagentService.enabledStore.disabledAmong(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);
+                if (off.length)
+                    await subagentService.enabledStore.setEnabled(off, false);
+                if (on.length)
+                    await subagentService.enabledStore.setEnabled(on, true);
+                void subagentCatalog.refresh();
+            },
             // 记忆 id 全集（保存 memories 段时校验并报 stale）。
             knownMemoryIds: async () => {
                 const r = await rulesService.ops['rules-list']({});
@@ -380,7 +477,8 @@ export default {
         // ---------- 轻量子智能体（设计 §3）----------
         // 人设 = $DSH_HOME/tool-management/agents/<name>.md；运行走官方 ctx.subagents.start（spawn provider）。
         // sceneLists 供场景绑定校验：启用场景（rules-list 的 active 行）档案里的 subagents 并集。
-        const subagentService = createSubagentService(ctx, {});
+        // stateDir 与 rules 共用同一个覆盖键（测试注入一致）；子智能体开关存 <stateDir>/agents-index.json。
+        const subagentService = createSubagentService(ctx, { stateDir: String(config?.rulesStateDir || '') });
         const subagentSceneLists = async () => {
             const slice = await rulesService.readArchiveSlice();
             const r = await rulesService.ops['rules-list']({});
@@ -390,6 +488,153 @@ export default {
                 .filter((s) => s.active)
                 .map((s) => slice.archives[s.name]?.subagents ?? []);
         };
+        // ---------- 注入类段（P1 人设目录 + P2 MCP 状态）----------
+        // 两者是同一类缺陷的两端：**某个域的配置状态没有在场陈述**，模型只能靠用户口头提醒。
+        //   - 人设：本插件自造的概念，宿主没有对应物 → 模型不知道有哪些人设，subagent_run 不会被触发。
+        //   - MCP：启停只改工具 schema，没有任何显式状态陈述 → 模型不知道有哪些 server，
+        //     更拿不到用户写的**备注**（那是写给「未来的模型」的决策提示，工具 schema 永远传达不到）。
+        // 两个段都只列「名字 + 摘要」，正文/工具清单绝不进上下文。
+        // 口径与理由分别见 src/subagents/catalog.ts、src/mcp/state-section.ts 的文件头。
+        const subagentCatalog = createSubagentCatalog({
+            list: () => subagentService.list(),
+            sceneLists: subagentSceneLists,
+        });
+        // ⚠️ 取数必须用 mcpmRowsWithNotes(false)：true 会带上**未打码**的 url/headers/env（含明文密钥）。
+        const mcpStateCatalog = createMcpStateCatalog({
+            rows: () => mcpmRowsWithNotes(false),
+        });
+        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');
+        }
+        catch (e) {
+            console.error('[dsh-plugin-tool-management] prompt section setup failed:', message(e));
+        }
+        // 预热放到下一轮事件循环：此时 apply 的同步初始化（补丁路径、tools 服务…）已全部完成，
+        // 避免在初始化中途就去读 MCP 补丁与工具 schema。
+        setTimeout(() => {
+            void subagentCatalog.warm();
+            void mcpStateCatalog.warm();
+        }, 0);
+        // 人设写操作成功后立即重算目录（SWR：text() 同步返回缓存值，写后主动 refresh）。
+        // 包装在 service 的 ops 上：写入口只有这一处，不需要在界面层逐个补。
+        for (const opName of subagentService.writeOps) {
+            const original = subagentService.ops[opName];
+            if (typeof original !== 'function')
+                continue;
+            subagentService.ops[opName] = async (args) => {
+                const result = await original(args);
+                if (result && result.ok !== false)
+                    void subagentCatalog.refresh();
+                return result;
+            };
+        }
+        /**
+         * 人设改名后同步场景绑定：场景档案的 `subagents` 名单存的是**人设名**，
+         * 不跟着改就会留一个悬空引用（界面把它报成 stale，用户看到「人设不存在」却找不到地方改）。
+         * 绑定存在 rules-index.json 里，人设服务看不到它，所以在这一层补一次（同提示词改名的做法）。
+         */
+        async function rebindSubagentInArchives(from, to) {
+            try {
+                const slice = await rulesService.readArchiveSlice();
+                const archives = { ...(slice.archives || {}) };
+                let changed = 0;
+                for (const [scene, archive] of Object.entries(archives)) {
+                    const list = archive.subagents;
+                    if (!Array.isArray(list) || !list.includes(from))
+                        continue;
+                    archives[scene] = { ...archive, subagents: list.map((n) => (n === from ? to : n)) };
+                    changed++;
+                }
+                if (changed)
+                    await rulesService.patchIndex({ archives });
+                return changed;
+            }
+            catch {
+                return 0;
+            }
+        }
+        const baseSubagentUpdate = subagentService.ops['subagent-update'];
+        if (typeof baseSubagentUpdate === 'function') {
+            subagentService.ops['subagent-update'] = async (args) => {
+                const res = await baseSubagentUpdate(args);
+                if (res && res.ok !== false && res.renamedFrom)
+                    void rebindSubagentInArchives(String(res.renamedFrom), String(res.name));
+                return res;
+            };
+        }
+        // 模式切换会改人设开关（进入=启用勾选的，退出=按快照停回）——目录段立即重算，
+        // 别等 1s TTL：切完场景紧接着的下一轮请求就该看到新名单。
+        const baseSceneModeSet = archiveService.ops['scene-mode-set'];
+        if (typeof baseSceneModeSet === 'function') {
+            archiveService.ops['scene-mode-set'] = async (args) => {
+                // 锁定的场景不能关闭（用户裁定）：退出模式（scene=null）和切换到别的场景
+                // 都意味着先退出当前模式 —— 当前模式场景处于锁定状态时一律拒绝。
+                // 目标就是当前场景 = 无操作，放行（引擎自己会 early-return）。
+                try {
+                    const slice = await rulesService.readArchiveSlice();
+                    const current = slice.mode && slice.mode.scene;
+                    if (current && args && 'scene' in (args || {})) {
+                        const target = args.scene == null ? null : String(args.scene).trim() || null;
+                        if (target !== current) {
+                            const locked = await lockedSceneNames();
+                            if (locked.includes(current)) {
+                                return { ok: false, error: `场景「${current}」已锁定：先解锁再关闭` };
+                            }
+                        }
+                    }
+                }
+                catch { /* 守卫读状态失败不拦正常流程（引擎自身校验兜底） */ }
+                const res = await baseSceneModeSet(args);
+                if (res && res.ok !== false) {
+                    // 进/退/切换模式会改 MCP 启停（服务器级）与备注（场景备注覆盖/恢复），
+                    // 状态段必须立即重算 —— 场景退出后下一次请求就该看到恢复的全局备注与启停。
+                    void subagentCatalog.refresh();
+                    void mcpStateCatalog.refresh();
+                }
+                return res;
+            };
+        }
+        /**
+         * 模式进行中保存当前场景的档案时，联动人设开关：subagents 段新勾进来的名字**立即启用**，
+         * 并追加进快照的「模式期间自动启用」名单（退出时停回）。只启用、不停用 —— 用户手动
+         * 关掉的开关不该被一次档案保存悄悄改回去。
+         */
+        const baseSceneArchiveSave = archiveService.ops['scene-archive-save'];
+        if (typeof baseSceneArchiveSave === 'function') {
+            archiveService.ops['scene-archive-save'] = async (args) => {
+                const res = await baseSceneArchiveSave(args);
+                try {
+                    const bound = res && res.ok !== false && res.archive && Array.isArray(res.archive.subagents) ? res.archive.subagents : [];
+                    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 } } });
+                                }
+                            }
+                        }
+                    }
+                }
+                catch { /* 联动失败不阻断档案保存本身；开关会在下次进/退模式时对齐 */ }
+                return res;
+            };
+        }
         // HTTP 写操作门禁清单。skills/rules/档案引擎域由各自 service 导出的 writeOps 派生
         // （与其 ops 表同文件维护，新增写 op 改对应 service 即可）；本文件内联域
         // （mcpm-* / skill-open / agentsmd-* / history-*）在此列举。
@@ -415,6 +660,8 @@ export default {
             // workspace-register 会新增一条宿主工作区登记，同样是写）
             'history-archive', 'history-unarchive', 'history-delete', 'history-retention-set',
             'history-unarchive-batch', 'history-delete-batch', 'history-import', 'history-export',
+            // 通用导出：往用户指定的目录写文件，按写操作门禁（token）。
+            'bundle-export',
             'history-archive-batch', 'history-workspace-register',
         ]);
         // 会泄露明文凭据 / 完整配置的 op：**必须**带对的访问令牌，没配令牌就一律拒绝
@@ -1355,6 +1602,34 @@ export default {
             }
             return out;
         }
+        // ---------- 「已知工具」侧车（v0.8.1）-----------------------------------
+        // MCP 工具名只在服务器**运行**时可见（tools.schemas() 里才有）。未运行的服务器在
+        // 场景档案里既显示 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 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();
+                }
+            }
+            knownMcpToolsCache = { at: Date.now(), value: out };
+            return out;
+        }
+        async function writeKnownMcpTools(value) {
+            const p = await ensurePaths();
+            await writeJsonFile(sidecarPath(p.home, KNOWN_MCP_TOOLS_FILE), value);
+            knownMcpToolsCache = { at: Date.now(), value: value };
+        }
         /** 单工具停用判定（含整服务器通配 `*`——场景档案的"MCP 工具集=整台"写的就是它）。 */
         function isToolDisabled(map, fullName) {
             if (!fullName.startsWith('mcp__'))
@@ -1585,8 +1860,77 @@ export default {
                     toolsList.push({ name, description: '（已停用；描述暂不可用）', enabled: false, parameters: [] });
                 }
             }
+            // 「已知工具」缓存兜底：服务器没运行时 schemas() 里没有它任何工具 —— 场景档案里
+            // 想给未运行服务器挑工具就全靠这份最后见过的名单（描述/参数不可用，按名字勾选）。
+            for (const name of (await readKnownMcpTools())[serverName] || []) {
+                if (listed.has(name))
+                    continue;
+                toolsList.push({ name, description: '（服务器未运行；描述暂不可用）', enabled: !disabledHere.has(name), parameters: [] });
+                listed.add(name);
+            }
             return { ok: true, tools: toolsList };
         }
+        /**
+         * 临时启动服务器以枚举工具（v0.8.1）：从未运行过的服务器在 schemas() 与「已知工具」
+         * 缓存里都没有工具名，场景档案勾选器对它一无所知。这里**临时**把它启用（写补丁），
+         * 轮询等它的工具注册（npx 冷启动要下载，上限 30s），拿到名单后就**恢复原启停状态**——
+         * 用户环境的服务器开关不受影响。已有已知工具时直接返回现有清单，不做任何改动。
+         */
+        async function mcpmToolsRefresh(args) {
+            const serverName = String((args && args.serverName) || '').trim();
+            if (!serverName)
+                return { ok: false, error: 'serverName 不能为空' };
+            const existing = await mcpmTools({ serverName });
+            if (existing && existing.ok === false)
+                return existing;
+            if (existing && (existing.tools || []).length)
+                return existing;
+            const list = await mcpmListView();
+            const row = ((list && list.rows) || []).find((r) => String(r.serverName) === serverName);
+            if (!row)
+                return { ok: false, error: `未找到服务器: ${serverName}` };
+            if (row.level !== 'global' && row.level !== 'project') {
+                return { ok: false, error: `该服务器不驻留在补丁文件（level=${row.level}），无法临时启动；请先在 MCP 页启用它一次以记录工具` };
+            }
+            const wasDisabled = !!row.disabled;
+            try {
+                if (wasDisabled) {
+                    const r = await mcpmSetEnabled({ id: row.id, level: row.level, enabled: true });
+                    if (r && r.ok === false)
+                        return r;
+                }
+                const deadline = Date.now() + 30000;
+                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) {
+                            try {
+                                const cache = await readKnownMcpTools();
+                                const merged = [...new Set([...(cache[serverName] || []), ...names])].sort();
+                                cache[serverName] = merged;
+                                await writeKnownMcpTools(cache);
+                            }
+                            catch { /* 缓存写失败不影响本次返回 */ }
+                        }
+                        return t;
+                    }
+                    if (Date.now() >= deadline)
+                        break;
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                return { ok: false, error: `等待超时：${serverName} 在 30 秒内没有注册任何工具（服务器可能启动失败或连接过慢）` };
+            }
+            finally {
+                if (wasDisabled) {
+                    const r = await mcpmSetEnabled({ id: row.id, level: row.level, enabled: false });
+                    if (!r || r.ok === false)
+                        console.warn('[dsh-plugin-tool-management] mcpm-tools-refresh: 恢复服务器停用状态失败', serverName);
+                }
+                void mcpStateCatalog.refresh();
+            }
+        }
         async function mcpmList() {
             const p = await ensurePaths();
             const rows = [];
@@ -1608,23 +1952,54 @@ export default {
             const toolCounts = {};
             try {
                 const schemas = await tools.schemas();
+                const knownCache = await readKnownMcpTools();
+                const liveNames = {};
                 const seen = new Set();
                 for (const s of schemas) {
                     const fullName = String(s && s.name || '');
-                    seen.add(fullName);
-                    const m = fullName.match(/^mcp__([A-Za-z0-9_-]+)__/);
-                    if (m)
-                        toolCounts[m[1]] = (toolCounts[m[1]] || 0) + 1;
-                }
-                // Restricted tools may be absent from schemas(); they still belong to
-                // the per-server count so the UI does not show a phantom drop.
-                for (const fullName of disabledToolNames(await readDisabledTools())) {
                     if (seen.has(fullName))
                         continue;
-                    const m = fullName.match(/^mcp__([A-Za-z0-9_-]+)__/);
-                    if (m)
-                        toolCounts[m[1]] = (toolCounts[m[1]] || 0) + 1;
+                    seen.add(fullName);
+                    const m = fullName.match(/^mcp__([A-Za-z0-9_-]+)__(.+)$/);
+                    if (!m)
+                        continue;
+                    const list = liveNames[m[1]] || (liveNames[m[1]] = []);
+                    if (list.indexOf(m[2]) < 0)
+                        list.push(m[2]);
+                }
+                // 工具数 = live ∪ 停用表里的单个工具名 ∪ 「已知工具」缓存 —— 未运行的服务器
+                // 也能显示最后一次见过的工具数，而不是永远 0。
+                const union = {};
+                const addTool = (server, tool) => {
+                    if (!server || !tool)
+                        return;
+                    const set = union[server] || (union[server] = new Set());
+                    set.add(tool);
+                };
+                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 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))
+                    toolCounts[server] = set.size;
+                // 回写「已知工具」：live 见到的名字并入缓存（有变化才写盘，读路径上的 best-effort）。
+                let cacheChanged = false;
+                for (const [server, list] of Object.entries(liveNames)) {
+                    const prev = knownCache[server] || [];
+                    const next = [...new Set([...prev, ...list])].sort();
+                    if (next.join('\u0000') !== prev.join('\u0000')) {
+                        knownCache[server] = next;
+                        cacheChanged = true;
+                    }
                 }
+                if (cacheChanged)
+                    void writeKnownMcpTools(knownCache).catch(() => { });
             }
             catch (e) { /* ignore */ }
             let live = [];
@@ -1710,7 +2085,10 @@ export default {
                 }
                 const before = content;
                 content = appendBlock(content, buildInsertBlock(row));
-                if (args.enabled === false)
+                // v0.8.5：新增服务器默认不启动（用户裁定，与技能 / 子智能体同口径）；
+                // 显式传 enabled: true 才创建即启动。
+                const defaultDisabled = args.enabled !== true;
+                if (defaultDisabled)
                     content = appendBlock(content, buildDisableBlock(id, true));
                 const guard = duplicateGuard(before, content);
                 if (guard)
@@ -1721,7 +2099,7 @@ export default {
                 catch (e) {
                     return { ok: false, error: '写入补丁失败: ' + message(e) };
                 }
-                return { ok: true, row: { ...row, level, disabled: args.enabled === false } };
+                return { ok: true, row: { ...row, level, disabled: defaultDisabled } };
             });
         }
         async function mcpmEdit(args) {
@@ -2270,6 +2648,24 @@ export default {
                 }
                 const sessionPaths = registry.sessionPaths instanceof Map ? registry.sessionPaths : undefined;
                 const headers = registry.headers instanceof Map ? registry.headers : undefined;
+                // 「目录真实存在」检查缓存：canRegister 从「宿主 sessionPaths 命中」放宽为
+                // 「目录存在」时，同一目录只 stat 一次；结果按归一化键缓存，避免每次刷新重复探盘。
+                const dirExistsCache = new Map();
+                async function directoryExists(p) {
+                    const k = workspacePathKey(p);
+                    const hit = dirExistsCache.get(k);
+                    if (hit !== undefined)
+                        return hit;
+                    let ok = false;
+                    try {
+                        ok = (await stat(p)).isDirectory();
+                    }
+                    catch {
+                        ok = false;
+                    }
+                    dirExistsCache.set(k, ok);
+                    return ok;
+                }
                 for (const it of items) {
                     const sid = it.sessionId;
                     let wid = owned.get(sid);
@@ -2299,17 +2695,21 @@ export default {
                     const known = snapshot ? snapshot.get(workspacePathKey(path)) : undefined;
                     const existing = groupsById.get(key);
                     if (existing) {
-                        // 同目录的多个会话：目录存在（sessionPaths 命中）即可重新登记。
-                        if (canonical !== undefined)
+                        // 同目录的多个会话：宿主索引命中，或磁盘目录真实存在，即可重新登记。
+                        if (canonical !== undefined || (await directoryExists(path))) {
                             existing.canRegister = true;
+                            existing.dirMissing = false;
+                        }
                         continue;
                     }
+                    const canRegister = canonical !== undefined || (await directoryExists(path));
                     const view = {
                         id: key,
                         title: known?.title || workspaceBaseName(path) || path,
                         kind: 'detached',
                         registered: known !== undefined,
-                        canRegister: canonical !== undefined,
+                        canRegister,
+                        dirMissing: !canRegister,
                         path: known?.path || path,
                     };
                     groupsById.set(key, view);
@@ -2565,6 +2965,7 @@ export default {
             'mcpm-tool-enabled': mcpmToolEnabled,
             'skill-open': skillOpen,
             'mcpm-tools': mcpmTools,
+            'mcpm-tools-refresh': mcpmToolsRefresh,
             'mcpm-add': mcpmAdd,
             'mcpm-edit': mcpmEdit,
             'mcpm-set-enabled': mcpmSetEnabled,
@@ -2620,14 +3021,19 @@ export default {
                     if (!name || seen.has(name))
                         continue;
                     seen.add(name);
+                    const live = !!(row.live && row.live.enabled);
                     mcpServers.push({
                         name,
                         level: row.level || null,
-                        live: !!(row.live && row.live.enabled),
+                        live,
                         serverDisabled: !!row.disabled,
                         // 停用表里的 ['*'] = 整台工具停用（勾选器据此预勾，避免把"全停"读成"全启用"）。
                         allToolsDisabled: (disabledRaw[name] || []).indexOf('*') >= 0,
-                        toolCount: typeof row.toolCount === 'number' ? row.toolCount : null,
+                        // 未运行且没有任何已知工具 ⇒ null（客户端显示「工具数未知」并引导读取），
+                        // 不再给出误导性的 0。
+                        toolCount: live || Number(row.toolCount) > 0
+                            ? (typeof row.toolCount === 'number' ? row.toolCount : null)
+                            : null,
                     });
                 }
                 return {
@@ -2684,13 +3090,16 @@ export default {
             'agentsmd-create': (args) => agentsMdService.create(String((args && args.id) || ''), {
                 ...(args && args.from ? { from: String(args.from) } : {}),
                 ...(args && typeof args.content === 'string' ? { content: String(args.content) } : {}),
+                ...(args && typeof args.description === 'string' ? { description: String(args.description) } : {}),
             }),
             // 保存：改正文 + 可选改名（nextId）。改名成功顺带把场景绑定一起改名 ——
             // 绑定存在 rules-index.json 里，预设库自己看不到，不叫这一声就会留悬空绑定。
             // 保存后同步一次全局基线：若改的正是「正在驱动基线的那份」，正文要跟着写进
             // `~/.dsh/AGENTS.md`（否则页面标着「生效中」而文件里还是旧内容）。
             'agentsmd-update': async (args) => {
-                const res = await agentsMdService.update(String((args && args.id) || ''), String((args && args.content) ?? ''), args && args.nextId !== undefined ? String(args.nextId) : undefined);
+                const res = await agentsMdService.update(String((args && args.id) || ''), String((args && args.content) ?? ''), args && args.nextId !== undefined ? String(args.nextId) : undefined, 
+                // 描述与正文同一次提交：省略（undefined）= 不动，空串 = 清空。
+                args && typeof args.description === 'string' ? String(args.description) : undefined);
                 if (!res || res.ok === false)
                     return res;
                 let renamed = {};
@@ -2716,7 +3125,7 @@ export default {
                 }
                 return agentsMdService.remove(id);
             },
-            'agentsmd-import': (args) => agentsMdService.importPreset(String((args && args.id) || ''), String((args && args.content) ?? '')),
+            '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>/`，
             // 误删可从「提示词」页的回收站里恢复（同 id 已存在时拒绝恢复，绝不覆盖）。
             'agentsmd-trash-list': () => agentsMdService.trashList(),
@@ -2924,6 +3333,7 @@ export default {
                         mayDelete: assessment.mayDelete,
                         verifiedVersion: VERIFIED_HOST_VERSION,
                         expectedPeerRange: EXPECTED_PEER_RANGE,
+                        minHostVersion: EXPECTED_MIN_HOST_VERSION,
                         generatedAt: assessment.generatedAt,
                         summary,
                     };
@@ -3098,6 +3508,130 @@ export default {
             },
             // 把选中的归档会话导出为可再导入的转录文件（Markdown / JSONL），写入指定目录。
             // 每个会话一个文件；读不到正文的冷会话列入 skipped，不中断其余导出。
+            // ---------- 通用导出（D14）----------
+            // 技能 / 子智能体 / 提示词 / 记忆四个域的差异只有「从哪取哪些文件」，其余
+            //（绝对路径校验、建目录、zip 打包、错误回报）完全相同 —— 所以只加**一个** op。
+            // 打包用已在依赖里的 `fflate.zipSync`（此前只用了 unzipSync）。
+            'bundle-export': async (args) => {
+                const kind = String((args && args.kind) || '');
+                const KINDS = ['skills', 'subagents', 'presets', 'memories'];
+                if (KINDS.indexOf(kind) < 0)
+                    return { ok: false, error: `kind 需为 ${KINDS.join(' / ')}` };
+                const rawNames = (args && args.names) || [];
+                const names = Array.isArray(rawNames) ? rawNames.map((s) => String(s).trim()).filter(Boolean) : [];
+                if (!names.length)
+                    return { ok: false, error: '请至少选择一项' };
+                const outDir = String((args && args.outDir) || '').trim();
+                // 与 history-export 同一条校验：必须绝对路径（相对路径会在宿主进程的 cwd 下落盘，
+                // 用户根本找不到文件）。
+                if (!/^([A-Za-z]:[\\/]|\\\\|\/)/.test(outDir))
+                    return { ok: false, error: '导出目录需为绝对路径' };
+                // ① 收集 (zip 内路径, 绝对路径)。
+                const entries = [];
+                const missing = [];
+                try {
+                    if (kind === 'subagents') {
+                        const dir = defaultPersonasDir();
+                        for (const name of names)
+                            entries.push({ zip: `${name}.md`, abs: join(dir, `${name}.md`) });
+                    }
+                    else if (kind === 'presets') {
+                        for (const id of names) {
+                            entries.push({ zip: `${id}/AGENTS.md`, abs: join(agentsMdPresetsDir, id, 'AGENTS.md') });
+                            // 描述侧车（「只给使用者看」的那句）随预设一起走：导出再导入不该把它丢掉。
+                            const metaAbs = join(agentsMdPresetsDir, id, 'meta.json');
+                            try {
+                                if ((await stat(metaAbs)).isFile())
+                                    entries.push({ zip: `${id}/meta.json`, abs: metaAbs });
+                            }
+                            catch { /* 没写描述 */ }
+                        }
+                    }
+                    else if (kind === 'memories') {
+                        // 记忆有 flat（`<场景>/<name>.md`）与 bundle（`<场景>/<name>/SKILL.md`）两种形态，
+                        // 且场景名本身可含 '/' —— 按 id 拼路径会把 bundle 读成 `<场景>/<name>.md`，读不到
+                        // 就静默丢项（详见 planMemoryExport）。所以走索引拿那条规则自己的真实路径。
+                        const r = await rulesService.ops['rules-list']({});
+                        const plan = planMemoryExport(names, (r && r.rules) || []);
+                        missing.push(...plan.missing);
+                        for (const item of plan.entries) {
+                            if (item.kind === 'file') {
+                                entries.push({ zip: item.zip, abs: item.abs });
+                                continue;
+                            }
+                            // bundle：把目录内的文件全部打包（与技能分支同口径），单个目录读不了只丢它自己。
+                            try {
+                                for (const e of await readdir(item.abs, { withFileTypes: true })) {
+                                    if (e.isFile())
+                                        entries.push({ zip: `${item.zip}/${e.name}`, abs: join(item.abs, e.name) });
+                                }
+                            }
+                            catch {
+                                missing.push(item.id);
+                            }
+                        }
+                    }
+                    else {
+                        // 技能：先经 skill-detail 拿源文件路径（bundle 型是目录，单文件型是 .md）。
+                        for (const key of names) {
+                            const i = key.indexOf('/');
+                            if (i <= 0) {
+                                missing.push(key);
+                                continue;
+                            }
+                            const short = key.slice(i + 1);
+                            const r = await skillsService.ops['skill-detail']({ root: key.slice(0, i), name: short });
+                            const p = r && r.ok !== false && r.data ? String(r.data.path || '') : '';
+                            if (!p) {
+                                missing.push(key);
+                                continue;
+                            }
+                            let isDir = false;
+                            try {
+                                isDir = (await stat(p)).isDirectory();
+                            }
+                            catch {
+                                isDir = false;
+                            }
+                            if (isDir) {
+                                for (const e of await readdir(p, { withFileTypes: true })) {
+                                    if (e.isFile())
+                                        entries.push({ zip: `${short}/${e.name}`, abs: join(p, e.name) });
+                                }
+                            }
+                            else {
+                                entries.push({ zip: `${short}/${basename(p)}`, abs: p });
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    return { ok: false, error: '收集待导出文件失败: ' + message(e) };
+                }
+                // ② 读盘 + 打包（读不到的项进 missing，不整体失败 —— 部分成功也有价值）。
+                const bundle = {};
+                for (const item of entries) {
+                    try {
+                        bundle[item.zip] = new Uint8Array(await readFile(item.abs));
+                    }
+                    catch {
+                        missing.push(item.zip);
+                    }
+                }
+                if (!Object.keys(bundle).length)
+                    return { ok: false, error: '没有可导出的文件（选中项都不存在？）' };
+                let zipPath = '';
+                try {
+                    const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+                    zipPath = join(outDir, `dsh-tool-management-${kind}-${stamp}.zip`);
+                    await mkdir(outDir, { recursive: true });
+                    await writeFile(zipPath, Buffer.from(zipSync(bundle)));
+                }
+                catch (e) {
+                    return { ok: false, error: '写入导出文件失败: ' + message(e) };
+                }
+                return { ok: true, written: Object.keys(bundle).length, zipPath, missing };
+            },
             'history-export': async (args) => {
                 const rawIds = (args && args.sessionIds) || [];
                 const ids = Array.isArray(rawIds) ? rawIds.map((s) => String(s).trim()).filter(Boolean) : [];
@@ -3193,6 +3727,87 @@ export default {
                 return { ok: true, retentionDays: days };
             },
         };
+        // MCP 写操作成功后立即重算状态段（SWR：text() 同步返回缓存值，写后主动 refresh）。
+        // 覆盖所有会改变「哪些 server 可用 / 有哪些备注」的写入口 —— 集中在这一处包，
+        // 不需要在界面层逐个补（漏一个就会出现「改了但模型看不到」的静默不一致）。
+        for (const opName of ['mcpm-add', 'mcpm-edit', 'mcpm-remove', 'mcpm-set-enabled', 'mcpm-set-all',
+            'mcpm-restart', 'mcpm-note', 'mcpm-tool-enabled', 'mcpm-import', 'mcpm-compact', 'mcpm-tools-refresh']) {
+            const original = handlers[opName];
+            if (typeof original !== 'function')
+                continue;
+            handlers[opName] = async (args) => {
+                const result = await original(args);
+                if (result && result.ok !== false)
+                    void mcpStateCatalog.refresh();
+                return result;
+            };
+        }
+        // ---------- 场景锁定守卫（v0.8）----------
+        // 任一场景 locked=true = 五个管理域（MCP/技能/子智能体/记忆/提示词）整体冻结：
+        // 下面列出的写 op 一律拒绝；界面按钮同步禁用，这里是兜底（防止绕过界面直接打 op）。
+        // 只包 **handlers** 这一层是有意的：进/退模式的运行时应用走的是内部函数与
+        // service.ops（applyMcpServerSwitches / applySkills / applySubagentSwitches / patchIndex），
+        // 不经过 handlers —— 锁定就是为了让场景能按原样启动，运行时应用不能被自己挡住。
+        // 例外里的例外：scene-archive-save / rules-remove-scene 只对**被锁的那个场景**拒绝。
+        async function lockedSceneNames() {
+            const r = await rulesService.ops['rules-list']({});
+            return ((r && r.scenes) || []).filter((s) => s.locked === true).map((s) => String(s.name));
+        }
+        function guardLockedOps(opNames, what) {
+            for (const opName of opNames) {
+                const original = handlers[opName];
+                if (typeof original !== 'function')
+                    continue;
+                handlers[opName] = async (args) => {
+                    const locked = await lockedSceneNames();
+                    if (locked.length)
+                        return { ok: false, error: `场景已锁定（${locked.join('、')}）：先到场景页解锁再${what}` };
+                    return original(args);
+                };
+            }
+        }
+        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-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',
+            // 记忆：增删改 / 开关 / 导入 / 回收站 / 绑定。set-active 是场景启停，不在冻结范围。
+            'rules-create', 'rules-update', 'rules-remove', 'rules-toggle', 'rules-import', 'rules-restore', 'rules-trash-remove', 'rules-attach', 'rules-detach', 'rules-set-index',
+            // 提示词：建改删 / 应用（切换生效基线）/ 导入 / 回收站。
+            'agentsmd-create', 'agentsmd-update', 'agentsmd-remove', 'agentsmd-apply', 'agentsmd-import', 'agentsmd-trash-restore', 'agentsmd-trash-delete',
+        ], '修改');
+        // 被锁场景自身的档案与删除：只挡它自己，别的场景照常。
+        for (const [opName, pickScene, what] of [
+            ['scene-archive-save', (args) => (args && args.scene) || '', '改档案'],
+            ['rules-remove-scene', (args) => (args && args.name) || '', '删除'],
+        ]) {
+            const original = handlers[opName];
+            if (typeof original !== 'function')
+                continue;
+            handlers[opName] = async (args) => {
+                const scene = String(pickScene(args) || '').trim();
+                const locked = await lockedSceneNames();
+                if (scene && locked.includes(scene))
+                    return { ok: false, error: `场景「${scene}」已锁定：先解锁再${what}` };
+                return original(args);
+            };
+        }
+        // 各页列表响应带上 anyLocked：界面据此禁用写控件（读 op，附加字段不影响既有消费方）。
+        async function annotateLocked(res) {
+            if (res && res.ok !== false)
+                res.anyLocked = (await lockedSceneNames()).length > 0;
+            return res;
+        }
+        for (const opName of ['mcpm-list', 'mcpm-reveal', 'skill-state', 'subagent-list', 'agentsmd-list']) {
+            const original = handlers[opName];
+            if (typeof original !== 'function')
+                continue;
+            handlers[opName] = async (args) => annotateLocked(await original(args));
+        }
         // ---------- agent-facing tools (standard ctx.tools.register + defineTool) ----------
         const text = (value) => [{ type: 'text', text: value }];
         tools.register(defineTool({
@@ -3334,12 +3949,12 @@ export default {
                 // 同上：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(Applying takes effect on the next session created; the current session is unchanged.)' + notice;
+                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;
             },
         }));
         tools.register(defineTool({
             name: 'agentsmd_apply',
-            description: 'Apply one AGENTS.md preset by writing it to ~/.dsh/AGENTS.md. Takes effect on the next session created; the current session is unchanged.',
+            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.',
             parameters: {
                 id: { type: 'string', required: true, description: 'Preset id (lowercase letters, digits, hyphens).' },
             },
@@ -3503,9 +4118,14 @@ export default {
         if (typeof ctx.on === 'function') {
             try {
                 // MCP servers (de)register their tools as instances come and go; the
-                // visible-set restriction must track that.
+                // visible-set restriction must track that — and so must the MCP state
+                // section: 工具加载完成后若不重算，段会一直停留在「空/旧集合」的缓存值上
+                //（用户切 MCP 后立即看系统提示词就是空段 —— 2026-09-16 实测）。
                 ctx.effect(() => {
-                    const stop = ctx.on('tools/change', () => scheduleToolRestrictions());
+                    const stop = ctx.on('tools/change', () => {
+                        scheduleToolRestrictions();
+                        void mcpStateCatalog.refresh();
+                    });
                     return typeof stop === 'function' ? stop : () => { };
                 }, 'dsh-plugin-tool-management: tools/change listener');
             }