dsh-plugin-tool-management 0.18.0 → 0.19.0

package/lib/context-inject-frame.js

@@ -67,6 +67,19 @@ export const DOMAIN_FRAME = {
         supersede: SUPERSEDE_NOTE,
     },
 };
+/**
+ * `how` 行里**点名过的工具**（六个域里只有 skills / subagents 两个会点名）。
+ *
+ * 为什么要有这份名单：一条 `how` 行是否成立，取决于它点名的工具在**这个 agent 手里**还在不在。
+ * 名单放在这里而不是调用方 —— 与上面那两条 `how` 相邻，改一处不会漏另一处。
+ *
+ * "不在手里"有两条路，都要算：
+ *   ① 兼容页「模型工具表」把它关掉（用户全局开关，名单在 index.ts 的 `hiddenTools` 里）；
+ *   ② **人设的工具限制**把它砍掉（`decideToolFilter` → 官方 `tools.restrict`，只作用于那份
+ *      人设启动的子代理）。②此前没人管：目录照注、`how` 行照样点名一个模型手里没有的工具，
+ *      等于诱导它去调一个不存在的名字（2026-10-07 修）。
+ */
+export const HOW_NAMED_TOOLS = ['skill_manager_read', 'subagent_manager_run'];
 /** 域声明里没登记的 key（理论上到不了这里）：给一个不出错的通用框架。 */
 export const fallbackFrame = (label) => ({
     title: `本机的${label}`,

package/lib/context-inject-select.js

@@ -20,9 +20,10 @@ export function normalizeInjectSettings(raw) {
  * 规则（设计 2026-09-16；目录注入深度 2026-09-17）：
  *   - 域开关关掉的、文本为空的，都不进；
  *   - **压制型预设**且没开「仍然注入」→ 一个都不进（跟随预设）；
- *   - 域声明 `applicableTo` 说不成立的域不进（当前只有人设目录：会话深度超出了人设的
- *     `catalogDepth`，默认 1 = 只在顶层注入。**这不是"子会话不能委派"** —— 委派由官方
- *     决定，见 service.ts 里 `catalogDepth` 的注释）；
+ *   - 域声明 `applicableTo` 说不成立的域不进（**深度判据逐域写**：场景与记忆只在顶层
+ *     —— 它们说的是父会话的处境；人设目录则看会话深度有没有超出人设的 `catalogDepth`，
+ *     默认 1 = 只在顶层注入。**这都不是"子会话不能委派"** —— 委派由官方决定，
+ *     见 service.ts 里 `catalogDepth` 的注释）；
  *   - 有官方载体的两个域（提示词 / 技能目录）：预设挂得到官方那条行时不进
  *     —— 官方自己会送，再注入一遍只会重复；预设事实读不到（`undefined`）时按"已承载"处理
  *     （宁可与现状一致，也不制造重复）；

package/lib/context-inject.js

@@ -80,7 +80,7 @@ import { kindOfMessage, LIVE_KINDS, newestDomainTexts, officialKindsToSuppress,
 // subagents/{catalog,service}.ts 与契约测试都按这个路径引）。
 export { DEFAULT_INJECT_SETTINGS, DOMAIN_TOOL_PREFIX, INJECT_DOMAIN_KEYS, INJECT_KIND_OF, domainOfTool, isSubagentSession, subagentDepthOf, } from './context-inject-contract.js';
 export { explainInjections, normalizeInjectSettings, selectInjections, } from './context-inject-select.js';
-export { clearedDomainText, escapeFrameBody, renderDomainText } from './context-inject-frame.js';
+export { clearedDomainText, escapeFrameBody, HOW_NAMED_TOOLS, renderDomainText } from './context-inject-frame.js';
 export { officialKindsToSuppress } from './context-inject-surface.js';
 // B4：关域拦截的**顺序自检**。官方那两条注入行与本插件同挂在这条瀑布上，拦截成立的剩余前提是
 // "本插件排在它们上游"（本插件用 `{ prepend: true }` 把自己钉在钩子表最前，所以真正还依赖的
@@ -370,8 +370,9 @@ export function createContextInjector(deps) {
             const published = new Set();
             // 域声明按 key 索引：来源文件（`files`）只在真要发消息时取，所以要能从这里回查声明。
             const domainOf = new Map(domains.map((domain) => [domain.key, domain]));
-            // 工具表开关本步读一次（同步快照）：`how` 行里点名工具的那几句据此换话术。
-            const hiddenNow = deps.hiddenTools !== undefined ? deps.hiddenTools() : null;
+            // `how` 行点名工具的那几句据本步的快照换话术。按 agent 取：全局开关之外，
+            // 人设的工具限制也会让工具不在手里，而那份名单逐 agent 不同。
+            const hiddenNow = deps.hiddenTools !== undefined ? deps.hiddenTools(agent) : null;
             const toolHidden = hiddenNow === null ? () => false : (name) => hiddenNow.has(name);
             for (const section of sections) {
                 published.add(section.key);

package/lib/exports/transcript.js

@@ -0,0 +1,223 @@
+// 会话转录导出：把宿主的 SessionEvent[] 提成可再导入的转录文本。
+//
+// 从 src/index.ts 剥出来（0.18.5），同时补上两件事：
+//
+// 1. **按块类型取文本**。宿主的内容块是带 type 标签的联合（dsh-llm types.d.ts:114-122）：
+//    `text` 是用户可见正文，`reasoning` 是思考，`tool-call` 是模型发起的调用。此前导出走
+//    `extractText`，它只判「这个对象有没有 text 字段」—— 而 `ReasoningBlock` 恰好就是
+//    `{type:'reasoning', text}`，所以**思考一直混在助手正文里导出去**。同一类缺陷 0.16.x
+//    已在子智能体侧用 `textOfBlocks` 修过（persona-parse.ts:275），导出侧是它的第二个出口。
+// 2. **导出分三档，且是累进的**：正文 → 另加工具 → 再加思考。每档都是上一档的超集，
+//    所以一个下拉就说得清（两个独立勾选框是另一种答案，用户不要）。
+//    三档仍是**可读转录，不是完整备份**：每块有上限并明说截断，token 统计与压缩结构不在里面。
+//
+// `extractText` 本身不动：它服务的是外部文件导入，那份宽松是故意的（外来转录稿没有
+// `reasoning` 词表可守）。
+import { textOfBlocks } from '../subagents/persona-parse.js';
+// 上限是**病态保护**：工具结果可以是一次几 MB 的文件读取，不设限的话一个会话就能
+// 导出上百 MB。取最靠前的那一段 —— 工具输出的头部几乎总是最有用的那部分。
+const REASONING_MAX = 6000;
+const TOOL_INPUT_MAX = 1000;
+const TOOL_RESULT_MAX = 2000;
+/** 裁到 max 个字符并留下标记。标记固定英文：op 跑在服务端，没有客户端词典可用。 */
+function cap(text, max) {
+    const s = String(text || '');
+    if (s.length <= max)
+        return s;
+    return `${s.slice(0, max)}\n[truncated: showing ${max} of ${s.length} chars]`;
+}
+function str(value) {
+    return typeof value === 'string' ? value : '';
+}
+function blocksOf(content) {
+    return Array.isArray(content) ? content : [];
+}
+function formatBytes(n) {
+    const v = Number(n);
+    if (!Number.isFinite(v) || v < 0)
+        return 'unknown size';
+    if (v < 1024)
+        return `${v} B`;
+    if (v < 1024 * 1024)
+        return `${Math.round(v / 1024)} KB`;
+    return `${(Math.round((v / 1024 / 1024) * 10) / 10).toFixed(1)} MB`;
+}
+/** 附件只报名字 / 类型 / 尺寸 / 字节数 —— `attachmentId` 官方定义为不透明串，进了转录稿只是噪声。 */
+function attachmentLines(content) {
+    const lines = [];
+    for (const block of blocksOf(content)) {
+        const ref = (block.attachment && typeof block.attachment === 'object' ? block.attachment : {});
+        if (block.type === 'image') {
+            const media = str(ref.mediaType) || 'image';
+            const w = Number(ref.width);
+            const h = Number(ref.height);
+            const dims = Number.isFinite(w) && Number.isFinite(h) ? ` ${w}×${h}` : '';
+            const name = str(ref.name);
+            lines.push(`image: ${name ? name + ' — ' : ''}${media}${dims} (${formatBytes(ref.bytes)})`);
+        }
+        else if (block.type === 'file') {
+            lines.push(`file: ${str(ref.name) || '(未命名)'} (${formatBytes(ref.bytes)})`);
+        }
+    }
+    return lines.join('\n');
+}
+function toolLabel(name, kind, failed = false) {
+    return `Tool: ${name} — ${kind}${failed ? ' (failed)' : ''}`;
+}
+/**
+ * 把会话事件提成导出用的轮次。
+ *
+ * 工具的**发起**在两处都有记录：`assistant/message` 里的 `tool-call` 块（模型可见真相），
+ * 与 log-only 的 `tool/call` 事件（持久化记录）。两边都收、按 call id 去重 —— 只认一边
+ * 会在某种宿主形状下静默丢掉全部工具调用，而"导出里看不见工具调用"正是这份文件此前的毛病。
+ * 配不上任何调用的 `tool/result` 也照样单独成段，同样不静默丢。
+ */
+export function extractExportTurns(events, detail) {
+    const wantTools = detail !== 'simple';
+    const wantThinking = detail === 'full';
+    const turns = [];
+    const namesByCallId = new Map();
+    const emittedCallIds = new Set();
+    let current = null;
+    const flush = () => {
+        // 空正文 + 空附加段 = 这一轮什么都没有，不占位。
+        if (current && (current.text || current.details.length))
+            turns.push(current);
+        current = null;
+    };
+    /** 工具细节总归属于助手轮；正文已经翻篇时就另起一轮。 */
+    const openAssistant = () => {
+        if (!current || current.role !== 'assistant') {
+            flush();
+            current = { role: 'assistant', text: '', details: [] };
+        }
+        return current;
+    };
+    for (const event of events || []) {
+        if (!event || typeof event !== 'object')
+            continue;
+        const e = event;
+        const data = (e.data && typeof e.data === 'object' ? e.data : {});
+        if (e.type === 'user/message') {
+            flush();
+            const turn = { role: 'user', text: textOfBlocks(data.content, 'text'), details: [] };
+            // 附件跟工具一起进中间档：它是「对话里出现过什么」的一部分，不是「模型想了什么」。
+            if (wantTools) {
+                const attachments = attachmentLines(data.content);
+                if (attachments)
+                    turn.details.push({ label: 'Attachment', text: attachments });
+            }
+            current = turn;
+            continue;
+        }
+        if (e.type === 'assistant/message') {
+            flush();
+            const message = (data.message && typeof data.message === 'object' ? data.message : {});
+            const turn = { role: 'assistant', text: textOfBlocks(message.content, 'text'), details: [] };
+            // 顺序即模型产出的顺序：先思考、后调用。两档都开时（full）这个次序天然成立，
+            // 因为 full 必然也开 wantTools。
+            if (wantThinking) {
+                const reasoning = textOfBlocks(message.content, 'reasoning');
+                if (reasoning)
+                    turn.details.push({ label: 'Thinking', text: cap(reasoning, REASONING_MAX) });
+            }
+            if (wantTools) {
+                for (const block of blocksOf(message.content)) {
+                    if (block.type !== 'tool-call')
+                        continue;
+                    const id = str(block.id);
+                    const name = str(block.name) || '(unnamed)';
+                    if (id) {
+                        namesByCallId.set(id, name);
+                        emittedCallIds.add(id);
+                    }
+                    turn.details.push({ label: toolLabel(name, 'in'), text: cap(str(block.arguments), TOOL_INPUT_MAX) });
+                }
+            }
+            current = turn;
+            continue;
+        }
+        // 往下只剩工具与结果两类事件，中间档就要，只有简洁档跳过。
+        if (!wantTools)
+            continue;
+        if (e.type === 'tool/call') {
+            const id = str(data.callId);
+            const name = str(data.name) || namesByCallId.get(id) || '(unnamed)';
+            if (id)
+                namesByCallId.set(id, name);
+            // assistant 块里已经列过同一个调用，就别重复成段。
+            if (id && emittedCallIds.has(id))
+                continue;
+            if (id)
+                emittedCallIds.add(id);
+            openAssistant().details.push({ label: toolLabel(name, 'in'), text: cap(str(data.arguments), TOOL_INPUT_MAX) });
+            continue;
+        }
+        if (e.type === 'tool/result') {
+            const message = (data.message && typeof data.message === 'object' ? data.message : {});
+            const id = str(message.toolCallId);
+            const name = namesByCallId.get(id) || '(unknown)';
+            const failed = message.isError === true;
+            const body = textOfBlocks(message.content, 'text');
+            const blocks = blocksOf(message.content);
+            openAssistant().details.push({
+                label: toolLabel(name, 'out', failed),
+                text: cap(body || (blocks.length ? `(无文本输出，${blocks.length} 个内容块)` : '(无输出)'), TOOL_RESULT_MAX),
+            });
+            // `error` 官方注释明说它在模型可见消息之外 —— 带工具的那两档是用户唯一能看到它的地方。
+            const err = (data.error && typeof data.error === 'object' ? data.error : undefined);
+            if (err) {
+                const reason = str(err.reason) || str(err.code) || str(err.name);
+                if (reason)
+                    openAssistant().details.push({ label: toolLabel(name, 'error'), text: cap(`${str(err.name)}/${str(err.code)} — ${reason}`, TOOL_RESULT_MAX) });
+            }
+            continue;
+        }
+    }
+    flush();
+    return turns;
+}
+/**
+ * 把载荷整段缩进 4 空格。
+ *
+ * 这是**回流保护**，不是排版：工具结果可以是任意文件内容，读进一份 markdown 转录稿就会把
+ * 里面的 `## User` 原样吐进助手正文，再导入时把轮次劈开。缩进同时废掉 `HEADING_RE` 与
+ * `BOLD_PREFIX_RE` 两个行首锚点（两者都不允许前导空白）。空行保持真空，不留尾随空格。
+ */
+function indentBlock(text) {
+    return String(text || '')
+        .split('\n')
+        .map((line) => (line.trim() ? `    ${line}` : ''))
+        .join('\n');
+}
+/**
+ * 序列化为可再导入的转录文本：Codex 风格 Markdown 或 Claude Code 风格 JSONL。
+ *
+ * 签名与 0.18.5 之前一致 —— 附加信息全在 `turn.details` 里，所以 `details` 为空时两种输出
+ * 与旧版逐字节相同。`## User` / `### Assistant` 两级标题不能改：导入侧靠它切轮次与嗅探格式。
+ */
+export function serializeTranscript(turns, format) {
+    const list = Array.isArray(turns) ? turns : [];
+    if (format === 'jsonl') {
+        // content 保持**字符串**：改成类型化块数组的话，导入侧的 extractText 会把 reasoning
+        // 又拼回正文（正是我们在修的那个泄漏），并让 tool-call 无声消失 —— 严格劣于字符串。
+        return list
+            .map((turn) => {
+            let content = turn.text;
+            for (const item of turn.details)
+                content += `${content ? '\n\n' : ''}[${item.label}]\n${item.text}`;
+            return JSON.stringify({ type: turn.role, message: { role: turn.role, content } });
+        })
+            .join('\n');
+    }
+    return list
+        .map((turn) => {
+        const head = turn.role === 'user' ? '## User' : '### Assistant';
+        const blocks = [turn.text ? `${head}\n${turn.text}` : head];
+        // 四级标题：`#{1,3}` 匹配不到，所以附加段再导入时只会并入所属轮次，不会伪装成边界。
+        for (const item of turn.details)
+            blocks.push(`#### ${item.label}\n${indentBlock(item.text)}`);
+        return blocks.join('\n\n');
+    })
+        .join('\n\n');
+}

package/lib/index.js

@@ -30,7 +30,7 @@ import { runStateDoctor } from './ops/state-doctor.js';
 import { createSubagentService, decideToolFilter, defaultPersonasDir } from './subagents/service.js';
 import { createSubagentCatalog } from './subagents/catalog.js';
 import { createSkillCatalog } from './skills/catalog.js';
-import { createContextInjector, subagentDepthOf, } from './context-inject.js';
+import { createContextInjector, HOW_NAMED_TOOLS, subagentDepthOf, } from './context-inject.js';
 import { isApprovalNever } from './approval-policy.js';
 import { DEFAULT_HIDDEN_TOOLS, FACTORY_TOOL_TABLE_PRESET, normalizeToolTableSettings, } from './tools/table.js';
 import { createToolTableSwitch } from './tool-table-switch.js';
@@ -70,41 +70,13 @@ import { buildMemoryTools } from './tools/memory.js';
 import { buildSceneTools } from './tools/scene.js';
 import { buildSubagentTools } from './tools/subagent.js';
 import { createScenePromptSync } from './scene-prompt-sync.js';
-import { extractText } from './imports/parsers.js';
+import { extractExportTurns, serializeTranscript } from './exports/transcript.js';
 import { spawn } from 'node:child_process';
 import { mkdir, readdir, readFile, rm, stat, unlink, writeFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 // ---------------------------------------------------------------------------
-// Transcript export helpers — mirror the import parsers (src/imports/parsers.js)
-// so an exported file can be imported back losslessly. Pure Node, no ctx.
+// Transcript export lives in src/exports/transcript.ts (0.18.5).
 // ---------------------------------------------------------------------------
-/** 从会话事件数组提取用户/助手纯文本轮次（与导入解析器对称）。 */
-function extractTurnsFromEvents(events) {
-    const turns = [];
-    for (const ev of events || []) {
-        if (!ev || typeof ev !== 'object')
-            continue;
-        const e = ev;
-        let content;
-        if (e.type === 'user/message')
-            content = e.data && e.data.content;
-        else if (e.type === 'assistant/message')
-            content = e.data && e.data.message && e.data.message.content;
-        else
-            continue;
-        const text = extractText(content).trim();
-        if (text)
-            turns.push({ role: e.type === 'user/message' ? 'user' : 'assistant', text });
-    }
-    return turns;
-}
-/** 序列化为可再导入的转录文本：Codex 风格 Markdown 或 Claude Code 风格 JSONL。 */
-function serializeTurns(turns, format) {
-    if (format === 'jsonl') {
-        return turns.map((t) => JSON.stringify({ type: t.role, message: { role: t.role, content: t.text } })).join('\n');
-    }
-    return turns.map((t) => (t.role === 'user' ? '## User\n' : '### Assistant\n') + t.text).join('\n\n');
-}
 /**
  * `inject` 的服务名清单（单一来源）：既声明给宿主，也是「挂载心跳」与 doctor 核对的内容。
  *
@@ -652,6 +624,35 @@ export default {
             }
             return out;
         };
+        /**
+         * `how` 行点名过的工具里，**这个 agent 手里没有**的那些（注入器每步同步问一次）。
+         *
+         * 两条路并起来，缺一条框架文本就会说谎：
+         *   ① `toolTableHidden()` —— 兼容页「模型工具表」的全局开关。**必须留着**：它读的是设置
+         *      本身，与"限制层装没装上"无关（可见性的重放有 300ms 去抖，只问可见性会有一个窗口漏报）。
+         *   ② `tools.get(name, agent)` —— 拿 agent 当 scope 问"它解析得到这个名字吗"，与
+         *      `carrierHiddenToolsFor` 同一套官方写法。这一条覆盖**人设的工具限制**：
+         *      `decideToolFilter` 算出的 allow/deny 由官方在子代理启动时 `tools.restrict` 装到那个
+         *      scope 上（`dsh-subagent/lib/index.js:522`），全局开关表里看不到它 —— 于是人设砍掉
+         *      `skill_manager_read` 之后，技能目录照注、`how` 行照样点名一个模型手里没有的工具。
+         *      拿不到 agent 时跳过：`get(name, undefined)` 问的是**全局视图**，会得出相反结论。
+         */
+        const howHiddenToolsFor = (agent) => {
+            const hidden = new Set(toolTableHidden());
+            if (agent === null || (typeof agent !== 'object' && typeof agent !== 'function'))
+                return hidden;
+            const scope = agent;
+            for (const name of HOW_NAMED_TOOLS) {
+                if (hidden.has(name))
+                    continue;
+                try {
+                    if (tools.get(name, scope) === undefined)
+                        hidden.add(name);
+                }
+                catch { /* 读不到 = 按还在手里算 */ }
+            }
+            return hidden;
+        };
         // ---------- 注入通道（场景 / 记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
         // 这些文本以前是 systemPrompt 段（persona complete 会整段压掉）。现在改走官方的
         // 「每步注入一条合成消息」通道（skill-catalog / AGENTS.md / 时间上下文同款）：
@@ -701,23 +702,23 @@ export default {
                     // 子智能体 → 提示词。form 是宿主语义轴：记忆是「当前状态」（snapshot，后发取代先发），
                     // 三个目录是 catalog，提示词是 instructions（与官方 AGENTS.md 那条行同一形态）。
                     //
-                    // `applicableTo`（2026-09-17 方案 A）：子智能体域按"**目录该不该注入到这么深的
-                    // 会话**"（人设的 `catalogDepth`，默认 1 = 只在顶层注入）判断，**不是**"能不能
-                    // 委派"。委派可行性由官方决定：`dsh-tool-subagent` 默认 `maxDepth: 3`，provider
-                    // 只在传了该值时才校验，所以子代理本来就能继续嵌套（用户实测确认）。此前判据叫
-                    // "还有没有委派预算"、语义是"还能不能委派"，那是错的 —— 详见 service.ts 里
-                    // `catalogDepth` 字段的注释。目录正文也按同一个判据过滤（`text(agent)`），两处同源
-                    // 所以不会分叉。
+                    // 深度判据（`applicableTo`）**逐域写在域声明上**，三个域各一条，语义都**不是**"能不能
+                    // 委派"。委派可行性由官方决定：`dsh-tool-subagent` 默认 `maxDepth: 3`，provider 只在
+                    // 传了该值时才校验，所以子代理本来就能继续嵌套（用户实测确认）。此前判据叫"还有没有
+                    // 委派预算"、语义是"还能不能委派"，那是错的 —— 详见 service.ts 里 `catalogDepth` 的注释。
+                    //   · 场景与记忆：**恒为"只在顶层"**。这两段说的是**父会话的处境**（此刻在哪个场景、
+                    //     这个场景下攒了什么），子代理要什么由父代理写进委派说明；记忆本体又是几 KB 的
+                    //     常驻文本，子代理真有需要可以自己用 `memory_manager_*` 取。放它们进子会话，
+                    //     子代理的上下文就不再收敛为「角色 + 任务」。（0.19.0 中途有一版把这两条放开到
+                    //     所有深度，已回退。）
+                    //   · 子智能体目录：人设的 `catalogDepth`（默认 1 = 只在顶层）—— 它问的是"**目录该不该
+                    //     注入到这么深的会话**"，与"这个域要不要注入"是两件事。目录正文也按同一判据过滤
+                    //     （`text(agent)`），两处同源所以不会分叉。
+                    //   · MCP / 技能 / 提示词：不分深度。
                     //
-                    // 场景与记忆（2026-09-17 用户裁定；2026-09-23 拆成两个域）：**都只在顶层注入**。
-                    // 记忆是"父会话的现场"，不是子代理完成任务所需的事实 —— 塞进一次性子会话只会与
-                    // 角色定义争注意力（实测：子代理跑审查时，上下文里同时躺着人设与整份记忆）。
-                    // 场景段同理：它说的是"父会话现在处在哪个模式"，而子代理根本没有"模式"可言。
-                    // 子代理手里有 `memory_manager_list/read` 与 `scene_manager_save`，需要什么自己取；
-                    // 父代理上下文里也有，相关事实应当由它写进 `task`（子代理的上下文 = 角色 + 任务）。
-                    // 其余三域对任何深度都成立：提示词是用户规则（本插件的立身之本就是"覆盖到子代理"）、
-                    // 技能目录与 MCP 状态是"操作这台机器所需的事实"（子代理手里就有 `skill` / `mcp__*`
-                    // 工具，不知道清单就只能瞎调）。
+                    // 同一张 `domains` 表管着六个域的开关，没有按会话分流的第二张表 —— 那张
+                    // `subagentDomains` 已删：人设身份在官方机制里取不到（descriptor 是字段白名单、
+                    // 冷恢复只还原 provider/model/effort）。
                     domains: () => [
                         // 场景（**框架**）：启用的场景 + 场景说明（用户的约定）。排第一 —— 先让模型知道
                         // "现在在哪个场景、这个场景的约定是什么"，再读下面的记忆条目。
@@ -738,7 +739,7 @@ export default {
                     ],
                     settings: () => injectSettingsSync(),
                     // 工具表开关：`how` 行里点名工具的那几句要跟着它换话术（关掉的不点名）。
-                    hiddenTools: toolTableHidden,
+                    hiddenTools: howHiddenToolsFor,
                     factsFor: (agent) => candidates.presetFactsForAgent(agent),
                     // 令牌门禁（2026-09-19，用户裁定「宿主侧硬拦截」）：令牌**在生效**（`TOKEN !== ''`，
                     // 关掉或没配都是空串）而本次启动还没有人验过 ⇒ 这一步不放行，宿主把 turn 收成
@@ -1427,6 +1428,11 @@ export default {
         // 实现在 ./scenes/candidates.ts（2026-09-19 从本闭包 10 段抽出，约 260 行）。
         // 放在这里而不是更早：它要 mcp（读停用表）与 toolKeyParts（416 行的 const），
         // 而唯一在更早处引用它的地方（注入 deps 的 factsFor）是箭头函数，调用发生在之后。
+        // 本插件注册过的工具名。**唯一**可靠的"插件工具"判据：官方没有工具级归属接口
+        // （`ToolSchema` 无归属字段、`ToolRuntime` 公开面无来源、`tools/change` 无载荷），
+        // 但自己注册了什么自己当然知道。登记点在下面 `toolDeps.register`（2115 行那个漏斗，
+        // 六个域的构建器全部经它），所以不可能漂移 —— 新增工具自动进集合，不用维护前缀表。
+        const selfToolNames = new Set();
         const candidates = createCandidates({
             get: (name) => ctx.get(name),
             tools,
@@ -1434,6 +1440,9 @@ export default {
             skillsService,
             memoriesService,
             toolKeyParts,
+            // 传 getter 而不是快照：登记发生在 apply 过程中（本行之后 600 余行），
+            // 而这个工厂现在就要构造完。
+            selfToolNames: () => selfToolNames,
         });
         // 提示词预设域的 op 表。单独提出来是为了让**模型工具**能复用同一份判定：
         // `prompt_manager_list` 以前直调 `promptsService.list()`，于是它报的「生效中」是
@@ -1534,8 +1543,8 @@ export default {
                 quickPromptsDir,
                 rulesList: (args) => memoriesService.ops['rules-list'](args),
                 skillDetail: (args) => skillsService.ops['skill-detail'](args),
-                extractTurnsFromEvents,
-                serializeTurns,
+                extractTurnsFromEvents: extractExportTurns,
+                serializeTurns: serializeTranscript,
             }),
             // rules 域里要走「场景 ↔ 全局基线同步」包装的四个写 op（ops/scene-sync.ts 提供）。
             // 必须排在 ...memoriesService.ops 之后 —— 这里是显式覆盖同名 op，不是新增。
@@ -2117,7 +2126,11 @@ export default {
             defineTool,
             // 量体积只认**注册成功**的那些（注册失败的域工具本来就不在模型工具表里）——
             // 兼容页「模型工具表」块的分组与 ≈token 都取自这里，那是这份设置唯一的数字来源。
-            register: (def) => { recordToolSize(def); tools.register(def); },
+            //
+            // 同一行里登记 `selfToolNames`：六个域的构建器全部经这个漏斗，所以它就是"本插件注册了
+            // 哪些工具"的权威清单。`tools.register` 抛（重名 / 保留名）时不登记 —— 那份不在表里，
+            // 也不该出现在「工具限制」的候选里。
+            register: (def) => { recordToolSize(def); tools.register(def); selfToolNames.add(String(def.name)); },
             lockedSceneGuard,
             syncSwitchToScene,
             // 错误句里点名工具前要先问一句（判据与两个目录的 `listToolVisible` 同一份缓存）。

package/lib/ops/candidates.js

@@ -6,7 +6,7 @@ export function buildCandidateOps(deps) {
     return {
         // 人设表单的两个候选源之一（只读，均为「按需拉取」——不进 scene-inventory，避免每次开
         // 档案弹窗都枚举预设）。
-        // preset-tools：全体 Agent 预设工具名并集 + 各工具所属预设 + 当前会话是否可见。
+        // preset-tools：一行一个 Agent 预设，各带自己的工具清单与归属组（0.19.0 起不再返回全体并集）。
         // `unavailable` = 本插件自己没注册上的工具：工具列表接口是唯一按名字枚举工具的地方，
         // 注册失败只能在这里被如实回答。
         'preset-tools': async () => ({

package/lib/ops/sessions.js

@@ -205,9 +205,13 @@ export function buildSessionOps(deps) {
             if (!sessionId)
                 return { ok: false, error: '缺少 sessionId' };
             try {
-                const r = await registry.unarchiveSession(sessionId);
+                // 不接 registry 的返回值：官方 `unarchiveSession` 是 `Promise<void>`，而界面只要
+                // ok / error / workspace —— 每次单条恢复都把整个归档集合回传一遍纯属浪费。
+                // 0.18.5 之前这里读 `r.archivedSessionIds`，于是宿主恢复**成功之后**构造回执时抛
+                // TypeError，界面弹「操作失败」，用户以为没恢复、其实已经恢复了。
+                await registry.unarchiveSession(sessionId);
                 const workspace = await deps.restoreWorkspaceAccounting([sessionId]);
-                return { ok: true, archivedSessionIds: r.archivedSessionIds, ...(workspace ? { workspace } : {}) };
+                return { ok: true, sessionId, ...(workspace ? { workspace } : {}) };
             }
             catch (e) {
                 return { ok: false, error: deps.message(e) };
@@ -278,7 +282,8 @@ export function buildSessionOps(deps) {
             try {
                 const r = await registry.unarchiveSessions(parsed.target);
                 const workspace = await deps.restoreWorkspaceAccounting(r.unarchivedSessionIds || []);
-                return { ok: true, unarchivedSessionIds: r.unarchivedSessionIds, archivedSessionIds: r.archivedSessionIds, ...(workspace ? { workspace } : {}) };
+                // 只报「这次恢复了哪些」，不把整个归档集合快照发回界面（同上，界面不读它）。
+                return { ok: true, unarchivedSessionIds: r.unarchivedSessionIds, ...(workspace ? { workspace } : {}) };
             }
             catch (e) {
                 return { ok: false, error: deps.message(e) };
@@ -564,6 +569,8 @@ export function buildSessionOps(deps) {
         },
         // 把选中的归档会话导出为可再导入的转录文件（Markdown / JSONL），写入指定目录。
         // 每个会话一个文件；读不到正文的冷会话列入 skipped，不中断其余导出。
+        // `detail` 三档**累进**：`simple`（默认）只有正文；`tools` 另加工具调用与结果、附件名；
+        // `full` 再加思考。
         'history-export': async (args) => {
             const rawIds = (args && args.sessionIds) || [];
             const ids = Array.isArray(rawIds) ? rawIds.map((s) => String(s).trim()).filter(Boolean) : [];
@@ -572,6 +579,11 @@ export function buildSessionOps(deps) {
             const format = String((args && args.format) || 'markdown').toLowerCase();
             if (format !== 'markdown' && format !== 'jsonl')
                 return { ok: false, error: 'format 需为 markdown 或 jsonl' };
+            // 收到不认识的档位就出声：静默降级会让用户以为导出的是带工具的版本，而它其实只有正文。
+            const rawDetail = String((args && args.detail) || 'simple').toLowerCase();
+            if (rawDetail !== 'simple' && rawDetail !== 'tools' && rawDetail !== 'full')
+                return { ok: false, error: 'detail 需为 simple / tools / full' };
+            const detail = rawDetail;
             const outDir = String((args && args.outDir) || '').trim();
             if (!/^([A-Za-z]:[\\/]|\\\\|\/)/.test(outDir))
                 return { ok: false, error: '导出目录需为绝对路径' };
@@ -627,9 +639,13 @@ export function buildSessionOps(deps) {
                 const path = join(outDir, fileName);
                 try {
                     const events = await readEvents(sessionId);
-                    const turns = deps.extractTurnsFromEvents(events || []);
+                    const turns = deps.extractTurnsFromEvents(events || [], detail);
                     if (!turns.length) {
-                        skipped.push({ sessionId, error: events ? '会话中没有可导出的消息' : '无法读取会话内容（不在活动存储且无持久化句柄）' });
+                        // 简洁档现在**不含思考与工具**（0.18.5 之前思考被混在正文里），所以"只有思考没正文"
+                        // 的会话会第一次变成导不出来 —— 得说清楚是档位问题，不是内容丢了。
+                        skipped.push({ sessionId, error: !events ? '无法读取会话内容（不在活动存储且无持久化句柄）'
+                                : detail !== 'full' ? '会话中没有可导出的正文（思考与工具调用不计入本档 —— 换更高一档可以导出它们）'
+                                    : '会话中没有可导出的消息' });
                         continue;
                     }
                     // `'wx'`：绝不覆盖已存在的同名文件 —— 覆盖是静默的，用户会以为导出成功