@yfwu2020/dsh-selection-explain 0.10.3 → 0.10.5

package/lib/index.js

@@ -1,3694 +1,13 @@
-/**
- * @yfwu2020/dsh-selection-explain — host half（划词解读）。
- *
- * 为浏览器端的「划词解读」提供两个同源 HTTP 路由：
- *   POST /selection-explain/api/analyze   选中文字 + 上下文 → SSE 流式返回
- *                                         「专业中英翻译」与「语境含义详解」
- *   GET  /selection-explain/api/ping      健康检查：当前模型路由 + 限制（弹窗页脚用）
- *
- * 模型路由默认取 agentDefaultModel.currentSelection()（用户在设置里选的默认模型）；
- * 调用过一次真实 LLM 后，也会从 llm/stream 事件里捕获路由作为兜底。
- * 流式 text-delta 直接透传，前端边收边渲染，首字延迟 ≈ 模型首 token 时间。
- */
-import { createHash } from 'node:crypto';
-import { lookup } from 'node:dns/promises';
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join, resolve, sep } from 'node:path';
-import { createInterface } from 'node:readline';
-import { fileURLToPath } from 'node:url';
-import { BlockAssembler, createAssistantMessage, createSystemMessage, createToolResultMessage, createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
-import z from '@deepseek-ai/schemastery';
-// 提示词与写作规则（纯文本常量）单独成模块：本文件是 2400+ 行的 host 全量逻辑，
-// 提示词放这里既难找也容易误改。组装逻辑仍在下方（按 stage / kind 选一套）。
-import { CHAT_SYSTEM_PROMPT, CODE_PROMPT, DETAIL_PROMPT, TRANSLATION_PROMPT, } from './prompts.js';
-// 设置页的字段声明与校验：与 Config 一一对应，GET /settings 直接把 spec 发给客户端，
-// 客户端只负责画 —— 避免 UI 的边界和 host 的 clamp 各写一份、时间久了互相漂。
-import { buildSettingsPayload, normalizeSettingsPatch, normalizeStoredSettings, PERSISTED_SETTING_KEYS, SETTINGS_KEYS } from './settings.js';
-/** 插件名（= package.json name，客户端 bundle 的模块 id 也是它）。 */
-export const name = '@yfwu2020/dsh-selection-explain';
-/**
- * 升格时那条「上下文注入」消息的 `source.kind` —— 生产者**自有**的来源标识。
- *
- * 会话格式 v4 起（本机实测内核 0.2.0-rc.2），消息来源必须是生产者自报的 kind；
- * v3 那种 `plugin` 包装（`kind: 'plugin'` 配一个 `plugin` 字段）已经退役，会被
- * v4 准入当场拒掉：
- *   SessionFormatError: format v4 message requires a producer-owned source kind
- * 症状极具迷惑性：`↗ 升格` 的 HTTP 请求返回 `ok: true`（那时只写进了内存里的会话面），
- * 随后那轮 opener 运行失败、整个 artifact 一个字都没落盘 —— 新会话只剩表头。
- * 离线测试也照样全绿（校验发生在真实内核里，不在构建期），所以另配了
- * scripts/test-format.mjs 钉住这个 shape。
- *
- * 第三方插件的规范形态是 `plugin:<插件名>`：内核 v3→v4 迁移把那种 `plugin` 包装
- * 重写成 `plugin:<完整插件名>`（`producerKind()` 对不在同名表里的插件就是这么算的），
- * 所以这里写的与迁移结果逐字节一致 —— 新旧会话归因相同，且 v3 内核下同样合法
- * （直写的 kind 迁移时原样保留）。
- */
-export const PLUGIN_SOURCE_KIND = `plugin:${name}`;
-/** 路由注册与模型调用所需的服务。 */
-export const inject = ['webServer', 'llm'];
-/** 路由前缀。 */
-const API_PREFIX = '/selection-explain/api';
-/** 最新一次探针状态（进程集合变了才更新）。 */
-const micState = {
-    available: false,
-    capturing: false,
-    processes: [],
-    /** 不可用时的原因（not-macos / probe-missing / probe-failed / probe-exited）。 */
-    reason: '',
-};
-let micChild = null;
-/** 只尝试启动一次：失败就认（避免每个请求都去 spawn 一遍）。 */
-let micStarted = false;
-/** 最近一次有人来问探针的时间（用来判断"没人看了"）。 */
-let micLastUse = 0;
-/** "没人看就停"的检查定时器。 */
-let micIdleTimer = null;
-/**
- * 没人来问之后，探针还留多久（毫秒）。
- *
- * 为什么不立刻停：页面在"点一下别处"时会瞬间停轮询，立刻杀进程会变成反复 spawn/kill。
- * 留一段空转把这种抖动吸收掉；划词期间页面每 200ms 来问一次，探针自然不会到期。
- *
- * 为什么是 60 秒：让探针"热着"—— 你划词、看两眼、再划下一段，中间往往隔几十秒；
- * 探针还在的话，第二次划词是**零启动开销**（冷启动要 ~80ms 才出第一行）。
- * 代价是没人用之后进程多留一会儿，而它常驻只占 ~0.8% 单核，值。
- * 实际停止发生在超时后的下一次检查，所以真实寿命是 60~65 秒（见 MIC_IDLE_CHECK_MS）。
- */
-const MIC_IDLE_MS = Number(process.env.DSH_SEL_MIC_IDLE_MS || 60000);
-/** 空转检查的间隔（毫秒）。 */
-const MIC_IDLE_CHECK_MS = Number(process.env.DSH_SEL_MIC_CHECK_MS || 5000);
-/**
- * 探针的采样间隔（毫秒）—— 决定它多久发现"麦克风被打开了"。
- *
- * 为什么是 125：实测常驻成本极低（250ms → 0.6% 单核，150ms → 0.7%），
- * 而"按 Fn 到卡片弹出"的延迟里它是主要两项之一（另一项是页面轮询）。
- * 调快一倍的代价约 0.1% 单核，换来发现延迟减半 —— 值。
- * 原生探针会把区间夹在 50~5000ms 之间（见 native/mic-probe.c）。
- */
-const MIC_WATCH_MS = Number(process.env.DSH_SEL_MIC_WATCH_MS || 125);
-/** 探针路径：lib/native/mic-probe（与编译产物 lib/index.js 同级；测试可注入假的）。 */
-const MIC_PROBE = process.env.DSH_SEL_MIC_PROBE || fileURLToPath(new URL('native/mic-probe', import.meta.url));
-/**
- * 懒启动探针（第一次有人来问才 spawn）。
- *
- * 为什么不加载就启动：插件装着的绝大多数时间没人划词，没必要常驻一个每秒读几次
- * CoreAudio 的进程。第一次 GET /mic 时才起。
- * 起过之后**也不是一直留着**：见 armMicIdleCheck —— 没人来问就停，下次再起。
- */
-function ensureMicProbe() {
-    if (micStarted)
-        return;
-    micStarted = true;
-    if (process.platform !== 'darwin') {
-        micState.reason = 'not-macos';
-        return;
-    }
-    if (!existsSync(MIC_PROBE)) {
-        micState.reason = 'probe-missing';
-        return;
-    }
-    try {
-        const child = spawn(MIC_PROBE, ['--watch', String(MIC_WATCH_MS)], {
-            stdio: ['ignore', 'pipe', 'ignore'],
-        });
-        micChild = child;
-        micState.available = true;
-        micState.reason = '';
-        if (child.stdout) {
-            const lines = createInterface({ input: child.stdout });
-            lines.on('line', (line) => {
-                try {
-                    const parsed = JSON.parse(line);
-                    micState.capturing = !!parsed.capturing;
-                    micState.processes = Array.isArray(parsed.processes) ? parsed.processes : [];
-                }
-                catch {
-                    // 半行 / 坏行：丢掉，下一行会覆盖（探针每行都是完整状态）
-                }
-            });
-        }
-        child.on('error', () => {
-            micChild = null;
-            micState.available = false;
-            micState.capturing = false;
-            micState.processes = [];
-            micState.reason = 'probe-failed';
-        });
-        child.on('exit', () => {
-            micChild = null;
-            micState.available = false;
-            micState.capturing = false;
-            micState.processes = [];
-            micState.reason = 'probe-exited';
-        });
-    }
-    catch {
-        micChild = null;
-        micState.available = false;
-        micState.reason = 'probe-failed';
-    }
-}
-/**
- * 排一次"没人看就停"的检查（幂等）。
- *
- * 页面的轮询只在"有选区 / 卡片开着"时跑，探针跟着它的节奏走就够了 ——
- * 划词即启动，选区消失后再空转 MIC_IDLE_MS 就停，下次划词再起。
- */
-function armMicIdleCheck() {
-    if (micIdleTimer)
-        return;
-    micIdleTimer = setInterval(() => {
-        if (Date.now() - micLastUse < MIC_IDLE_MS)
-            return;
-        stopMicProbe();
-    }, MIC_IDLE_CHECK_MS);
-    if (typeof micIdleTimer.unref === 'function')
-        micIdleTimer.unref();
-}
-/**
- * 停掉探针（没人看了 / 插件卸载）。**下次有人来问会重新启动**。
- *
- * 注意 available 要跟着回落到 false：探针都停了，再报"正在录"就是过期数据 ——
- * 客户端看到 !available 会停掉轮询（不假装），这正是我们要的。
- */
-function stopMicProbe() {
-    if (micIdleTimer) {
-        clearInterval(micIdleTimer);
-        micIdleTimer = null;
-    }
-    // 允许下次重新启动（与"启动失败就认"不同：那是 spawn 失败，不该每个请求都重试）
-    micStarted = false;
-    micState.available = false;
-    micState.capturing = false;
-    micState.processes = [];
-    micState.reason = 'idle';
-    const child = micChild;
-    micChild = null;
-    if (!child)
-        return;
-    try {
-        child.kill();
-    }
-    catch {
-        // 已经退了：无所谓
-    }
-}
-/**
- * GET /selection-explain/api/mic
- *   → { ok, available, capturing, processes:[{pid,bundleId,name}], reason }
- *
- * 客户端只关心 `capturing` 和某个进程的 bundleId 是不是目标输入法；
- * 一次把所有占用者给全，是因为"同时在录的还有别的 App"很常见（会议软件、录音工具），
- * 只报第一个会让特性在那种情况下静默失效。
- */
-const handleMic = (req, res) => {
-    // 每次有人来问都续一次命：只要页面在轮询，探针就不会到期
-    micLastUse = Date.now();
-    ensureMicProbe();
-    armMicIdleCheck();
-    res.writeHead(200, {
-        'content-type': 'application/json; charset=utf-8',
-        'cache-control': 'no-store',
-    });
-    res.end(JSON.stringify({ ok: true, ...micState }));
-};
-/** 单次请求体上限（字节）。 */
-const BODY_LIMIT = 512 * 1024;
-/** 配置 schema（缺省值即推荐值）。 */
-export const Config = z.object({
-    provider: z.string().default(''),
-    model: z.string().default(''),
-    chatProvider: z.string().default(''),
-    chatModel: z.string().default(''),
-    reasoningEffort: z.string().default('high'),
-    /** 首轮单独一档：默认关闭思考，优先快速给出翻译、解读或注释。 */
-    translationReasoningEffort: z.string().default('off'),
-    /**
-     * 小窗对话历史（A′）：把整段对话落到插件自己的目录，重划同一个词直接回放。
-     * 0 = 关闭历史。只留最近 N 个「划词条目」（每个条目内含它自己的全部追问轮次）。
-     */
-    historyMaxEntries: z.number().min(0).max(500).default(20),
-    /** 采样温度。**默认 -1 = 不传**（交给供应商默认，与主会话一致）。0~2 之间才真的传。 */
-    temperature: z.number().min(-1).max(2).default(-1),
-    /**
-     * 单次调用的输出上限（tokens）。**默认 0 = 不限制** —— 不传这个参数，交给模型/供应商自己的上限。
-     *
-     * 为什么不默认给个数：这是**每次调用**的上限，联网检索后的答案经常要 2~4k tokens，
-     * 之前默认 1200 会让回答"悄悄截断在句子中间"（实测）；而给死一个更大的数也一样会在别的场景截断。
-     * 想限制（控成本/控时延）就填正数，仍然生效。
-     */
-    maxTokens: z.number().min(0).max(32000).default(0),
-    timeoutMs: z.number().min(5000).max(600000).default(300000),
-    maxSelectionChars: z.number().min(20).max(20000).default(4000),
-    maxContextChars: z.number().min(200).max(60000).default(12000),
-    maxRequestsPerMinute: z.number().min(1).max(600).default(40),
-    sessionContext: z.boolean().default(true),
-    sessionContextMaxMessages: z.number().min(1).max(200).default(24),
-    sessionContextFastMessages: z.number().min(1).max(200).default(8),
-    sessionContextMaxChars: z.number().min(0).max(2000000).default(0),
-    quoteContextRounds: z.number().min(0).max(10).default(1),
-    quoteContextMaxCharsPerTurn: z.number().min(200).max(20000).default(2000),
-    quoteContextMaxChars: z.number().min(400).max(100000).default(6000),
-    resultCacheTtlMs: z.number().min(0).max(86400000).default(600000),
-    tools: z.boolean().default(true),
-    /**
-     * 工具白名单（逗号分隔）。
-     *
-     * 默认改用 **free-search 插件**的工具（`advanced_search` / `platform_search`），不再用 `web_search`：
-     * 会话里的 `web_search` 是官方 DeepSeek 搜索（复用 @deepseek-ai/dsh-tool-web 的 schema），
-     * 而新装的 dsh-free-search 只注册了 advanced_search / platform_search / free_search_test ——
-     * 引擎更多（ddg/bing/searxng/anysearch/exa/tavily/keenable/firecrawl/parallel…）、失败自动换引擎、
-     * 还支持时间过滤与平台搜索。
-     */
-    toolNames: z.string().default('advanced_search,platform_search,read,grep,glob'),
-    /**
-     * **备用**工具清单：只在"首选里的联网工具一个都不在"时才补进来。
-     *
-     * 场景：没装 free-search 插件（或它没注册工具）时，会话里通常仍有官方 `web_search`；
-     * 不补的话小窗会变成完全不能联网。装了 free-search 就完全用不到这一项。
-     */
-    fallbackToolNames: z.string().default('web_search'),
-    maxToolRounds: z.number().min(0).max(8).default(2),
-    toolResultMaxChars: z.number().min(200).max(20000).default(3000),
-    toolReadRoot: z.string().default(''),
-    chatReasoningEffort: z.string().default('high'),
-    /**
-     * 侧边栏 HTML 预览里的划词桥。关掉就不往预览帧里注入桥脚本，
-     * 侧边栏网页里选中文字不会再弹「解读」。
-     */
-    bridgeSidebarPreview: z.boolean().default(true),
-    /** 悬浮胶囊开关（小窗设置页可改）。 */
-    pillEnabled: z.boolean().default(true),
-    /** 静置收球时长（毫秒）——默认 10 秒，见 Config 注释。 */
-    pillIdleMs: z.number().min(2000).max(600000).default(10000),
-    /** 空录音是否收起卡片（默认开，见 Config 注释）。 */
-    voiceCancelOnSilence: z.boolean().default(true),
-    /** 有字是否自动发送（默认开，见 Config 注释）。 */
-    voiceAutoSend: z.boolean().default(true),
-});
-/** 联网类工具名：用来判断"首选里的联网工具在不在"。 */
-const SEARCH_TOOL_NAMES = ['advanced_search', 'platform_search', 'web_search'];
-/**
- * 决定这一轮给模型哪些工具（纯函数，便于单测）。
- *
- * 规则：
- *   ① 首选清单里**确实存在**的直接放行；
- *   ② 如果首选里的**联网工具一个都不在**（例如没装 free-search 插件），
- *      就把备用清单里存在的补上 —— 否则小窗会变成完全不能联网；
- *   ③ 备用只补"联网"这一类，不会顺手把别的东西带进来。
- */
-function resolveToolNames(preferred, fallback, visible) {
-    const present = new Set(visible);
-    const out = preferred.filter((name) => present.has(name));
-    const hasSearch = preferred.some((name) => SEARCH_TOOL_NAMES.includes(name) && present.has(name));
-    if (!hasSearch) {
-        for (const name of fallback) {
-            if (name && present.has(name) && !out.includes(name))
-                out.push(name);
-        }
-    }
-    return out;
-}
-/** 写一条 SSE 事件。 */
-function sse(res, payload) {
-    if (res.writableEnded)
-        return;
-    try {
-        res.write(`data: ${JSON.stringify(payload)}\n\n`);
-    }
-    catch {
-        /* 客户端已断开 */
-    }
-}
-/** 返回一个 JSON 响应。 */
-/**
- * 把模型**内联在正文里**的思考块拆出来。
- *
- * 为什么要它：有的模型（实测 opencode-go 上的 minimax-m3 偶发）不走 reasoning 通道，
- * 而是把整段思考当正文吐出来，形如 `<think>The user wants…</think>`——
- * 不处理的话，用户看到的"答案"就是一大段思考（实测报过"输出错乱、把思考也输出了"）。
- *
- * 流式难点是标签可能被切成两块（"...<thi" + "nk>..."），所以没找到标签时**留一小截尾巴**再输出。
- */
-const THINK_TAGS = 'think|thinking|reasoning|analysis|scratchpad';
-const THINK_OPEN = new RegExp(`<(${THINK_TAGS})\\s*>`, 'i');
-const THINK_CLOSE = new RegExp(`</(${THINK_TAGS})\\s*>`, 'i');
-const THINK_TAIL = 24;
-function createThinkFilter() {
-    let buffer = '';
-    let inside = false;
-    const drain = (final) => {
-        let text = '';
-        let think = '';
-        for (;;) {
-            if (inside) {
-                const close = THINK_CLOSE.exec(buffer);
-                if (!close) {
-                    if (final) {
-                        think += buffer;
-                        buffer = '';
-                    }
-                    else if (buffer.length > THINK_TAIL) {
-                        think += buffer.slice(0, buffer.length - THINK_TAIL);
-                        buffer = buffer.slice(-THINK_TAIL);
-                    }
-                    break;
-                }
-                think += buffer.slice(0, close.index);
-                buffer = buffer.slice(close.index + close[0].length);
-                inside = false;
-                continue;
-            }
-            const open = THINK_OPEN.exec(buffer);
-            if (!open) {
-                if (final) {
-                    text += buffer;
-                    buffer = '';
-                }
-                else if (buffer.length > THINK_TAIL) {
-                    text += buffer.slice(0, buffer.length - THINK_TAIL);
-                    buffer = buffer.slice(-THINK_TAIL);
-                }
-                break;
-            }
-            text += buffer.slice(0, open.index);
-            buffer = buffer.slice(open.index + open[0].length);
-            inside = true;
-        }
-        return { text, think };
-    };
-    return {
-        push: (chunk) => {
-            buffer += chunk;
-            return drain(false);
-        },
-        flush: () => drain(true),
-    };
-}
-/**
- * 检测"思考被写进正文"的泄漏段。
- *
- * 实测 omen-alpha 在 `off` 档（上游 none）时不走 reasoning 通道，把整段英文推理当正文吐出来：
- * 「The user is asking which model I am. According to my instructions…我是 Omen Alpha。」
- * —— 这种文本**不带任何标签**，靠 `<think>` 过滤器抓不到，只能按"开头是自我盘算"来认。
- *
- * 保守三条件，缺一不裁（宁可留着，也不误删正文）：
- *   ① 逐句扫描，从开头起连续命中"元推理"句式；
- *   ② 命中段以英文为主（≥80% ASCII 字母）；
- *   ③ 剩下的正文里有中文（说明真正的答案是中文，被裁的不是答案）。
- */
-const META_SENTENCE = /^\s*(?:The user|The question|The request|The person|According to (?:my|the)|Based on (?:my|the)|Per (?:my|the)|My (?:instructions|system prompt|guidelines)|I (?:should|must|need|will|am asked|always|usually|will just)|So I|Thus I|Therefore I|Instructed to|Now I (?:have|need|know|see)|Let me (?:verify|check|think|see|confirm)|I have (?:the|a|enough)|First,? I|OK,? (?:I|let)|用户(?:问|要求)的?是|根据(?:我的)?(?:指令|系统提示)|我应该|我需要|按照(?:我的)?(?:指令|系统提示))/i;
-/**
- * 宽松判据：开头是**英文盘算**、后面才是**中文答案**。
- * 只用来"记住这个模型在关档会泄漏"（下次自动抬档），**不用来裁剪** ——
- * 裁错了会误删正文，而记错了只是下次少一个档位可选，代价不对称。
- */
-function looksLikeLeakedReasoning(text) {
-    const body = String(text || '');
-    if (body.length < 40)
-        return false;
-    const cut = body.search(/[\u4e00-\u9fff]/);
-    if (cut < 30)
-        return false;
-    const head = body.slice(0, cut);
-    const tail = body.slice(cut);
-    if (!/[\u4e00-\u9fff]/.test(tail))
-        return false;
-    const letters = head.replace(/[^A-Za-z]/g, '').length;
-    return letters / head.length >= 0.5;
-}
-/**
- * 设置页那四个格子（**规范档位**）。
- *
- * 它们不是发给模型的 id，而是一份"意图词汇"：关（尽量不思考）/ 低 / 高 / 最高。
- * 各 adapter 的档位词汇表并不统一 —— 本机 74 个模型上就数出七种：
- *   off>low>high>max ／ low>high>max ／ high>max ／ off>minimal>low>medium>high ／
- *   off>low>medium>high>xhigh>max ／ low>medium>high>xhigh ／ minimal>low>medium>high>xhigh ／
- *   max（只有一档）／ 一档都不声明（不支持推理）。
- * 落到哪个真实档位由 `mapEffortToModel` 算（纯函数，有单测）。
- */
-const EFFORT_CANONICAL = ['off', 'low', 'high', 'max'];
-/**
- * 档位名 → "思考深度"刻度（认 id，也认显示名；比较前会去掉空格/下划线/连字符并转小写）。
- *
- * 刻度只用来**比较深浅**，绝对数值没有意义。锚点取最常见的五档：off 0 / low 2 /
- * medium 4 / high 6 / max 8，其余名字插在它们之间（minimal 在 off 与 low 之间、
- * xhigh 在 high 与 max 之间）。认不出的名字不在这张表里 —— 由 `rankEfforts` 按位置插值。
- */
-const EFFORT_RANK = {
-    off: 0, none: 0, disabled: 0, no: 0, nocontext: 0,
-    minimal: 1, minimum: 1, least: 1, tiny: 1,
-    low: 2, light: 2,
-    mid: 3, moderate: 3,
-    medium: 4,
-    high: 6,
-    xhigh: 7, veryhigh: 7,
-    max: 8, maximum: 8, highest: 8,
-    ultra: 9, extreme: 9,
-};
-/** 归一化档位名：'X-High' / 'very high' / 'x_high' 都算一个东西。 */
-function normEffortName(value) {
-    return String(value ?? '')
-        .trim()
-        .toLowerCase()
-        .replace(/[\s_-]+/g, '');
-}
-/**
- * 每个声明档位的刻度：认得的名字用表，不认识的按**位置**在已知邻居之间线性插值
- * （两头都没有已知锚点时按序号平铺到 0..8）。最后钳成不递减 —— 各 adapter 的声明都是升序，
- * 插值不该把这个顺序弄反。
- */
-function rankEfforts(declared) {
-    const known = declared.map((item) => {
-        const byId = EFFORT_RANK[normEffortName(item.id)];
-        if (byId !== undefined)
-            return byId;
-        const byName = EFFORT_RANK[normEffortName(item.name)];
-        return byName === undefined ? null : byName;
-    });
-    const n = declared.length;
-    const ranks = [];
-    for (let i = 0; i < n; i += 1) {
-        const hit = known[i];
-        if (hit !== null && hit !== undefined) {
-            ranks.push(hit);
-            continue;
-        }
-        let left = -1;
-        for (let l = i - 1; l >= 0; l -= 1) {
-            if (known[l] !== null && known[l] !== undefined) {
-                left = l;
-                break;
-            }
-        }
-        let right = -1;
-        for (let r = i + 1; r < n; r += 1) {
-            if (known[r] !== null && known[r] !== undefined) {
-                right = r;
-                break;
-            }
-        }
-        const leftRank = left >= 0 ? known[left] : null;
-        const rightRank = right >= 0 ? known[right] : null;
-        if (leftRank !== null && rightRank !== null) {
-            ranks.push(leftRank + ((rightRank - leftRank) * (i - left)) / (right - left));
-        }
-        else if (leftRank !== null) {
-            ranks.push(leftRank + (i - left));
-        }
-        else if (rightRank !== null) {
-            ranks.push(rightRank - (right - i));
-        }
-        else {
-            ranks.push(n > 1 ? (8 * i) / (n - 1) : 0);
-        }
-    }
-    for (let i = 1; i < n; i += 1) {
-        if (ranks[i] < ranks[i - 1])
-            ranks[i] = ranks[i - 1];
-    }
-    return ranks;
-}
-/**
- * 规范四格 → 当前模型**真实声明**的档位（返回 '' 表示这个模型没有可发的档位）。
- *
- * 规则一条到底（对 `off>low>high>max` 这类 4 档模型恰好是恒等映射）：
- *   · 关   → 声明里**最弱**的那档（模型没有 off 这类档时，就是它"能关到"的最小思考）
- *   · 最高 → 声明里**最强**的那档
- *   · 低/高 → 在整条刻度上取 1/3、2/3 处**最近的档**；候选**排除两端**（最弱那档留给「关」、
- *     最强那档留给「最高」，四个格子于是各有落点），并保证 关 ≤ 低 ≤ 高 ≤ 最高 单调；
- *     同样近时「低」取更浅的、「高」取更深的 —— 低要省、高要深。
- *
- * ⚠️ 这里**没有**任何按模型写死的表：输入只有"这个模型自己声明的档位列表"。
- * 名字认得出来（off/low/high/max、minimal、xhigh…）就用名字的深度刻度；认不出来
- * （别的 adapter 可能叫 a/b/c、tier1/tier2，或者干脆是数字）就按**它在声明里的位置**插值 ——
- * 所以任何用户换任何模型都能落位，插件作者没见过那个模型也能映射。
- * 为什么不让「低/高」也去抢最弱那档：那两个格子表达的是"开着思考、但别太深"，
- * 落到"关"那一档等于**把用户要的思考关掉**；只有「关」该动那一档。
- * 只有一档可发时（如 kimi-k3 只有 max），四格都落到它 —— 模型没有别的选择。
- *
- * 返回 '' 表示"这个模型没有可发的档位"（声明为空），调用方据此**不带** reasoningEffort。
- */
-function mapEffortToModel(declared, canonical) {
-    const list = (declared ?? []).filter((item) => item && typeof item.id === 'string' && item.id.length > 0);
-    if (list.length === 0)
-        return '';
-    if (list.length === 1)
-        return list[0].id;
-    const slot = EFFORT_CANONICAL.includes(canonical) ? canonical : 'off';
-    const ranks = rankEfforts(list);
-    // 两端：按刻度取最浅/最深；同样深时**以声明顺序为准**（声明在前的那档更弱、在后的更强）。
-    // 不能只按下标取首尾：adapter 万一声明得不严格升序，按下标就选错了；也不能只按刻度取最大，
-    // 那样 `…>max>ultra` 这种"更强但刻度相同"的档会被 max 抢走。
-    let weakest = 0;
-    let strongest = 0;
-    for (let i = 1; i < list.length; i += 1) {
-        if (ranks[i] < ranks[weakest])
-            weakest = i;
-        if (ranks[i] >= ranks[strongest])
-            strongest = i;
-    }
-    if (slot === 'max')
-        return list[strongest].id;
-    if (slot !== 'low' && slot !== 'high')
-        return list[weakest].id;
-    const pool = [];
-    for (let i = 0; i < list.length; i += 1) {
-        if (i !== weakest && i !== strongest)
-            pool.push(i);
-    }
-    // 中间两档没人可选时（只有"最弱 + 最强"两档）：都落到最强 —— 最弱那档留给「关」
-    if (pool.length === 0)
-        return list[strongest].id;
-    const span = ranks[strongest] - ranks[weakest];
-    const target = ranks[weakest] + span * (slot === 'low' ? 1 / 3 : 2 / 3);
-    const preferDeeper = slot === 'high';
-    let best = pool[0];
-    let bestDistance = Math.abs(ranks[best] - target);
-    for (const index of pool) {
-        const distance = Math.abs(ranks[index] - target);
-        const closer = distance < bestDistance;
-        const tie = distance === bestDistance;
-        if (closer || (tie && (preferDeeper ? ranks[index] > ranks[best] : ranks[index] < ranks[best]))) {
-            best = index;
-            bestDistance = distance;
-        }
-    }
-    return list[best].id;
-}
-/**
- * 一个模型的四格映射（设置页给用户看的就是它；请求时也走这份算）。
- * 返回空串的格子表示"没有可发的档位"（模型不支持推理时四个格子都是空串）。
- */
-function effortMapOf(declared) {
-    const out = {};
-    for (const slot of EFFORT_CANONICAL)
-        out[slot] = mapEffortToModel(declared, slot);
-    return out;
-}
-/**
- * 清单里查不到这个模型时的兜底阶梯。
- * 只列**最常见**的四档（与客户端 `FALLBACK_TIERS` 同一份）：多出来的 `medium` 很多模型
- * 并不声明，而 dsh-llm 对"声明里没有的档"是**直接抛错**（不 clamp）—— 兜底时不该去撞它。
- */
-const EFFORT_LADDER_FALLBACK = ['off', 'low', 'high', 'max'];
-/** 档位的中文名（notice 文案用，与客户端 TIER_LABEL 一致）。 */
-const EFFORT_LABEL = { off: '关', low: '低', medium: '中', high: '高', max: '最大' };
-/**
- * 这条上游错误是不是"**我们发的这个档位**不被接受"。
- *
- * ⚠️ 判据必须窄。免费/预览端点的上游会**偶发**返回
- * `Reasoning is mandatory for this endpoint and cannot be disabled.` ——
- * 2026-10-09 实测（`opencode-go/step-5-preview-free`，交错发送排除时间漂移）：
- *   · effort=low 成功 5/8；effort=high 成功 5/8 —— **同一档位时好时坏，档位不是变量**；
- *   · 对照模型 `longcat-2.5-preview-free` 6/6 成功（连 off 都收）。
- * 所以只认"明确说这个档位无效"的措辞；"必须开推理"另有一条判据
- * （见 looksLikeReasoningRequired，只在**我们发的是关档**时才算数）。
- * 把偶发失败当成"档位不支持"会连锁出三个错：给用户一句错诊断、把失败永久记进
- * noOffRoutes（以后再也不发这个档）、清掉用户选的档位。
- */
-function looksLikeUnsupportedTier(message) {
-    const tier = '(?:reasoning|effort|thinking|推理|思考|档位?)';
-    const bad = '(?:unsupported|not\\s+support|invalid|unrecognized|不支持|无效|不认识)';
-    return (new RegExp(`${bad}[^。\\n]{0,24}${tier}`, 'i').test(message) ||
-        new RegExp(`${tier}[^。\\n]{0,24}${bad}`, 'i').test(message));
-}
-/** 上游要求"必须开推理"——只有在**我们这次把推理关掉**（发的 off）时，这句才是冲我们来的。 */
-function looksLikeReasoningRequired(message) {
-    return (/(?:reasoning|thinking|推理|思考)/i.test(message) &&
-        /(?:mandatory|required|must|cannot\s+be\s+disabled|必须|不能(?:被)?关闭|不可关闭)/i.test(message));
-}
-/**
- * 换一个"没试过的"档位（重试用）。
- *
- * 为什么**绝不能省略档位**（老代码就是省略）：省略 = 请求里不带 reasoning，
- * 对"必须开推理"的端点等于把推理关掉 —— 实测 20 次这样的重试 **0 次成功**，
- * 而同一档位首发成功率约 60%。省略比"发一个可能不被接受的档"更糟。
- *
- * 顺序：模型自己声明的 defaultEffort → 沿档位阶梯往上走一格（离"关"越远越安全）。
- * 返回空串表示"没档位可换了"，调用方就不重试。
- */
-function pickNextEffort(declared, defaultEffort, rejected, tried) {
-    const usable = (id) => !!id && id !== rejected && !tried.has(id);
-    if (usable(defaultEffort))
-        return defaultEffort;
-    // 用**模型自己的声明顺序**（各 adapter 都是从最省到最深），"往上走一格"才落在它真实的下一档上。
-    // 老写法是"我方五档阶梯 ∩ 声明"，看不见 minimal / xhigh / none 这类 id —— 而按刻度映射之后，
-    // 被拒的那个很可能正是这类 id（indexOf 得到 -1 → 退回最弱的那档，方向正好反了）。
-    const order = declared.length > 0 ? declared : EFFORT_LADDER_FALLBACK;
-    const start = order.indexOf(rejected);
-    // ① 先往上走：离「关」越远越安全（不吃 off 的模型通常都吃更高的档）
-    for (let i = (start < 0 ? 0 : start + 1); i < order.length; i += 1) {
-        const id = order[i];
-        if (usable(id))
-            return id;
-    }
-    // ② 再按"通常最稳"的顺序退（模型拒的是 max 时往上没得走，该退到 high，而不是退回 off ——
-    //    off 恰恰是最容易被拒的那一档）
-    for (const id of ['high', 'medium', 'low', 'max', 'off']) {
-        if (order.includes(id) && usable(id))
-            return id;
-    }
-    // ③ 兜底：声明里剩下的
-    for (const id of order)
-        if (usable(id))
-            return id;
-    return '';
-}
-function splitLeakedReasoning(text) {
-    const body = String(text || '');
-    if (body.length < 40)
-        return { prefix: '', rest: body };
-    // 注意：不能用 split(/(?<=[.。!！?？])\s*/) —— 它会把句末空白吃掉，
-    // 于是拼回来的 prefix 与真正流出去的正文差一个空格，客户端 indexOf 匹配不上（实测踩过）。
-    // 这里保留分隔符本身，保证 parts.join('') === body。
-    const parts = body.match(/[^.。!！?？]*[.。!！?？]\s*|[^.。!！?？]+$/g) ?? [body];
-    // 从句首开始，连续吃"不含中文的句子"作为泄漏段。
-    // 为什么不是"必须命中元推理句式"：实测泄漏段里会夹着 "Previously I said something incorrect … — that was wrong."
-    // 这种自述句，逐句匹配元句式会在这里断掉、只裁掉前半段。结构判据（英文盘算 + 中文答案）更稳。
-    // 但仍然要求：整段里**至少有一句**命中元推理句式，避免把"英文开头的正常回答"误裁。
-    let index = 0;
-    let ascii = 0;
-    let metaHit = false;
-    while (index < parts.length && !/[\u4e00-\u9fff]/.test(parts[index])) {
-        if (META_SENTENCE.test(parts[index]))
-            metaHit = true;
-        ascii += (parts[index].match(/[A-Za-z]/g) || []).length;
-        index += 1;
-    }
-    if (index === 0 || !metaHit)
-        return { prefix: '', rest: body };
-    const head = parts.slice(0, index).join('');
-    const tail = parts.slice(index).join('');
-    if (!tail.trim())
-        return { prefix: '', rest: body }; // 整篇都是盘算：不裁（可能是模型只说了这些）
-    const letters = head.replace(/[^A-Za-z]/g, '').length;
-    if (head.length > 0 && letters / head.length < 0.5)
-        return { prefix: '', rest: body };
-    if (!/[\u4e00-\u9fff]/.test(tail))
-        return { prefix: '', rest: body };
-    return { prefix: head, rest: tail };
-}
-function sendJson(res, status, body) {
-    const text = JSON.stringify(body);
-    res.writeHead(status, {
-        'content-type': 'application/json; charset=utf-8',
-        'content-length': Buffer.byteLength(text),
-        'cache-control': 'no-store',
-    });
-    res.end(text);
-}
-/** 读取请求体（带长度上限）。 */
-function readBody(req, limit) {
-    return new Promise((resolve, reject) => {
-        let size = 0;
-        const chunks = [];
-        req.on('data', (chunk) => {
-            size += chunk.length;
-            if (size > limit) {
-                reject(new Error('请求体过大'));
-                req.destroy();
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-        req.on('error', reject);
-    });
-}
-/** 截断到指定字符数（保留省略标记）。 */
-function clampText(raw, max) {
-    const text = typeof raw === 'string' ? raw.trim() : '';
-    return text.length > max ? `${text.slice(0, max)}\n…（已截断）` : text;
-}
-// ────────────────────────────── 语音输入（小窗麦克风） ──────────────────────────────
-//
-// 小窗的追问输入框加一个麦克风：录一段话 → 转成文字**插进输入框**（不是直接发送，
-// 识别错了还能改）。转写这条链路在 host 这一侧收口：
-//
-//   GET  ${API_PREFIX}/speech            识别服务目录 + 就绪状态（客户端据此决定麦克风能不能点）
-//   POST ${API_PREFIX}/speech/transcribe 一段 16kHz 单声道 PCM16 WAV（base64）→ 文字
-//   POST ${API_PREFIX}/speech/prepare    显式准备本地识别模型（首次要下载，必须用户点头）
-//
-// 为什么不让浏览器自己去连识别服务：音频、provider 选择、模型路径全部留在 host，
-// 客户端只拿到"一段话的文字"；而且**音频不落盘、不进会话**（转写完即丢）。
-// 识别服务（@deepseek-ai/dsh-experimental-speech-to-text）是实验性的、可以不装：
-// 拿不到该服务就整条链路优雅降级（目录接口回 available:false，麦克风点了只给一句解释）。
-/** 单次录音时长上限（秒）：到了就自动收尾去识别，不让用户对着麦克风发呆。 */
-const SPEECH_MAX_SECONDS = 60;
-/** 单条音频的字节上限（≈ 2 分钟 16kHz 单声道 PCM16）；与识别服务默认的 4MB 对齐。 */
-const SPEECH_MAX_BYTES = 4 * 1024 * 1024;
-/** 识别请求体上限：base64 会膨胀 4/3，再留点余量给 JSON 外壳。 */
-const SPEECH_BODY_LIMIT = Math.ceil(SPEECH_MAX_BYTES / 3) * 4 + 4096;
-/** 单次识别的等待上限（毫秒）：真机上 60 秒音频几秒内就回来了，这是兜底。 */
-const SPEECH_TIMEOUT_MS = 120_000;
-/**
- * 校验客户端送上来的音频是不是**规范**的 16kHz 单声道 PCM16 WAV。
- *
- * 为什么抠得这么死：这个格式是浏览器端编码器（MediaRecorder → decodeAudioData →
- * OfflineAudioContext 重采样 → 手写 WAV 头）唯一会产出的形状。逐字段对齐之后，
- * "音频不对"就只剩两种可能——客户端版本对不上、或者有人手工构造了这个请求。
- * 光看二进制长度不算数：头里写的采样率/声道/位深必须是那一套，否则识别服务会按
- * 错误的采样率解释这段音频（听起来像快放/慢放），识别结果自然全错。
- *
- * @param audio 完整音频字节
- * @param maxSeconds 允许的最长时长
- * @returns 时长（秒）
- */
-export function validateWave(audio, maxSeconds) {
-    if (audio.length < 46 ||
-        audio.toString('ascii', 0, 4) !== 'RIFF' ||
-        audio.toString('ascii', 8, 12) !== 'WAVE' ||
-        audio.toString('ascii', 12, 16) !== 'fmt ' ||
-        audio.readUInt32LE(16) !== 16 ||
-        audio.readUInt16LE(20) !== 1 || // PCM
-        audio.readUInt16LE(22) !== 1 || // 单声道
-        audio.readUInt32LE(24) !== 16000 || // 16kHz
-        audio.readUInt32LE(28) !== 32000 || // 字节率 = 16000 × 1ch × 2B
-        audio.readUInt16LE(32) !== 2 || // 块对齐
-        audio.readUInt16LE(34) !== 16 || // 16 bit
-        audio.toString('ascii', 36, 40) !== 'data' ||
-        audio.readUInt32LE(4) !== audio.length - 8 ||
-        audio.readUInt32LE(40) !== audio.length - 44 ||
-        (audio.length - 44) % 2 !== 0) {
-        throw new Error('音频格式不是 16kHz 单声道 PCM16 WAV');
-    }
-    const seconds = (audio.length - 44) / 32000;
-    if (seconds <= 0)
-        throw new Error('录音是空的');
-    if (seconds > maxSeconds)
-        throw new Error(`录音超过 ${maxSeconds} 秒`);
-    return seconds;
-}
-/**
- * 「网页模式」的设计规范：从插件自带的 `skills/web-design/SKILL.md` 读（按 mtime 缓存）。
- *
- * 做成文件而不是写死在代码里：改规范不用重新构建，用户也能自己替换成喜欢的版本。
- * 读不到就退回一段精简规则（宁可少讲，也不能让请求挂掉）。
- */
-let designSkillCache = { at: 0, path: '', text: '' };
-const DESIGN_SKILL_FALLBACK = [
-    '单列、宽度 100%、不要横向滚动；不引外部资源；一套主题（别深浅混用）。',
-    '主标题 20–22px、正文 14px、行高 1.6–1.75；一个主色 + 中性灰阶。',
-    '只在内容真是序列时才编号；避免"什么内容都套同一张圆角卡片"这类模板感。',
-].join('\n');
-/** 模块级读文件失败时的告警（host 侧 logger 在 apply 里拿不到，走 console）。 */
-function ctxLoggerWarn(message) {
-    try {
-        console.warn(`[dsh-selection-explain] ${message}`);
-    }
-    catch {
-        /* noop */
-    }
-}
-async function loadDesignSkill() {
-    const path = fileURLToPath(new URL('../skills/web-design/SKILL.md', import.meta.url));
-    try {
-        const info = await stat(path);
-        if (designSkillCache.path === path && designSkillCache.at === info.mtimeMs && designSkillCache.text) {
-            return designSkillCache.text;
-        }
-        const raw = await readFile(path, 'utf8');
-        // 去掉 frontmatter，只把规则喂给模型
-        const body = raw.replace(/^---[\s\S]*?---\s*/, '').trim();
-        designSkillCache = { at: info.mtimeMs, path, text: body };
-        return body;
-    }
-    catch (error) {
-        ctxLoggerWarn(`读取设计规范失败（${path}）：${String(error?.message ?? error)}`);
-        return DESIGN_SKILL_FALLBACK;
-    }
-}
-/**
- * 粗略判断"是不是公网地址"，口径与 dsh-web-fetch-http 的 SSRF 防护一致（非 unicast 一律拒绝）。
- *
- * 为什么要这个：本机若跑着 TUN/fake-IP 代理（DNS 服务器是 198.18.0.2 这类），所有域名都会
- * 解析进 198.18.0.0/15 保留段 → web_fetch 每次都秒失败（"resolves to a non-public IP address"），
- * 而那个防护**没有配置开关**。与其让模型白跑一轮，不如探测出来直接不给它这个工具。
- */
-function isPublicAddress(address) {
-    const value = String(address || '').trim();
-    if (!value)
-        return false;
-    if (value.indexOf(':') >= 0) {
-        const lower = value.toLowerCase();
-        if (lower === '::1' || lower === '::')
-            return false;
-        if (/^f[cd][0-9a-f]{2}:/.test(lower))
-            return false;
-        if (/^fe[89ab][0-9a-f]:/.test(lower))
-            return false;
-        return true;
-    }
-    const parts = value.split('.').map((part) => Number(part));
-    if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255))
-        return false;
-    const a = parts[0];
-    const b = parts[1];
-    const c = parts[2];
-    if (a === 0 || a === 10 || a === 127)
-        return false;
-    if (a === 100 && b >= 64 && b <= 127)
-        return false;
-    if (a === 169 && b === 254)
-        return false;
-    if (a === 172 && b >= 16 && b <= 31)
-        return false;
-    if (a === 192 && (b === 168 || b === 0))
-        return false;
-    if (a === 198 && (b === 18 || b === 19))
-        return false; // 198.18.0.0/15 基准测试段 ← fake-IP 落这里
-    if (a === 198 && b === 51 && c === 100)
-        return false;
-    if (a === 203 && b === 0 && c === 113)
-        return false;
-    if (a >= 224)
-        return false;
-    return true;
-}
-/** 本机能否真正抓取网页（结果缓存 5 分钟，探测失败则不动它）。 */
-let fetchProbe = { at: 0, usable: true, sample: '' };
-async function webFetchUsable() {
-    if (Date.now() - fetchProbe.at < 300_000)
-        return fetchProbe;
-    try {
-        const addresses = await lookup('example.com', { all: true });
-        const usable = addresses.length > 0 && addresses.every((entry) => isPublicAddress(entry.address));
-        fetchProbe = { at: Date.now(), usable, sample: addresses.map((entry) => entry.address).join(', ') };
-    }
-    catch {
-        fetchProbe = { at: Date.now(), usable: true, sample: '' };
-    }
-    return fetchProbe;
-}
-/**
- * 路径是否落在允许的根目录里（root 为空 = 不设限）。
- *
- * 为什么需要它：read/grep/glob 能读**用户有权读的任何文件**（`~/.ssh/id_rsa`、`.env`、
- * `~/.dsh/settings.yaml`……），而划词的触发源（选中文字/上下文/搜索结果）可能是别人写的。
- * 这里只做词法判断（`resolve` 不跟随符号链接），挡住"顺着一段被注入的文字去读项目外的机密"。
- */
-export function isInsideRoot(root, target) {
-    if (!root)
-        return true;
-    const raw = String(target ?? '').trim();
-    if (!raw)
-        return true;
-    // `~` 一律拒：要么指向家目录（多数情况下在项目外），要么后端根本不展开
-    if (raw === '~' || raw.startsWith('~/') || raw.startsWith('~\\'))
-        return false;
-    const base = resolve(root);
-    const full = resolve(base, raw);
-    return full === base || full.startsWith(base.endsWith(sep) ? base : base + sep);
-}
-/** 文件类工具：这些工具的参数里有 path，需要过边界检查。 */
-const FS_TOOL_NAMES = ['read', 'grep', 'glob'];
-/** 工具调用的人类可读描述（给前端状态栏用）。 */
-function describeToolCall(name, args) {
-    const record = (args ?? {});
-    // command 也要认：bash 这类工具没有 query/url，不认的话摘要里只剩「bash」两个字
-    const raw = record.query ??
-        record.queries ??
-        record.q ??
-        record.url ??
-        record.prompt ??
-        record.command ??
-        record.file_path ??
-        record.path ??
-        record.pattern;
-    const query = Array.isArray(raw) ? raw[0] : raw;
-    return typeof query === 'string' ? query.slice(0, 120) : name;
-}
-/** 从工具结果里抽出：文本长度 / 预览 / 链接（前端只用它拼追问摘要，**不渲染**）。 */
-function digestToolResult(content) {
-    const text = content
-        .map((block) => (block.type === 'text' ? block.text : ''))
-        .join('\n')
-        .trim();
-    const urls = [];
-    const matches = text.match(/https?:\/\/[^\s<>"')\]]+/g) ?? [];
-    for (const raw of matches) {
-        const url = raw.replace(/[.,;:)\]}]+$/, '');
-        if (!urls.includes(url))
-            urls.push(url);
-        if (urls.length >= 5)
-            break;
-    }
-    return { chars: text.length, preview: text.slice(0, 600), urls };
-}
-/** 执行一个工具并把结果压成模型可读的内容块（带长度上限）。 */
-async function runTool(ctx, name, args, signal, maxChars, agent) {
-    const registry = ctx.get('tools');
-    if (typeof registry?.execute !== 'function') {
-        return { content: [{ type: 'text', text: '（工具不可用）' }], isError: true };
-    }
-    try {
-        const result = await registry.execute({
-            callId: `sel-tool-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-            name,
-            arguments: args,
-            signal,
-            ...(agent ? { agent } : {}),
-        });
-        const blocks = Array.isArray(result.content) ? result.content : [];
-        let used = 0;
-        const clamped = [];
-        for (const block of blocks) {
-            if (block.type !== 'text')
-                continue;
-            const remain = maxChars - used;
-            if (remain <= 0)
-                break;
-            const text = block.text.length > remain ? `${block.text.slice(0, remain)}
-…（已截断）` : block.text;
-            used += text.length;
-            clamped.push({ type: 'text', text });
-        }
-        if (clamped.length === 0)
-            clamped.push({ type: 'text', text: '（工具没有返回文本内容）' });
-        return { content: clamped, isError: result.isError === true };
-    }
-    catch (error) {
-        return { content: [{ type: 'text', text: `工具执行失败：${String(error?.message ?? error)}` }], isError: true };
-    }
-}
-/**
- * `createSystemMessage` 的**跨版本兼容调用**。
- *
- * 这个函数的签名在两个版本间不一样，而两份类型都得能编译通过：
- *   · **0.1.5-rc.3**（npm 上按 peer 范围 `>=0.1.5-rc <2` 解析到的就是它，CI 的构建校验用的这份）：
- *     `createSystemMessage(text, plugin)` —— 两个都必填，少传一个直接 TS2554（发布被卡过一次）；
- *   · **0.1.7-rc.x**（本机/新运行时）：`createSystemMessage(text)` —— 第二参数是历史遗留，传了会被忽略。
- *
- * 所以这里把它当"接受可选第二参数"的函数来调：两个版本都编译得过，运行时也都正确
- * （旧版正好拿到它想要的"组装这段提示词的插件名"，新版直接忽略）。
- */
-const systemMessageOf = createSystemMessage;
-/** 请求里带的会话 id（空串 = 客户端没取到）。 */
-function sessionIdOf(body) {
-    return typeof body.sessionId === 'string' ? body.sessionId.trim() : '';
-}
-/** 空白归一化（用于在会话记录里定位选中文字）。 */
-function normalizeSpace(text) {
-    return text.replace(/\s+/g, ' ').trim();
-}
-/** 从消息 content 里取纯文本（只取 text 块；工具调用/结果不进来，避免噪音挤占预算）。 */
-function messageText(content) {
-    if (!Array.isArray(content))
-        return '';
-    const parts = [];
-    for (const block of content) {
-        if (!block || typeof block !== 'object')
-            continue;
-        const typed = block;
-        if (typed.type === 'text' && typeof typed.text === 'string')
-            parts.push(typed.text);
-    }
-    return parts.join('\n').trim();
-}
-/**
- * 把会话的当前模型界面整理成「会话背景」文本。
- *
- * 只保留**真实对话**：用户真正发的话（source.kind === 'user'）与助手回复的正文。
- * 三类内容一律剔除，否则会把有效窗口挤没（实测：430 条 surface 事件里绝大多数是
- * 工具调用/结果，且 harness 注入的 system-reminder 单条可达 1.2 万字）：
- *   - tool/result 与纯工具调用的助手步骤（无正文）
- *   - system/message（系统提示词）
- *   - source.kind !== 'user' 的用户角色消息（运行环境快照、skill 目录等 harness 注入）
- */
-export function transcriptOf(events, options) {
-    const entries = [];
-    for (const event of events) {
-        if (!event || typeof event !== 'object')
-            continue;
-        const typed = event;
-        const data = (typed.data ?? {});
-        let role = '';
-        let content;
-        if (typed.type === 'user/message') {
-            if (data.source && data.source.kind !== 'user')
-                continue; // harness 注入的上下文
-            role = '用户';
-            content = data.content;
-        }
-        else if (typed.type === 'assistant/message') {
-            role = '助手';
-            content = data.message?.content;
-        }
-        else {
-            continue;
-        }
-        const text = messageText(content);
-        if (!text)
-            continue;
-        entries.push({ role, text, marked: false });
-    }
-    const needle = normalizeSpace(options.marker);
-    let marked = false;
-    if (needle.length >= 2) {
-        for (const entry of entries) {
-            if (normalizeSpace(entry.text).includes(needle)) {
-                entry.marked = true;
-                marked = true;
-            }
-        }
-    }
-    // 窗口 = 选中文字所在的那条消息 **向上** 数 maxMessages 条（含它自己），
-    // 之后的对话不进背景；找不到选中位置时退回「最近 maxMessages 条」。
-    // 默认不截断（maxChars = 0）：消息整条进背景，不做单条/总量裁剪。
-    let anchorIndex = -1;
-    if (marked) {
-        for (let i = entries.length - 1; i >= 0; i -= 1) {
-            if (entries[i]?.marked) {
-                anchorIndex = i;
-                break;
-            }
-        }
-    }
-    const endIndex = anchorIndex >= 0 ? anchorIndex : entries.length - 1;
-    const startIndex = Math.max(0, endIndex - options.maxMessages + 1);
-    const picked = entries.slice(startIndex, endIndex + 1).map((entry) => ({ ...entry }));
-    // 可选总量上限（配置里显式设 >0 时才生效）：超了就丢更早的消息
-    if (options.maxChars > 0) {
-        let used = picked.reduce((sum, entry) => sum + entry.text.length, 0);
-        while (picked.length > 1 && used > options.maxChars) {
-            const dropped = picked.shift();
-            used -= dropped ? dropped.text.length : 0;
-        }
-        for (const entry of picked) {
-            if (entry.text.length > options.maxChars)
-                entry.text = `${entry.text.slice(0, options.maxChars)}…`;
-        }
-    }
-    if (picked.length === 0)
-        return { transcript: '', marked: false };
-    const omitted = Math.max(0, entries.length - picked.length);
-    if (omitted > 0)
-        picked.unshift({ role: '提示', text: `（选中位置之前还有 ${omitted} 条更早的消息，未包含）`, marked: false });
-    const transcript = picked.map((entry) => `${entry.marked ? '▶ ' : '  '}${entry.role}：${entry.text}`).join('\n');
-    return { transcript, marked: picked.some((entry) => entry.marked) };
-}
-/** 在文本里找到引用文字并套上【】（直接找不到就按"空白等价"再找一次）。 */
-function markQuoteInText(text, marker) {
-    if (!text || !marker)
-        return text;
-    const at = text.indexOf(marker);
-    if (at >= 0)
-        return `${text.slice(0, at)}【${marker}】${text.slice(at + marker.length)}`;
-    // 归一化后匹配：把引用按空白切开，逐段允许任意空白（选中文字常与消息原文差在换行/缩进）
-    const tokens = marker.split(/\s+/).filter(Boolean).map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
-    if (tokens.length === 0)
-        return text;
-    try {
-        const hit = new RegExp(tokens.join('\\s+')).exec(text);
-        if (hit && typeof hit.index === 'number') {
-            return `${text.slice(0, hit.index)}【${hit[0]}】${text.slice(hit.index + hit[0].length)}`;
-        }
-    }
-    catch {
-        /* 正则构造失败（极端输入）：不标记，客户端会把原文另起一段补上 */
-    }
-    return text;
-}
-/** 围绕引用截断长消息（引用本身必须留下；找不到引用就从头截）。 */
-function clampAroundQuote(text, marker, max) {
-    if (text.length <= max)
-        return text;
-    const at = marker ? text.indexOf(marker) : -1;
-    if (at < 0)
-        return `${text.slice(0, max)}…（已截断）`;
-    const half = Math.max(0, Math.floor((max - marker.length) / 2));
-    const from = Math.max(0, at - half);
-    const to = Math.min(text.length, at + marker.length + half);
-    return `${from > 0 ? '…' : ''}${text.slice(from, to)}${to < text.length ? '…' : ''}`;
-}
-/**
- * **引用上下文**：引用文字所在的那一组对话 ± N 组（一组 = 一条用户消息 + 它的助手回复）。
- *
- * 与 `transcriptOf`（解读用的会话背景）的区别，两条都是为引用量身定的：
- *   ① 窗口是**锚点两侧** —— 引用常常是"上面那句"和"下面那句"的对照，只有上文不够；
- *   ② 按**轮**取整 —— 上下各至少一整组（用户消息 + AI 回复），不会切在半个回合上。
- * 噪音过滤与 `transcriptOf` 完全一致（工具调用/结果、系统提示、harness 注入一律不进）。
- */
-export function quoteContextOf(events, marker, options = {}) {
-    const roundsAround = Math.max(0, options.roundsAround ?? 1);
-    const maxCharsPerTurn = Math.max(200, options.maxCharsPerTurn ?? 2000);
-    const maxChars = Math.max(400, options.maxChars ?? 6000);
-    const entries = [];
-    for (const event of events) {
-        if (!event || typeof event !== 'object')
-            continue;
-        const typed = event;
-        const data = (typed.data ?? {});
-        let role = '';
-        let content;
-        if (typed.type === 'user/message') {
-            if (data.source && data.source.kind !== 'user')
-                continue;
-            role = '用户';
-            content = data.content;
-        }
-        else if (typed.type === 'assistant/message') {
-            role = '助手';
-            content = data.message?.content;
-        }
-        else {
-            continue;
-        }
-        const text = messageText(content);
-        if (!text)
-            continue;
-        entries.push({ role, text, marked: false });
-    }
-    if (entries.length === 0)
-        return { transcript: '', matched: false, rounds: 0 };
-    const needle = normalizeSpace(marker);
-    let anchor = -1;
-    if (needle.length >= 2) {
-        for (let i = entries.length - 1; i >= 0; i -= 1) {
-            if (normalizeSpace(entries[i]?.text ?? '').includes(needle)) {
-                anchor = i;
-                break;
-            }
-        }
-    }
-    if (anchor < 0)
-        return { transcript: '', matched: false, rounds: 0 };
-    // 按"轮"分组：一条用户消息开一轮（它之前的助手消息归上一轮）
-    const roundOf = [];
-    let round = -1;
-    for (const entry of entries) {
-        if (entry.role === '用户' || round < 0)
-            round += 1;
-        roundOf.push(round);
-    }
-    const anchorRound = roundOf[anchor] ?? 0;
-    const fromRound = Math.max(0, anchorRound - roundsAround);
-    const toRound = Math.min(round, anchorRound + roundsAround);
-    const picked = [];
-    for (let i = 0; i < entries.length; i += 1) {
-        const r = roundOf[i] ?? 0;
-        if (r < fromRound || r > toRound)
-            continue;
-        const entry = entries[i];
-        const isAnchor = i === anchor;
-        const raw = isAnchor ? markQuoteInText(entry.text, marker) : entry.text;
-        picked.push({
-            role: entry.role,
-            text: clampAroundQuote(raw, marker, maxCharsPerTurn),
-            marked: isAnchor,
-        });
-    }
-    // 总量上限：超了先丢最早的几组，再丢引用之后的几组（**引用所在那条永远保留**）
-    let used = picked.reduce((sum, entry) => sum + entry.text.length, 0);
-    let droppedBefore = 0;
-    let droppedAfter = 0;
-    while (picked.length > 1 && used > maxChars && picked[0] && !picked[0].marked) {
-        const first = picked.shift();
-        droppedBefore += 1;
-        used -= first ? first.text.length : 0;
-    }
-    while (picked.length > 1 && used > maxChars && picked[picked.length - 1] && !picked[picked.length - 1]?.marked) {
-        const last = picked.pop();
-        droppedAfter += 1;
-        used -= last ? last.text.length : 0;
-    }
-    if (droppedBefore > 0)
-        picked.unshift({ role: '提示', text: `（引用之前还有 ${droppedBefore} 条消息，未包含）`, marked: false });
-    if (droppedAfter > 0)
-        picked.push({ role: '提示', text: `（引用之后还有 ${droppedAfter} 条消息，未包含）`, marked: false });
-    const transcript = picked.map((entry) => `${entry.role}：${entry.text}`).join('\n');
-    return { transcript, matched: true, rounds: toRound - fromRound + 1 };
-}
-/** 注册路由、解析模型路由、转发 LLM 流。 */
-export function apply(ctx, rawConfig) {
-    const config = {
-        provider: rawConfig?.provider ?? '',
-        model: rawConfig?.model ?? '',
-        chatProvider: rawConfig?.chatProvider ?? '',
-        chatModel: rawConfig?.chatModel ?? '',
-        reasoningEffort: rawConfig?.reasoningEffort ?? 'high',
-        translationReasoningEffort: rawConfig?.translationReasoningEffort ?? 'off',
-        historyMaxEntries: rawConfig?.historyMaxEntries ?? 20,
-        temperature: rawConfig?.temperature ?? -1,
-        maxTokens: rawConfig?.maxTokens ?? 0,
-        timeoutMs: rawConfig?.timeoutMs ?? 300000,
-        maxSelectionChars: rawConfig?.maxSelectionChars ?? 4000,
-        maxContextChars: rawConfig?.maxContextChars ?? 12000,
-        maxRequestsPerMinute: rawConfig?.maxRequestsPerMinute ?? 40,
-        sessionContext: rawConfig?.sessionContext ?? true,
-        sessionContextMaxMessages: rawConfig?.sessionContextMaxMessages ?? 24,
-        sessionContextFastMessages: rawConfig?.sessionContextFastMessages ?? 8,
-        sessionContextMaxChars: rawConfig?.sessionContextMaxChars ?? 0,
-        quoteContextRounds: rawConfig?.quoteContextRounds ?? 1,
-        quoteContextMaxCharsPerTurn: rawConfig?.quoteContextMaxCharsPerTurn ?? 2000,
-        quoteContextMaxChars: rawConfig?.quoteContextMaxChars ?? 6000,
-        resultCacheTtlMs: rawConfig?.resultCacheTtlMs ?? 600000,
-        tools: rawConfig?.tools ?? true,
-        toolNames: rawConfig?.toolNames ?? 'advanced_search,platform_search,read,grep,glob',
-        fallbackToolNames: rawConfig?.fallbackToolNames ?? 'web_search',
-        maxToolRounds: rawConfig?.maxToolRounds ?? 2,
-        toolResultMaxChars: rawConfig?.toolResultMaxChars ?? 3000,
-        toolReadRoot: rawConfig?.toolReadRoot ?? '',
-        chatReasoningEffort: rawConfig?.chatReasoningEffort ?? 'high',
-        bridgeSidebarPreview: rawConfig?.bridgeSidebarPreview ?? true,
-        pillEnabled: rawConfig?.pillEnabled ?? true,
-        pillIdleMs: rawConfig?.pillIdleMs ?? 10000,
-        voiceCancelOnSilence: rawConfig?.voiceCancelOnSilence ?? true,
-        voiceAutoSend: rawConfig?.voiceAutoSend ?? true,
-    };
-    /**
-     * 出厂默认值（**不含**用户在设置页改过的部分）。
-     *
-     * 为什么单独留一份：设置页的「恢复默认」要能把值写回这里，
-     * 而"这一项改过没有"也要拿它对比 —— 只有一个 config 的话，改完就再也说不出原值是什么。
-     * 注意它取的是 rawConfig（cordis.patch.yml 里的配置），所以 yml 里写过的值也算"默认"：
-     * 用户在设置页恢复默认，应该回到 yml 写的那个数，而不是硬编码的出厂数。
-     */
-    const configDefaults = { ...config };
-    /**
-     * 设置页写入的覆盖值（**只存改过的键**）。
-     *
-     * 落盘在插件自己的目录（与 history.json / pill.json 同级），不碰 cordis.patch.yml：
-     * 那个文件是**装配清单**，让 UI 去改它既容易写坏结构，也要重启才生效。
-     * 这里的内存值即刻生效（下方所有 config.x 都是每次请求现读的），落盘只为跨重启保留。
-     */
-    let settingsOverrides = {};
-    let settingsLoaded = false;
-    let settingsTimer = null;
-    const settingsFile = () => join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'settings.json');
-    /**
-     * 把覆盖值套用到 config 上。
-     *
-     * 只接受 SETTINGS_KEYS 里的键，并且**类型必须与默认值一致** ——
-     * 文件是手工可编辑的（也可能被旧版本写坏），不能让它把 boolean 写成字符串，
-     * 那会让 `if (config.tools)` 这种判断悄悄变成永真。
-     */
-    function applyOverrides(patch) {
-        const target = config;
-        for (const [key, value] of Object.entries(patch)) {
-            if (!SETTINGS_KEYS.includes(key) && !PERSISTED_SETTING_KEYS.includes(key))
-                continue;
-            if (typeof value !== typeof configDefaults[key])
-                continue;
-            target[key] = value;
-        }
-    }
-    /** 读设置覆盖文件（进程内只读一次，与 loadHistory / loadPillPos 同节奏）。 */
-    async function loadSettings() {
-        if (settingsLoaded)
-            return;
-        settingsLoaded = true;
-        try {
-            const parsed = JSON.parse(await readFile(settingsFile(), 'utf8'));
-            const raw = parsed?.values;
-            if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
-                const values = normalizeStoredSettings(raw);
-                settingsOverrides = values;
-                applyOverrides(values);
-            }
-        }
-        catch {
-            // 没存过 / 坏了都当作"没改过"：出厂默认本来就是可用状态，没必要因此报错
-            settingsOverrides = {};
-        }
-    }
-    /** 落盘（防抖：拖数字输入框会连发多次，没必要每次都写文件）。 */
-    function scheduleSettingsWrite() {
-        if (settingsTimer)
-            clearTimeout(settingsTimer);
-        settingsTimer = setTimeout(() => {
-            settingsTimer = null;
-            void (async () => {
-                try {
-                    await mkdir(join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain'), { recursive: true });
-                    await writeFile(settingsFile(), JSON.stringify({ version: 1, values: settingsOverrides }, null, 0), 'utf8');
-                }
-                catch (error) {
-                    ctx.logger?.warn?.(`[${name}] 写入设置失败：${String(error?.message ?? error)}`);
-                }
-            })();
-        }, 300);
-        settingsTimer.unref?.();
-    }
-    /** 当前生效值（按 spec 的键序取，客户端可以直接对比 defaults 判断改过没有）。 */
-    function currentSettings() {
-        const target = config;
-        const values = {};
-        for (const key of SETTINGS_KEYS)
-            values[key] = target[key];
-        return values;
-    }
-    /** 兜底路由：第一次真实 LLM 调用后捕获。 */
-    let captured = null;
-    ctx.on('llm/stream', (options, next) => {
-        captured = { provider: options.provider, model: options.model };
-        return next();
-    });
-    let modelCache = { at: 0, items: [] };
-    /** 哪些 provider/model 在 "关" 档会把思考写进正文（实测过一次就记住，之后自动改用「低」）。 */
-    const leakyOnOff = new Set();
-    /**
-     * 哪些 provider/model **根本不接受 "关" 档**（上游直接 400 invalid_request_error）。
-     *
-     * 和 leakyOnOff 分开记：那个是"能发但会泄漏"，这个是"发了就报错"。
-     * 记下来之后不再发 off，直接改用 low —— 这是"最接近关"的可接受档位。
-     * 不记的话每次划词都要先失败一轮再重试：用户看到一次报错闪动 + 多一个来回的时延。
-     */
-    const noOffRoutes = new Set();
-    const leakyFile = () => join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'leaky-off.json');
-    let leakyLoaded = false;
-    /** 载入"关档会泄漏思考"的模型清单（跨重启保留；文件坏了就当空）。 */
-    async function loadLeaky() {
-        if (leakyLoaded)
-            return;
-        leakyLoaded = true;
-        try {
-            const raw = await readFile(leakyFile(), 'utf8');
-            const parsed = JSON.parse(raw);
-            let dropped = 0;
-            const accept = (item, into) => {
-                if (typeof item !== 'string' || !item)
-                    return;
-                // 落盘文件是**跨重启的经验**，但也可能被测试夹具写脏（实测有 p1/m-strong）：
-                // provider 不存在的条目直接丢掉，并顺手把文件写回干净版。
-                if (!isRealProvider(item.split('/')[0] ?? '')) {
-                    dropped += 1;
-                    return;
-                }
-                into.add(item);
-            };
-            if (Array.isArray(parsed?.routes))
-                for (const item of parsed.routes)
-                    accept(item, leakyOnOff);
-            if (Array.isArray(parsed?.noOff))
-                for (const item of parsed.noOff)
-                    accept(item, noOffRoutes);
-            if (dropped > 0)
-                saveLeaky();
-        }
-        catch {
-            /* 没有这个文件是常态 */
-        }
-    }
-    function saveLeaky() {
-        const body = JSON.stringify({ version: 1, routes: Array.from(leakyOnOff), noOff: Array.from(noOffRoutes) }, null, 0);
-        void writeFile(leakyFile(), body, 'utf8').catch((error) => {
-            ctx.logger?.warn?.(`[${name}] 泄漏清单写盘失败：${String(error?.message ?? error)}`);
-        });
-    }
-    /**
-     * 这条 route 的 provider 是不是**这台机器上真有的**。
-     *
-     * 为什么落盘前要查一下：这两个集合会写进 `~/.dsh/selection-explain/leaky-off.json`，
-     * 而请求体里的 provider 是可以伪造的（`resolveRoute` 在清单没加载出来时只做形状校验）。
-     * 实测踩过：`test-client.mjs` 的夹具 provider `p1` 被写进了用户真实的落盘文件
-     * （`p1/m-strong`、`p1/m-fast`）—— 之后再也没人清掉它。
-     * 宁可不记（顶多多撞一次上游，反正有重试），也不要往用户的文件里写不存在的东西。
-     */
-    function isRealProvider(provider) {
-        if (!provider)
-            return false;
-        try {
-            const llm = ctx.get('llm');
-            const list = llm?.listProviders?.() ?? [];
-            return list.some((item) => String(item?.id ?? '') === provider);
-        }
-        catch {
-            return false;
-        }
-    }
-    /** 记住一个"关档会泄漏"的模型（内存 + 落盘）。 */
-    function markLeaky(route) {
-        if (leakyOnOff.has(route))
-            return;
-        if (!isRealProvider(route.split('/')[0] ?? ''))
-            return;
-        leakyOnOff.add(route);
-        if (leakyLoaded)
-            saveLeaky();
-    }
-    /** 记住一个"不接受关档"的模型（内存 + 落盘）：下次直接改用 low，不再先撞一次。 */
-    function markNoOff(route) {
-        if (noOffRoutes.has(route))
-            return;
-        if (!isRealProvider(route.split('/')[0] ?? ''))
-            return;
-        noOffRoutes.add(route);
-        if (leakyLoaded)
-            saveLeaky();
-    }
-    /** 档位阶梯与判据都在模块层（纯函数，可单测）：这里只把清单数据喂给它。 */
-    function nextEffortFor(route, rejected, tried) {
-        const item = modelCache.items.find((entry) => `${entry.provider}/${entry.model}` === route);
-        return pickNextEffort((item?.efforts ?? []).map((effort) => effort.id), item?.defaultEffort, rejected, tried);
-    }
-    /**
-     * 规范档位（设置页那四格）→ 这个 route **这次真要发**的档位（'' = 不带 reasoningEffort）。
-     *
-     * 每次请求都按**当前模型的声明**现算（不缓存映射结果、不落盘）：用户换模型、DSH 升级换
-     * adapter 之后立刻跟着变。清单里查不到（还没加载过 / 那次调用失败）就原样发规范值 ——
-     * 与改动前一致，被拒时由换档重试兜；同时后台预热一次清单，下一次请求就能映射上。
-     * 模型明确不支持推理（hasReasoning === false）时不发档位：发了 dsh-llm 必拒。
-     */
-    function effortForRoute(route, canonical) {
-        const item = modelCache.items.find((entry) => `${entry.provider}/${entry.model}` === route);
-        if (!item) {
-            warmModelCache();
-            return canonical;
-        }
-        if (item.hasReasoning === false)
-            return '';
-        const mapped = item.effortMap?.[canonical];
-        return mapped === undefined || mapped === '' ? canonical : mapped;
-    }
-    /** 清单预热：只在"真要用却还没读到"时拉一次，60 秒内不重复拉（失败也不打转）。 */
-    let modelWarmAt = 0;
-    function warmModelCache() {
-        if (modelCache.items.length > 0)
-            return;
-        if (Date.now() - modelWarmAt < MODEL_CACHE_MS)
-            return;
-        modelWarmAt = Date.now();
-        void listModelChoices(false).catch(() => undefined);
-    }
-    const MODEL_CACHE_MS = 60_000;
-    async function listModelChoices(force = false) {
-        if (!force && modelCache.items.length > 0 && Date.now() - modelCache.at < MODEL_CACHE_MS)
-            return modelCache.items;
-        const llm = ctx.get('llm');
-        const items = [];
-        const providers = llm?.listProviders?.() ?? [];
-        for (const provider of providers) {
-            if (!provider?.id || typeof llm?.listModels !== 'function')
-                continue;
-            let models = [];
-            try {
-                models = (await llm.listModels(provider.id)) ?? [];
-            }
-            catch {
-                models = [];
-            }
-            for (const model of models) {
-                if (!model?.id)
-                    continue;
-                let efforts = [];
-                let defaultEffort = null;
-                // null = 没读到（调用失败 / 拿不到信息）；true/false = 明确支持 / 不支持
-                let hasReasoning = null;
-                try {
-                    let info = null;
-                    if (typeof llm.resolveModelInfo === 'function') {
-                        info = (await llm.resolveModelInfo(provider.id, model.id));
-                    }
-                    else if (typeof llm.resolveModel === 'function') {
-                        info = (await llm.resolveModel(provider.id, model.id));
-                    }
-                    if (info) {
-                        const list = info.reasoning?.efforts ?? [];
-                        efforts = list
-                            .filter((item) => typeof item?.id === 'string' && item.id.length > 0)
-                            .map((item) => ({ id: String(item.id), name: String(item.name ?? item.id) }));
-                        defaultEffort = typeof info.reasoning?.defaultEffort === 'string' ? info.reasoning.defaultEffort : null;
-                        // 声明了 reasoning 但档位列表为空 → 发任何档位 dsh-llm 都会拒（它自己也不接受空表）
-                        hasReasoning = efforts.length > 0;
-                    }
-                }
-                catch {
-                    efforts = [];
-                }
-                items.push({
-                    provider: provider.id,
-                    providerName: String(provider.name ?? provider.id),
-                    model: model.id,
-                    name: String(model.name ?? model.id),
-                    efforts,
-                    defaultEffort,
-                    hasReasoning,
-                    effortMap: effortMapOf(efforts),
-                });
-            }
-        }
-        if (items.length > 0)
-            modelCache = { at: Date.now(), items };
-        return items;
-    }
-    /** 请求里带 provider+model 时优先用它（并按清单校验；清单还没加载出来就只做形状校验）。 */
-    const resolveRoute = (override, 
-    /**
-     * **当前会话**自己的模型选择（见 sessionModelOf）。
-     *
-     * 为什么要有它：会话是各自选模型的（每个 Agent 一份 model-selection），
-     * 而 `agentDefaultModel.currentSelection()` 是**全局默认**、与会话无关。
-     * 以前只用后者，于是"跟随主会话"其实跟的是"全局默认"——
-     * 两个会话用不同模型时，插件对两个会话都用同一个默认模型，跟谁都对不上。
-     *
-     * 优先级：显式 override（小窗胶囊选的）→ 插件配置（设置页选的）→ **本会话的模型** → 全局默认 → 第一个可用。
-     * 会话没记过选择（新会话、或日志里没有 model/selection）时自然落回全局默认，行为与以前一致。
-     */
-    sessionModel, 
-    /**
-     * 这一轮是不是**追问**。
-     *
-     * 三个阶段沿用同一模型；旧 chatProvider/chatModel 仅保留配置兼容，不再参与路由。
-     */
-    chat) => {
-        if (override?.provider && override?.model) {
-            const wanted = { provider: override.provider, model: override.model };
-            const known = modelCache.items.some((item) => item.provider === wanted.provider && item.model === wanted.model);
-            if (known || modelCache.items.length === 0)
-                return wanted;
-        }
-        if (config.provider && config.model)
-            return { provider: config.provider, model: config.model };
-        if (sessionModel?.provider && sessionModel?.model) {
-            return { provider: sessionModel.provider, model: sessionModel.model };
-        }
-        const service = ctx.get('agentDefaultModel');
-        const selection = service?.currentSelection?.();
-        if (selection?.provider && selection?.model) {
-            return { provider: selection.provider, model: selection.model };
-        }
-        const llm = ctx.get('llm');
-        const first = llm?.listProviders?.()?.find((item) => (item.models?.length ?? 0) > 0);
-        if (first?.id && first.models?.[0]?.id)
-            return { provider: first.id, model: first.models[0].id };
-        return captured;
-    };
-    /** 分钟级限流。 */
-    const hits = [];
-    const allow = () => {
-        const now = Date.now();
-        while (hits.length > 0 && now - hits[0] > 60_000)
-            hits.shift();
-        if (hits.length >= config.maxRequestsPerMinute)
-            return false;
-        hits.push(now);
-        return true;
-    };
-    /**
-     * 共享结果缓存（进程级，跨标签页/刷新可用）：
-     * 同会话 + 同选中文字 + 同局部片段 + 同会话背景 → 直接回放上次结果，不再调用模型。
-     */
-    const resultCache = new Map();
-    const resultKeyOf = (provider, model, sessionId, backgroundText, text, context) => createHash('sha1').update([provider, model, sessionId, backgroundText, text, context].join('\u0000')).digest('hex');
-    /** 会话背景短缓存：同一会话 10 秒内复用（连续划词不重复读日志）。 */
-    const backgroundCache = new Map();
-    /**
-     * 「本会话在用哪个模型」的短缓存 —— 只给按秒轮询的 `/route` 用（见 sessionModelOf）。
-     *
-     * 为什么需要：`readSession` 会把整份日志重放成一个 Session、再逐条深拷贝一遍
-     * （本机实测 1.5MB 的会话一次 80~125ms）。跟随状态下**小窗一开着**就要每 2 秒问一次，
-     * 不缓存等于每 2 秒在宿主进程里重放一次会话日志。
-     *
-     * 变更探测用 live 会话的 `seq`（同步、零成本，见 liveSeqOf）：没涨就直接回缓存；
-     * 涨了（主会话正在连续对话时每轮都在涨）也至少隔 SESSION_MODEL_MIN_MS 才重读一次，
-     * 否则"小窗开着 + 主会话在聊"时每 2 秒照样重放。非 live（磁盘上的旧会话，读不到 seq）按 TTL 兜底。
-     */
-    const sessionModelCache = new Map();
-    /** 同一会话正在飞的读取（读可能比轮询间隔还慢，叠起来没意义）。 */
-    const sessionModelPending = new Map();
-    /** live 会话两次重读之间的最短间隔（挡住"事件一直在涨"时的连续重放）。 */
-    const SESSION_MODEL_MIN_MS = 3_000;
-    /** 读不到 seq（非 live）时的兜底 TTL。 */
-    const SESSION_MODEL_TTL_MS = 10_000;
-    /**
-     * live 会话的事件数（`Session.seq` = 日志长度，每次 append 都会涨）。
-     *
-     * 这是**零成本**的同步读取：不用读日志、不用重放，就能判断"会话有没有新事件"。
-     * 拿不到（会话不在内存里 / 老内核没有 sessions 服务）返回 null，调用方退回 TTL。
-     */
-    const liveSeqOf = (sessionId) => {
-        const sessions = ctx.get('sessions');
-        const seq = sessions?.get?.(sessionId)?.seq;
-        return typeof seq === 'number' ? seq : null;
-    };
-    /** 读取当前会话的模型界面事件（live 优先；失败/超时一律降级为「无背景」）。 */
-    const readSurfaceEvents = async (sessionId) => {
-        const cached = backgroundCache.get(sessionId);
-        if (cached && Date.now() - cached.at < 10_000)
-            return cached.events;
-        const sessionQuery = ctx.get('sessionQuery');
-        if (typeof sessionQuery?.readSurface !== 'function')
-            return [];
-        const timeout = new Promise((resolve) => setTimeout(() => resolve(null), 2000));
-        try {
-            const surface = await Promise.race([sessionQuery.readSurface(sessionId), timeout]);
-            const events = surface && Array.isArray(surface.events) ? surface.events : [];
-            backgroundCache.set(sessionId, { at: Date.now(), events });
-            if (backgroundCache.size > 8) {
-                const oldest = backgroundCache.keys().next().value;
-                if (oldest !== undefined)
-                    backgroundCache.delete(oldest);
-            }
-            return events;
-        }
-        catch (error) {
-            ctx.logger?.warn?.(`[${name}] 读取会话背景失败（${sessionId}）：${String(error?.message ?? error)}`);
-            return [];
-        }
-    };
-    /**
-     * 真读一次：拿会话原始事件里的最后一条 `model/selection`。
-     *
-     * 来源：会话事件流里的 `model/selection`（每条 = 一次"后续请求用这个模型"的选择，
-     * 形如 `{ type:'model/selection', data:{ provider, model, reasoningEffort? } }`）。
-     * 取**最后一条** = 会话当前在用的那个；一条都没有（新会话）就返回 null，调用方落回全局默认。
-     */
-    const readSessionModel = async (sessionId) => {
-        if (!sessionId)
-            return null;
-        const sessionQuery = ctx.get('sessionQuery');
-        if (typeof sessionQuery?.readSession !== 'function')
-            return null;
-        let events = [];
-        try {
-            const timeout = new Promise((resolve) => setTimeout(() => resolve(null), 2000));
-            const log = await Promise.race([sessionQuery.readSession(sessionId), timeout]);
-            events = log && Array.isArray(log.events) ? (log.events) : [];
-        }
-        catch {
-            return null;
-        }
-        for (let i = events.length - 1; i >= 0; i -= 1) {
-            const event = events[i];
-            if (!event || typeof event !== 'object')
-                continue;
-            const typed = event;
-            if (typed.type !== 'model/selection')
-                continue;
-            const data = (typed.data ?? {});
-            if (typeof data.provider === 'string' && data.provider && typeof data.model === 'string' && data.model) {
-                return { provider: data.provider, model: data.model };
-            }
-        }
-        return null;
-    };
-    /**
-     * 记下这次的结论（连同"读到它时的 seq"）：下次轮询就能靠 seq 判断结论还有效没。
-     *
-     * 顺手也把"用户动作路径"读到的值种进缓存 —— 那是**此刻**那一份，
-     * 种进来只会让轮询更少重读、更不容易报旧值。
-     */
-    const rememberSessionModel = (sessionId, seq, value) => {
-        sessionModelCache.set(sessionId, { at: Date.now(), seq, value });
-        if (sessionModelCache.size > 8) {
-            const oldest = sessionModelCache.keys().next().value;
-            if (oldest !== undefined)
-                sessionModelCache.delete(oldest);
-        }
-    };
-    /**
-     * 读**当前会话**自己的模型选择。
-     *
-     * `useCache` 只给按秒轮询的 `/route` 打开；用户动作路径（analyze / models / ping）一律直读，
-     * 拿到的必须是**此刻**那一份 —— 不能让人刚在主会话里换完模型、划词却按旧模型解析。
-     * 直读的结果会顺手种进缓存（见 rememberSessionModel）。
-     */
-    const sessionModelOf = async (sessionId, useCache = false) => {
-        if (!sessionId)
-            return null;
-        if (!useCache) {
-            // seq 在读**之前**取：读的过程中若又落了事件，缓存就应当被视为旧值（宁可下次重读）
-            const seqNow = liveSeqOf(sessionId);
-            const value = await readSessionModel(sessionId);
-            rememberSessionModel(sessionId, seqNow, value);
-            return value;
-        }
-        const seq = liveSeqOf(sessionId);
-        const cached = sessionModelCache.get(sessionId);
-        if (cached) {
-            // 事件没涨 → 结论不可能变。只对 live 会话成立：`seq` 是同步的，每次 append 都会涨。
-            if (seq !== null && cached.seq === seq)
-                return cached.value;
-            // 涨了也不立刻重读：主会话正在连续对话时事件一直在涨，否则每 2 秒照样重放一次日志。
-            const floor = seq === null ? SESSION_MODEL_TTL_MS : SESSION_MODEL_MIN_MS;
-            if (Date.now() - cached.at < floor)
-                return cached.value;
-        }
-        // 同一会话的轮询叠在一起（读可能比轮询间隔还慢）时共用一个在飞的请求
-        const pending = sessionModelPending.get(sessionId);
-        if (pending)
-            return pending;
-        const task = readSessionModel(sessionId)
-            .then((value) => {
-            rememberSessionModel(sessionId, seq, value);
-            return value;
-        })
-            .finally(() => {
-            sessionModelPending.delete(sessionId);
-        });
-        sessionModelPending.set(sessionId, task);
-        return task;
-    };
-    /** 组装会话背景文本。 */
-    const loadSessionBackground = async (sessionId, options) => {
-        const events = await readSurfaceEvents(sessionId);
-        if (events.length === 0)
-            return null;
-        const background = transcriptOf(events, options);
-        return background.transcript ? background : null;
-    };
-    const history = new Map();
-    let historyLoaded = false;
-    let historyTimer = null;
-    const historyFile = () => join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'history.json');
-    /**
-     * 悬浮胶囊"拖到别处"后的位置（用户要求记住，存 host 上 —— 不用 localStorage）。
-     * 只记自由摆放的**右边缘 + 垂直中心**：收球/展开都以右边缘为锚（client 半的 applyFreePill 用 CSS right 钉住）。
-     * 吸附回右下角（anchor）时会清掉 —— 那是默认位置，不需要记。
-     */
-    const pillPosFile = () => join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'pill.json');
-    let pillPos = null;
-    let pillPosLoaded = false;
-    let pillPosTimer = null;
-    /** 位置校验：只接受有限数值，并夹到一个"任何屏幕都放得下"的量级。 */
-    function normalizePillPos(input) {
-        const value = input;
-        const right = typeof value?.right === 'number' && Number.isFinite(value.right) ? value.right : NaN;
-        const y = typeof value?.y === 'number' && Number.isFinite(value.y) ? value.y : NaN;
-        if (!Number.isFinite(right) || !Number.isFinite(y))
-            return null;
-        const clamp = (n) => Math.round(Math.min(40000, Math.max(-40000, n)));
-        return { right: clamp(right), y: clamp(y) };
-    }
-    async function loadPillPos() {
-        if (pillPosLoaded)
-            return;
-        pillPosLoaded = true;
-        try {
-            const parsed = JSON.parse(await readFile(pillPosFile(), 'utf8'));
-            pillPos = normalizePillPos(parsed?.position);
-        }
-        catch {
-            pillPos = null; // 没存过 / 坏了都当作"没记过"
-        }
-    }
-    function schedulePillPosWrite() {
-        if (pillPosTimer)
-            clearTimeout(pillPosTimer);
-        pillPosTimer = setTimeout(() => {
-            pillPosTimer = null;
-            void (async () => {
-                try {
-                    await mkdir(join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain'), { recursive: true });
-                    await writeFile(pillPosFile(), JSON.stringify({ version: 1, position: pillPos }, null, 0), 'utf8');
-                }
-                catch (error) {
-                    ctx.logger?.warn?.(`[${name}] 写入胶囊位置失败：${String(error?.message ?? error)}`);
-                }
-            })();
-        }, 300);
-        pillPosTimer.unref?.();
-    }
-    /**
-     * 小窗的**尺寸**（拖角改过大小之后记下来）。
-     *
-     * 只记尺寸，**不记位置**：小窗每次开窗都由 client 按选区重新锚定
-     * （落在选区下方，放不下就翻到上方，再夹进视口）—— 那套锚定逻辑是既有的设计，
-     * 位置一旦被"记住"就等于架空了它，开窗不再跟着划词的地方走。
-     * 尺寸则是用户明确调过的东西，值得跨开窗保留。
-     */
-    const panelSizeFile = () => join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'panel.json');
-    let panelSize = null;
-    let panelSizeLoaded = false;
-    let panelSizeTimer = null;
-    /**
-     * 尺寸校验：两个数都得是有限值，并夹到一个合理的区间。
-     *
-     * client 那边已经有 min/max 了，但文件是手工可编辑的（也可能被旧版本写坏），
-     * 不能让一个 5px 宽的小窗把界面弄成没法用。
-     */
-    function normalizePanelSize(input) {
-        const value = input;
-        const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : NaN);
-        const w = num(value?.w);
-        const h = num(value?.h);
-        if (!Number.isFinite(w) || !Number.isFinite(h))
-            return null;
-        const clamp = (n, lo, hi) => Math.round(Math.min(hi, Math.max(lo, n)));
-        return { w: clamp(w, 280, 4000), h: clamp(h, 200, 4000) };
-    }
-    async function loadPanelSize() {
-        if (panelSizeLoaded)
-            return;
-        panelSizeLoaded = true;
-        try {
-            const parsed = JSON.parse(await readFile(panelSizeFile(), 'utf8'));
-            panelSize = normalizePanelSize(parsed?.size);
-        }
-        catch {
-            panelSize = null; // 没存过 / 坏了都当作"没调过"
-        }
-    }
-    function schedulePanelSizeWrite() {
-        if (panelSizeTimer)
-            clearTimeout(panelSizeTimer);
-        panelSizeTimer = setTimeout(() => {
-            panelSizeTimer = null;
-            void (async () => {
-                try {
-                    await mkdir(join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain'), { recursive: true });
-                    await writeFile(panelSizeFile(), JSON.stringify({ version: 1, size: panelSize }, null, 0), 'utf8');
-                }
-                catch (error) {
-                    ctx.logger?.warn?.(`[${name}] 写入小窗尺寸失败：${String(error?.message ?? error)}`);
-                }
-            })();
-        }, 300);
-        panelSizeTimer.unref?.();
-    }
-    /**
-     * 小窗尺寸：GET 读回来（挂载时恢复）、POST 存（{w,h}）或清（{clear:true}，回到默认尺寸）。
-     */
-    const handlePanelSize = (req, res) => {
-        void (async () => {
-            await loadPanelSize();
-            if (req.method === 'GET') {
-                sendJson(res, 200, { ok: true, size: panelSize });
-                return;
-            }
-            if (req.method !== 'POST') {
-                sendJson(res, 405, { ok: false, error: '只支持 GET / POST' });
-                return;
-            }
-            const raw = await readBody(req, 4_000);
-            let body = {};
-            try {
-                body = raw ? JSON.parse(raw) : {};
-            }
-            catch {
-                sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
-                return;
-            }
-            if (body.clear === true) {
-                panelSize = null;
-                schedulePanelSizeWrite();
-                sendJson(res, 200, { ok: true, size: null });
-                return;
-            }
-            const next = normalizePanelSize(body.size ?? body);
-            if (!next) {
-                sendJson(res, 400, { ok: false, error: 'size 需要 { w, h } 两个有限数值' });
-                return;
-            }
-            panelSize = next;
-            schedulePanelSizeWrite();
-            sendJson(res, 200, { ok: true, size: panelSize });
-        })().catch((error) => {
-            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
-        });
-    };
-    /**
-     * 胶囊位置：GET 读回来（挂载时恢复）、POST 存（{right,y}）或清（{clear:true}，吸附回右下角时调）。
-     */
-    const handlePillPos = (req, res) => {
-        void (async () => {
-            await loadPillPos();
-            if (req.method === 'GET') {
-                sendJson(res, 200, { ok: true, position: pillPos });
-                return;
-            }
-            if (req.method !== 'POST') {
-                sendJson(res, 405, { ok: false, error: '只支持 GET / POST' });
-                return;
-            }
-            const raw = await readBody(req, 4_000);
-            let body = {};
-            try {
-                body = raw ? JSON.parse(raw) : {};
-            }
-            catch {
-                sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
-                return;
-            }
-            if (body.clear === true) {
-                pillPos = null;
-                schedulePillPosWrite();
-                sendJson(res, 200, { ok: true, position: null });
-                return;
-            }
-            const next = normalizePillPos(body.position ?? body);
-            if (!next) {
-                sendJson(res, 400, { ok: false, error: 'position 需要 { right, y } 两个有限数值' });
-                return;
-            }
-            pillPos = next;
-            schedulePillPosWrite();
-            sendJson(res, 200, { ok: true, position: pillPos });
-        })();
-    };
-    const clampText = (value, max) => (typeof value === 'string' ? value.slice(0, max) : '');
-    async function loadHistory() {
-        if (historyLoaded)
-            return;
-        historyLoaded = true;
-        try {
-            await loadLeaky();
-            const raw = await readFile(historyFile(), 'utf8');
-            const parsed = JSON.parse(raw);
-            const list = Array.isArray(parsed?.entries) ? parsed.entries : [];
-            for (const item of list) {
-                const entry = item;
-                if (typeof entry?.key !== 'string' || entry.key.length === 0)
-                    continue;
-                history.set(entry.key, {
-                    key: entry.key,
-                    // 按可设置的最高选区长度保留，调低当前限制也不截断已有历史。
-                    text: clampText(entry.text, 20000),
-                    context: clampText(entry.context, 20000),
-                    label: clampText(entry.label, 60),
-                    at: typeof entry.at === 'number' ? entry.at : Date.now(),
-                    parts: {
-                        translation: clampText(entry.parts?.translation, 20000),
-                        detail: clampText(entry.parts?.detail, 20000),
-                    },
-                    turns: Array.isArray(entry.turns)
-                        ? entry.turns.slice(0, 60).map((turn) => ({
-                            role: turn?.role === 'assistant' ? 'assistant' : 'user',
-                            text: clampText(turn?.text, 20000),
-                        }))
-                        : [],
-                    toolDigest: clampText(entry.toolDigest, 2000),
-                    pinned: entry.pinned === true,
-                });
-            }
-            ctx.logger?.info?.(`[${name}] 小窗历史已载入 ${String(history.size)} 条（${historyFile()}）`);
-        }
-        catch (error) {
-            const code = error?.code;
-            if (code !== 'ENOENT') {
-                ctx.logger?.warn?.(`[${name}] 读取小窗历史失败：${String(error?.message ?? error)}`);
-            }
-        }
-    }
-    function scheduleHistoryWrite() {
-        if (historyTimer)
-            clearTimeout(historyTimer);
-        historyTimer = setTimeout(() => {
-            historyTimer = null;
-            const entries = [...history.values()].sort((a, b) => b.at - a.at);
-            void (async () => {
-                try {
-                    await mkdir(join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain'), { recursive: true });
-                    await writeFile(historyFile(), JSON.stringify({ version: 1, entries }, null, 0), 'utf8');
-                }
-                catch (error) {
-                    ctx.logger?.warn?.(`[${name}] 写入小窗历史失败：${String(error?.message ?? error)}`);
-                }
-            })();
-        }, 800);
-        historyTimer.unref?.();
-    }
-    /** 存一条对话（整段覆盖），并按 LRU 淘汰超出上限的条目（升格过的不淘汰）。 */
-    function saveHistoryEntry(input) {
-        if (config.historyMaxEntries <= 0)
-            return history.size;
-        const key = clampText(input.key, 200);
-        if (!key)
-            return history.size;
-        const previous = history.get(key);
-        const entry = {
-            key,
-            text: clampText(input.text, 20000),
-            context: clampText(input.context, 20000),
-            label: clampText(input.label, 60),
-            at: Date.now(),
-            parts: {
-                translation: clampText(input.parts?.translation, 20000),
-                detail: clampText(input.parts?.detail, 20000),
-            },
-            turns: Array.isArray(input.turns)
-                ? input.turns.slice(0, 60).map((turn) => ({
-                    role: turn?.role === 'assistant' ? 'assistant' : 'user',
-                    text: clampText(turn?.text, 20000),
-                }))
-                : [],
-            toolDigest: clampText(input.toolDigest, 2000),
-            pinned: input.pinned === true || previous?.pinned === true,
-        };
-        history.delete(key);
-        history.set(key, entry);
-        // LRU：超出上限时丢最久没用过的（Map 的插入顺序就是使用顺序）
-        while (history.size > config.historyMaxEntries) {
-            let victim;
-            for (const candidate of history.keys()) {
-                const item = history.get(candidate);
-                if (item && !item.pinned) {
-                    victim = candidate;
-                    break;
-                }
-            }
-            if (victim === undefined)
-                break;
-            history.delete(victim);
-        }
-        scheduleHistoryWrite();
-        return history.size;
-    }
-    const historyMeta = (entry) => ({
-        key: entry.key,
-        text: entry.text.length > 60 ? `${entry.text.slice(0, 60)}…` : entry.text,
-        label: entry.label,
-        at: entry.at,
-        turns: entry.turns.filter((turn) => turn.role === 'user').length,
-        hasDetail: entry.parts.detail.length > 0,
-        pinned: entry.pinned,
-    });
-    /**
-     * 引用上下文：客户端点了「❝ 引用」之后，拿引用文字来换它所在的那一组对话 ± 一组。
-     *
-     * 为什么走 host 而不是客户端读 DOM：会话正文的**干净文本**只有 host 这边有
-     * （`readSurface` 的事件流里工具调用/结果、系统提示、harness 注入全都被 `transcriptOf`
-     * 那套规则滤掉过）。客户端 DOM 里读到的会是"渲染后的样子"——思考块、工具卡片、
-     * 按钮文案全混在里面。定位不到（引用来自侧边栏网页/文档预览）就返回 matched:false，
-     * 客户端退回它自己采的局部上下文。
-     */
-    const handleQuoteContext = (req, res) => {
-        void (async () => {
-            if (req.method !== 'POST') {
-                sendJson(res, 405, { ok: false, error: '只支持 POST' });
-                return;
-            }
-            const raw = await readBody(req, 200_000);
-            let body = {};
-            try {
-                body = raw ? JSON.parse(raw) : {};
-            }
-            catch {
-                sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
-                return;
-            }
-            const sessionId = typeof body.sessionId === 'string' ? body.sessionId.trim() : '';
-            const text = clampText(body.text, config.maxSelectionChars);
-            if (!sessionId || !text.trim()) {
-                sendJson(res, 200, { ok: true, matched: false, context: '', rounds: 0 });
-                return;
-            }
-            const events = await readSurfaceEvents(sessionId);
-            const context = quoteContextOf(events, text, {
-                roundsAround: config.quoteContextRounds,
-                maxCharsPerTurn: config.quoteContextMaxCharsPerTurn,
-                maxChars: config.quoteContextMaxChars,
-            });
-            sendJson(res, 200, {
-                ok: true,
-                matched: context.matched,
-                context: context.transcript,
-                rounds: context.rounds,
-                chars: context.transcript.length,
-            });
-        })().catch((error) => {
-            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
-        });
-    };
-    /** ctx.speechToText：装了就给，没装/被停用给 undefined（麦克风据此优雅降级）。 */
-    const speechService = () => {
-        try {
-            const service = ctx.get('speechToText');
-            return service && typeof service.transcribe === 'function' ? service : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    };
-    /**
-     * 语音目录：有哪些识别器、各自什么状态、默认选谁、这次能录多久。
-     *
-     * 客户端据此决定麦克风的形态：能用 / 要先把模型准备好 / 这个部署根本没有识别服务。
-     * 不认识的状态一律当成"不能录"（宁可让用户看到一句解释，也不要录完才发现转不了）。
-     */
-    const speechCatalog = () => {
-        const service = speechService();
-        const limits = { maxSeconds: SPEECH_MAX_SECONDS, maxBytes: SPEECH_MAX_BYTES };
-        if (!service) {
-            return {
-                ok: true,
-                available: false,
-                reason: 'missing',
-                error: '这个 DSH 没有启用语音识别服务（缺 @deepseek-ai/dsh-experimental-speech-to-text）',
-                providers: [],
-                selection: null,
-                limits,
-            };
-        }
-        let snapshot;
-        try {
-            snapshot = service.snapshot();
-        }
-        catch (error) {
-            return {
-                ok: true,
-                available: false,
-                reason: 'error',
-                error: String(error?.message ?? error),
-                providers: [],
-                selection: null,
-                limits,
-            };
-        }
-        const providers = (snapshot?.providers ?? []).map((provider) => {
-            const preparation = provider.preparation ?? { phase: 'ready' };
-            return {
-                id: String(provider.id),
-                name: String(provider.name ?? provider.id),
-                location: String(provider.location ?? ''),
-                languages: Array.isArray(provider.languages) ? provider.languages.map(String) : [],
-                // 下载源：本地模型已经装好时是空数组（没有可选项），装了才有得选
-                downloadSources: Array.isArray(provider.downloadSources) ? provider.downloadSources.map(String) : [],
-                phase: String(preparation.phase ?? 'unprepared'),
-                step: preparation.step ? String(preparation.step) : '',
-                // 下载进度（只在 downloading 时有意义）：客户端显示"还要下多少"
-                completedBytes: typeof preparation.completedBytes === 'number' ? preparation.completedBytes : 0,
-                totalBytes: typeof preparation.totalBytes === 'number' ? preparation.totalBytes : 0,
-                message: preparation.message ? String(preparation.message) : '',
-            };
-        });
-        const selection = snapshot?.selection
-            ? { providerId: String(snapshot.selection.providerId), language: String(snapshot.selection.language) }
-            : null;
-        // 能录 = 至少有一个识别器已经就绪（standby 也算：本机模型在磁盘上，用到才唤醒）
-        const usable = providers.filter((provider) => provider.phase === 'ready' || provider.phase === 'standby');
-        return {
-            ok: true,
-            available: usable.length > 0,
-            reason: usable.length > 0 ? '' : providers.length > 0 ? 'unprepared' : 'empty',
-            error: '',
-            providers,
-            selection,
-            limits,
-        };
-    };
-    const handleSpeech = (req, res) => {
-        if (req.method !== 'GET') {
-            sendJson(res, 405, { ok: false, error: '只支持 GET' });
-            return;
-        }
-        sendJson(res, 200, speechCatalog());
-    };
-    /**
-     * 显式准备识别模型（首次要下 1G 左右的模型，所以**只有用户点了才做**，不自动触发）。
-     * 只是把任务交给识别服务，进度走目录接口轮询（下载在 host 上跑，关掉页面也继续）。
-     */
-    const handleSpeechPrepare = (req, res) => {
-        void (async () => {
-            if (req.method !== 'POST') {
-                sendJson(res, 405, { ok: false, error: '只支持 POST' });
-                return;
-            }
-            const service = speechService();
-            if (!service) {
-                sendJson(res, 200, { ok: false, error: '这个 DSH 没有启用语音识别服务' });
-                return;
-            }
-            let body = {};
-            try {
-                const raw = await readBody(req, 20_000);
-                body = raw ? JSON.parse(raw) : {};
-            }
-            catch {
-                sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
-                return;
-            }
-            const catalog = speechCatalog();
-            const wanted = typeof body.providerId === 'string' && body.providerId ? body.providerId : '';
-            const providers = catalog.providers ?? [];
-            const target = wanted || (providers.find((item) => item.phase !== 'ready' && item.phase !== 'standby')?.id ?? providers[0]?.id ?? '');
-            if (!target) {
-                sendJson(res, 200, { ok: false, error: '没有可用的识别器' });
-                return;
-            }
-            try {
-                const source = typeof body.downloadSource === 'string' && body.downloadSource ? body.downloadSource : undefined;
-                service.prepare(target, source === undefined ? undefined : { downloadSource: source });
-            }
-            catch (error) {
-                // 已经在准备中 / 下载源不认 / 服务生命周期已结束：都不算致命，把状态回给客户端自己看
-                sendJson(res, 200, { ok: false, error: String(error?.message ?? error), catalog: speechCatalog() });
-                return;
-            }
-            sendJson(res, 200, { ok: true, providerId: target, catalog: speechCatalog() });
-        })().catch((error) => {
-            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
-        });
-    };
-    /**
-     * 转写一段录音。
-     *
-     * 输入是浏览器端编码好的规范 WAV（base64），输出就是一段文字——**不落盘、不进会话**，
-     * 也不给模型看（用户要的是"把我说的变成字"，不是"让模型处理我的录音"）。
-     * 识别失败一律回 200 + { ok:false, code }：这是"这一句话没听清"，
-     * 不是 HTTP 层面的错误，客户端按 code 给不同的话术（换 HTTP 状态码反而会被
-     * 各种中间层改写或吞掉，用户看到的就只剩"请求失败"）。
-     */
-    const handleSpeechTranscribe = (req, res) => {
-        void (async () => {
-            if (req.method !== 'POST') {
-                sendJson(res, 405, { ok: false, error: '只支持 POST' });
-                return;
-            }
-            const service = speechService();
-            if (!service) {
-                sendJson(res, 200, {
-                    ok: false,
-                    code: 'missing',
-                    error: '这个 DSH 没有启用语音识别服务（缺 @deepseek-ai/dsh-experimental-speech-to-text）',
-                });
-                return;
-            }
-            let body = {};
-            try {
-                const raw = await readBody(req, SPEECH_BODY_LIMIT);
-                body = raw ? JSON.parse(raw) : {};
-            }
-            catch (error) {
-                sendJson(res, 200, { ok: false, code: 'transport', error: String(error?.message ?? error) });
-                return;
-            }
-            const encoded = typeof body.audioBase64 === 'string' ? body.audioBase64 : '';
-            if (!encoded) {
-                sendJson(res, 200, { ok: false, code: 'audio', error: '没有收到音频' });
-                return;
-            }
-            let audio;
-            let seconds = 0;
-            try {
-                if (encoded.length > Math.ceil(SPEECH_MAX_BYTES / 3) * 4)
-                    throw new Error('录音太大了');
-                audio = Buffer.from(encoded, 'base64');
-                // 规范 base64：随手传一段别的东西进来会在这一步被挡掉（解出来对不上原文）
-                if (audio.toString('base64') !== encoded)
-                    throw new Error('音频不是合法 base64');
-                if (audio.length > SPEECH_MAX_BYTES)
-                    throw new Error('录音太大了');
-                seconds = validateWave(audio, SPEECH_MAX_SECONDS);
-            }
-            catch (error) {
-                sendJson(res, 200, { ok: false, code: 'audio', error: String(error?.message ?? error) });
-                return;
-            }
-            const catalog = speechCatalog();
-            const providers = catalog.providers ?? [];
-            // 这个部署默认用的语言（识别服务里配的，auto = 自动判断）；请求里带了就以请求为准
-            const catalogLanguage = String(catalog.selection?.language ?? '');
-            const wanted = typeof body.providerId === 'string' && body.providerId ? body.providerId : '';
-            const picked = providers.find((item) => item.id === wanted) ??
-                providers.find((item) => item.phase === 'ready' || item.phase === 'standby') ??
-                providers[0];
-            if (!picked) {
-                sendJson(res, 200, { ok: false, code: 'empty', error: '没有可用的识别器' });
-                return;
-            }
-            if (picked.phase !== 'ready' && picked.phase !== 'standby') {
-                sendJson(res, 200, {
-                    ok: false,
-                    code: 'unprepared',
-                    providerId: picked.id,
-                    phase: picked.phase,
-                    error: `识别模型还没准备好（${picked.name}：${picked.phase}）`,
-                    catalog,
-                });
-                return;
-            }
-            // 客户端断开 / 用户取消 → 立刻掐掉识别（本机模型在跑推理，不能让它白跑）
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(new Error('识别超时')), SPEECH_TIMEOUT_MS);
-            const onClose = () => controller.abort(new Error('客户端已断开'));
-            req.on('close', onClose);
-            const startedAt = Date.now();
-            try {
-                const language = typeof body.language === 'string' && body.language ? body.language : undefined;
-                const spec = service.resolve({
-                    audio,
-                    ...(wanted ? { providerId: wanted } : {}),
-                    ...(language === undefined ? {} : { language }),
-                });
-                const transcript = await service.transcribe(spec, controller.signal);
-                const text = String(transcript?.text ?? '').trim();
-                if (!text) {
-                    sendJson(res, 200, { ok: false, code: 'empty-transcript', error: '没听清（这段录音里没有识别到内容）' });
-                    return;
-                }
-                sendJson(res, 200, {
-                    ok: true,
-                    text,
-                    providerId: picked.id,
-                    providerName: picked.name,
-                    language: language ?? catalogLanguage,
-                    seconds,
-                    elapsedMs: Date.now() - startedAt,
-                });
-            }
-            catch (error) {
-                const message = String(error?.message ?? error);
-                const aborted = error?.name === 'AbortError' || controller.signal.aborted;
-                // 超时/断开与"识别失败"分开报：前者是这一句没转成，后者是识别服务本身有问题
-                sendJson(res, 200, {
-                    ok: false,
-                    code: aborted ? 'aborted' : 'failed',
-                    error: aborted ? `这次识别被打断了（${message}）` : message,
-                });
-            }
-            finally {
-                clearTimeout(timer);
-                req.off('close', onClose);
-            }
-        })().catch((error) => {
-            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
-        });
-    };
-    const handleHistory = (req, res) => {
-        void (async () => {
-            await loadSettings();
-            await loadHistory();
-            const url = new URL(req.url ?? '/', 'http://localhost');
-            if (req.method === 'DELETE') {
-                // 删除一条（?key=）或清空（?all=1）。
-                // 返回被删条目的**快照**，客户端据此做"撤销"（撤销就是把它原样 POST 回来）。
-                const all = url.searchParams.get('all') === '1';
-                if (all) {
-                    const removed = Array.from(history.values());
-                    history.clear();
-                    scheduleHistoryWrite();
-                    sendJson(res, 200, { ok: true, removed: removed.length, entries: removed.map(historyMeta) });
-                    return;
-                }
-                const key = url.searchParams.get('key') ?? '';
-                if (!key) {
-                    sendJson(res, 400, { ok: false, error: '缺少 key' });
-                    return;
-                }
-                const entry = history.get(key);
-                if (!entry) {
-                    sendJson(res, 200, { ok: true, removed: 0, entry: null });
-                    return;
-                }
-                history.delete(key);
-                scheduleHistoryWrite();
-                sendJson(res, 200, { ok: true, removed: 1, entry });
-                return;
-            }
-            if (req.method === 'POST' && url.searchParams.get('restore') === '1') {
-                // 撤销删除：把客户端手里的快照原样写回（含 at/pinned，恢复原来的位置与标记）
-                const raw = await readBody(req, 2_000_000);
-                let body = {};
-                try {
-                    body = raw ? JSON.parse(raw) : {};
-                }
-                catch {
-                    sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
-                    return;
-                }
-                const entry = body.entry;
-                if (!entry || typeof entry.key !== 'string' || !entry.key) {
-                    sendJson(res, 400, { ok: false, error: '缺少 entry' });
-                    return;
-                }
-                history.delete(entry.key);
-                history.set(entry.key, entry);
-                scheduleHistoryWrite();
-                sendJson(res, 200, { ok: true, size: history.size });
-                return;
-            }
-            if (req.method === 'POST') {
-                const raw = await readBody(req, 2_000_000);
-                let body = {};
-                try {
-                    body = raw ? JSON.parse(raw) : {};
-                }
-                catch {
-                    sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
-                    return;
-                }
-                const size = saveHistoryEntry({
-                    key: typeof body?.key === 'string' ? body.key : '',
-                    text: typeof body?.text === 'string' ? body.text : '',
-                    context: typeof body?.context === 'string' ? body.context : '',
-                    label: typeof body?.label === 'string' ? body.label : '',
-                    parts: (body?.parts ?? {}),
-                    turns: (Array.isArray(body?.turns) ? body.turns : []),
-                    toolDigest: typeof body?.toolDigest === 'string' ? body.toolDigest : '',
-                    pinned: body?.pinned === true,
-                });
-                sendJson(res, 200, { ok: true, size });
-                return;
-            }
-            const key = url.searchParams.get('key');
-            if (key) {
-                const entry = history.get(key);
-                sendJson(res, 200, { ok: true, entry: entry ?? null });
-                return;
-            }
-            const entries = [...history.values()].sort((a, b) => b.at - a.at).map(historyMeta);
-            sendJson(res, 200, { ok: true, entries });
-        })().catch((error) => {
-            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
-        });
-    };
-    /** GET /models：给「模型」菜单用（带每个模型支持的推理等级；60 秒缓存）。 */
-    async function handleModels(req, res) {
-        await loadLeaky(); // 不 await 的话，这条路由在读"关档会泄漏"的清单时文件还没载入（实测报空）
-        const url = new URL(req.url ?? '/', 'http://localhost');
-        const force = url.searchParams.get('refresh') === '1';
-        let items = [];
-        let error = '';
-        try {
-            items = await listModelChoices(force);
-        }
-        catch (thrown) {
-            error = String(thrown?.message ?? thrown);
-        }
-        // 会话级：设置页的「跟随主会话」要显示**当前会话**在用的模型
-        let modelsSessionId = '';
-        try {
-            modelsSessionId = url.searchParams.get('sessionId') ?? '';
-        }
-        catch {
-            /* 解析不了就当没带 */
-        }
-        const current = resolveRoute(undefined, await sessionModelOf(modelsSessionId));
-        sendJson(res, 200, {
-            ok: true,
-            current,
-            cached: Date.now() - modelCache.at < MODEL_CACHE_MS,
-            ...(error ? { error } : {}),
-            models: items,
-            // 进程内学到的"关档会把思考写进正文"的模型（客户端据此在菜单里标注；重启后由客户端本地记忆兜着）
-            leakyOff: Array.from(leakyOnOff),
-            // 前端按 provider+model 匹配"当前档"
-            stages: {
-                chat: config.chatReasoningEffort || config.reasoningEffort,
-                translation: config.translationReasoningEffort || config.reasoningEffort,
-                detail: config.reasoningEffort,
-            },
-        });
-    }
-    /**
-     * 设置页的读写口。
-     *
-     *   GET  → { groups, values, defaults }：spec 一并下发，客户端只负责画
-     *   POST → { values: {...} }：归一 → 立刻生效（改内存）→ 防抖落盘
-     *   POST { reset: true }    ：清空覆盖，回到 cordis.patch.yml / 出厂默认
-     *
-     * 为什么不是"写回 cordis.patch.yml"：那是装配清单，
-     * 让 UI 去改它既要人肉重启、又可能把 YAML 结构写坏；这里落在插件自己的目录，改完即时生效。
-     */
-    const handleSettings = (req, res) => {
-        void (async () => {
-            await loadSettings();
-            if (req.method === 'POST') {
-                const raw = await readBody(req, 200_000);
-                let body = {};
-                try {
-                    body = raw ? JSON.parse(raw) : {};
-                }
-                catch {
-                    sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
-                    return;
-                }
-                if (body.reset === true) {
-                    settingsOverrides = {};
-                    applyOverrides(configDefaults);
-                    scheduleSettingsWrite();
-                    sendJson(res, 200, { ok: true, values: currentSettings(), rejected: [] });
-                    return;
-                }
-                const result = normalizeSettingsPatch(body.values);
-                if (Object.keys(result.values).length === 0 && result.rejected.length > 0) {
-                    sendJson(res, 400, { ok: false, error: '没有可写入的字段', rejected: result.rejected });
-                    return;
-                }
-                // 合并而不是覆盖：只发一个键的补丁不该把其它改过的项抹掉
-                settingsOverrides = { ...settingsOverrides, ...result.values };
-                applyOverrides(result.values);
-                scheduleSettingsWrite();
-                sendJson(res, 200, { ok: true, values: currentSettings(), rejected: result.rejected });
-                return;
-            }
-            sendJson(res, 200, { ok: true, ...buildSettingsPayload(currentSettings(), configDefaults) });
-        })().catch((error) => {
-            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
-        });
-    };
-    /**
-     * 极轻的"这一轮会用哪个模型"查询。
-     *
-     *   GET /selection-explain/api/route?sessionId=…[&chat=1]
-     *
-     * 为什么单开一条：设置页要**实时**显示当前会话在用的模型，
-     * 而 /models 会去列 provider 与模型（42 个，还要端点发现）、/ping 要枚举工具表并探 DNS ——
-     * 两者都不适合按秒轮询。这条只做一次会话模型解析 + 一次 resolveRoute。
-     *
-     * 也是唯一走 `sessionModelOf(…, true)`（短缓存）的地方：客户端在小窗开着时每 2 秒问一次，
-     * 不能每拍都重放一次会话日志（见 sessionModelCache 的注释）。
-     */
-    const handleRoute = (req, res) => {
-        void (async () => {
-            await loadSettings();
-            let sessionId = '';
-            let chat = false;
-            try {
-                const url = new URL(req.url ?? '/', 'http://localhost');
-                sessionId = url.searchParams.get('sessionId') ?? '';
-                chat = url.searchParams.get('chat') === '1';
-            }
-            catch {
-                /* 解析不了就当没带 */
-            }
-            const route = resolveRoute(undefined, await sessionModelOf(sessionId, true), chat);
-            sendJson(res, 200, {
-                ok: true,
-                provider: route?.provider ?? '',
-                model: route?.model ?? '',
-                // 是不是"跟首轮/次轮同一个"：客户端据此把追问下拉显示成「跟随首轮 / 次轮」
-                chatFollows: true,
-            });
-        })().catch((error) => {
-            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
-        });
-    };
-    const handlePing = (req, res) => {
-        const sessionQuery = ctx.get('sessionQuery');
-        // 可以带 ?sessionId=xxx：工具是**按会话作用域**注册的，不带 id 只能看到全局视图（里面没有 web_search）
-        let pingSessionId = '';
-        try {
-            pingSessionId = new URL(req.url ?? '/', 'http://localhost').searchParams.get('sessionId') ?? '';
-        }
-        catch {
-            /* 解析不了就当没带 */
-        }
-        // 小窗能调哪些工具：白名单是配置，实际放行还要看本机能不能抓网页（见下）。
-        // 用 async 包一层：探测 DNS 是异步的，出错也要给出结构化响应（和 history 路由同一写法）。
-        void (async () => {
-            // 先把用户改过的设置套上：下面报的每一条都必须是**当前生效**的值
-            await loadSettings();
-            const whitelist = config.toolNames
-                .split(',')
-                .map((item) => item.trim())
-                .filter((item) => item.length > 0);
-            const agents = ctx.get('agents');
-            // 复刻 handleAnalyze 的作用域回退：本会话 agent 取不到就用任一活跃 agent
-            let pingAgent = pingSessionId ? agents?.get?.(pingSessionId) : undefined;
-            let pingScope = pingAgent ? 'session' : '';
-            if (!pingAgent) {
-                pingAgent = agents?.list?.()?.[0];
-                pingScope = pingAgent ? 'fallback' : 'global';
-            }
-            let visible = [];
-            let visibleError = '';
-            let toolInfo = [];
-            let toolNames = [];
-            let sessionToolCount = 0;
-            try {
-                // 必须带着 registry 调（`const f = registry.schemas; f(...)` 会把 this 丢掉 → 拿到空表）
-                const registry = ctx.get('tools');
-                const all = registry?.schemas?.(pingAgent) ?? [];
-                sessionToolCount = all.length;
-                visible = all.map((schema) => schema.name).filter((toolName) => whitelist.includes(toolName));
-                // 诊断用：会话里这几个工具到底是哪个插件提供的（描述前 70 字能认出来）
-                toolInfo = all.map((schema) => ({
-                    name: schema.name,
-                    desc: String(schema.description ?? '').replace(/\s+/g, ' ').slice(0, 70),
-                }));
-                toolNames = all.map((schema) => schema.name);
-            }
-            catch (error) {
-                visibleError = String(error?.message ?? error);
-            }
-            // 本机抓不了网页时 web_fetch 会被摘掉（探针缓存 5 分钟，这里复用同一个）
-            let fetchBlocked = '';
-            if (whitelist.includes('web_fetch')) {
-                const probe = await webFetchUsable();
-                if (!probe.usable)
-                    fetchBlocked = probe.sample;
-            }
-            sendJson(res, 200, {
-                ok: true,
-                plugin: name,
-                route: resolveRoute(undefined, await sessionModelOf(pingSessionId)),
-                reasoningEffort: config.reasoningEffort,
-                modelsRoute: `${API_PREFIX}/models`,
-                history: { maxEntries: config.historyMaxEntries, file: historyFile() },
-                // 三档分开报：一眼看出"首轮为什么快、详解为什么慢"
-                reasoningEffortByStage: {
-                    translation: config.translationReasoningEffort,
-                    detail: config.reasoningEffort,
-                    chat: config.chatReasoningEffort,
-                },
-                // 小窗能用哪些工具：whitelist=配置允许，offered=这一轮真会交给模型的
-                tools: {
-                    enabled: config.tools && config.maxToolRounds > 0,
-                    whitelist,
-                    offered: visible.filter((toolName) => !(toolName === 'web_fetch' && fetchBlocked)),
-                    // 文件类工具的读取边界：'' = 会话工作目录，'*' = 不限制
-                    readRoot: config.toolReadRoot === '*' ? '(不限)' : config.toolReadRoot || '(会话工作目录)',
-                    visible: visibleError ? '读取工具表失败：' + visibleError : visible.length,
-                    // 备用联网工具是否启用（没装 free-search 时会补上 web_search）
-                    fallback: config.fallbackToolNames,
-                    preferredSearchPresent: visible.includes('advanced_search') || visible.includes('platform_search'),
-                    toolInfo,
-                    toolNames,
-                    // 这个会话一共能看到多少工具（放行的是白名单里那几个，其余一律不可用）
-                    sessionTools: sessionToolCount,
-                    scope: pingScope,
-                    maxRounds: config.maxToolRounds,
-                    fetchBlocked,
-                },
-                sessionContext: config.sessionContext && typeof sessionQuery?.readSurface === 'function',
-                // 侧边栏 HTML 预览里的划词桥开关：客户端据此决定要不要往预览帧注入桥脚本
-                bridgeSidebarPreview: config.bridgeSidebarPreview,
-                // 悬浮胶囊的两个偏好：跟着 ping 一起下发，省得客户端为它单开一次请求
-                pill: { enabled: config.pillEnabled, idleMs: config.pillIdleMs },
-                limits: {
-                    maxSelectionChars: config.maxSelectionChars,
-                    maxContextChars: config.maxContextChars,
-                    sessionContextMaxMessages: config.sessionContextMaxMessages,
-                    sessionContextFastMessages: config.sessionContextFastMessages,
-                    sessionContextMaxChars: config.sessionContextMaxChars,
-                    quoteContextRounds: config.quoteContextRounds,
-                    quoteContextMaxChars: config.quoteContextMaxChars,
-                },
-            });
-        })().catch((error) => {
-            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
-        });
-    };
-    /** 解析一个会话的工作目录（同项目 = 同 cwd）。 */
-    const resolveSessionCwd = async (sessionId) => {
-        if (!sessionId)
-            return undefined;
-        const sessions = ctx.get('sessions');
-        const live = sessions?.get?.(sessionId)?.header?.cwd;
-        if (live)
-            return live;
-        const sessionQuery = ctx.get('sessionQuery');
-        try {
-            const log = await sessionQuery?.readSession?.(sessionId);
-            return log?.session?.cwd;
-        }
-        catch {
-            return undefined;
-        }
-    };
-    /**
-     * 把划词解读小窗「升格」成正式会话（建在来源会话同一个项目下）：
-     *   ① 建会话 → ② 注入上下文消息（选中文字/所在位置/上下文片段，生产者自有 kind 的 context 消息）
-     *   → ③ 把首轮解读写成助手消息 → ④ 把追问逐轮写成真实的 user/assistant 历史消息
-     *   → ⑤ 送一条短开场消息让 agent 接手（这样整段历史才会落盘）。
-     * 这样新会话里看到的就是一段真实的多轮对话，而不是一大坨打包文本。
-     * live 会话对象拿不到时，退回「打包成一条消息」的老路径，保证升格不会整体失败。
-     */
-    const handlePromote = async (req, res) => {
-        if (req.method !== 'POST') {
-            sendJson(res, 405, { error: '只支持 POST' });
-            return;
-        }
-        let body;
-        try {
-            body = JSON.parse(await readBody(req, BODY_LIMIT));
-        }
-        catch (error) {
-            sendJson(res, 400, { error: `请求体解析失败：${String(error?.message ?? error)}` });
-            return;
-        }
-        const text = typeof body.text === 'string' ? body.text.trim() : '';
-        if (!text) {
-            sendJson(res, 400, { error: '缺少 text（选中文字）' });
-            return;
-        }
-        const controller = ctx.get('sessionController');
-        if (typeof controller?.create !== 'function' || typeof controller?.prompt !== 'function') {
-            sendJson(res, 503, { error: '当前部署不支持创建会话（sessionController 不可用）' });
-            return;
-        }
-        const sourceSessionId = sessionIdOf(body);
-        const cwd = await resolveSessionCwd(sourceSessionId);
-        // 会话在侧栏里的「项目分组」= workspace 的 sessionIds（按 canonical cwd 索引）。
-        // 只传 cwd 不够：还要带上 workspaceId，并在建好后把它挂到该 workspace 上（双保险）。
-        const registry = ctx.get('workspaceRegistry');
-        let workspaceId;
-        if (cwd) {
-            try {
-                const workspace = await registry?.resolveByPath?.(cwd);
-                if (typeof workspace?.id === 'string')
-                    workspaceId = workspace.id;
-            }
-            catch (error) {
-                ctx.logger?.warn?.(`[${name}] 解析 workspace 失败（${cwd}）：${String(error?.message ?? error)}`);
-            }
-        }
-        try {
-            // 注意：session.create 的 workspaceId 与 cwd 互斥（同时传会报
-            // "session.create accepts workspaceId or cwd, not both"）——有 workspace 就只传它
-            const created = await controller.create(workspaceId ? { workspaceId } : cwd ? { cwd } : {});
-            const newSessionId = typeof created?.sessionId === 'string' ? created.sessionId : '';
-            if (!newSessionId) {
-                sendJson(res, 500, { error: '创建会话失败：未返回会话 id' });
-                return;
-            }
-            // 兜底：若 cwd 索引还没把它算进该 workspace，显式 attach 一次
-            if (workspaceId) {
-                try {
-                    const workspace = registry?.get?.(workspaceId);
-                    if (workspace && !(workspace.sessionIds ?? []).includes(newSessionId)) {
-                        await workspace.attachSession?.(newSessionId);
-                    }
-                }
-                catch (error) {
-                    ctx.logger?.warn?.(`[${name}] 挂载会话到 workspace 失败：${String(error?.message ?? error)}`);
-                }
-            }
-            const title = `划词解读：${text.replace(/\s+/g, ' ').slice(0, 24)}`;
-            try {
-                await controller.rename?.({ sessionId: newSessionId, title });
-            }
-            catch {
-                /* 标题失败不影响升格 */
-            }
-            const label = clampText(body.label, 80) || '页面内容';
-            const contextText = clampText(body.context, config.maxContextChars) || '（未记录）';
-            const translation = clampText(body.translation, 8000);
-            const detail = clampText(body.detail, 12000);
-            const turns = (Array.isArray(body.turns) ? body.turns : [])
-                .slice(-20)
-                .map((turn) => turn)
-                .filter((turn) => turn.seed !== true && typeof turn.text === 'string' && turn.text.trim().length > 0)
-                .map((turn) => ({ role: turn.role === 'assistant' ? 'assistant' : 'user', text: turn.text.trim() }));
-            const live = ctx.get('sessions')?.get?.(newSessionId);
-            let seeded = false;
-            if (live && typeof live.append === 'function') {
-                const stamp = Date.now().toString(36);
-                /**
-                 * 把一轮写进日志：turn/start → step/start → 消息 → step/end → turn/end。
-                 * ⚠️ 必须带这层骨架：客户端会话视图是按 turn/step 事件给消息定位的，
-                 * 裸写 user/message、assistant/message 会因为拿不到坐标而不显示成历史对话。
-                 */
-                // 轮号从 1000 起：客户端按「轮号」分组（Map<number>），而新建会话里 agent 的第一轮
-                // 一定从 1 开始（phase.turn 初始为 0），所以历史轮必须避开低位号段，
-                // 否则历史的 turn 1 会和真实的 turn 1 并成同一组、看起来"历史没进去"。
-                // 同时这也是 resume 语义安全的：resume 时 phase.turn = lastTurn + 1 = 1000+N+1，仍不与历史重号。
-                let turnNo = 1000;
-                const appendTurn = (userEvent, assistantText) => {
-                    turnNo += 1;
-                    const turn = turnNo;
-                    live.append?.('turn/start', { turn });
-                    live.append?.('step/start', { turn, step: 1 });
-                    if (userEvent)
-                        live.append?.('user/message', userEvent, { surfaceOp: 'append' });
-                    live.append?.('assistant/message', {
-                        turn,
-                        step: 1,
-                        stream: [],
-                        message: {
-                            id: `sel-a-${stamp}-${turn}`,
-                            role: 'assistant',
-                            source: { kind: 'model', provider: 'dsh-selection-explain', model: '划词解读小窗' },
-                            content: [{ type: 'text', text: assistantText }],
-                        },
-                    }, { surfaceOp: 'append' });
-                    live.append?.('step/end', { turn, step: 1 });
-                    live.append?.('turn/end', { turn, reason: { kind: 'completed' } });
-                };
-                // 第 1 轮：上下文消息（生产者自有的 source.kind + snapshot 呈现）+ 首轮解读
-                // ⚠️ kind 必须是 PLUGIN_SOURCE_KIND（`plugin:<插件名>`）：会话格式 v4 起不再
-                // 接受退役的 `plugin` 包装（`kind: 'plugin'` 加一个 `plugin` 字段），否则整场升格
-                // 会死在 "format v4 message requires a producer-owned source kind" 上（见文件头常量注释）。
-                const contextBody = [
-                    `选中文字：${text}`,
-                    `所在位置：${label}`,
-                    `来源：划词解读小窗${sourceSessionId ? `（来源会话 ${sourceSessionId}）` : ''}`,
-                    '',
-                    '选中处的上下文片段：',
-                    contextText,
-                ].join('\n');
-                const explanation = ['翻译', translation || '（未记录）', '', '详解', detail || '（未记录）'].join('\n');
-                appendTurn({
-                    id: `sel-ctx-${stamp}`,
-                    role: 'user',
-                    source: {
-                        kind: PLUGIN_SOURCE_KIND,
-                        form: 'snapshot',
-                        sections: [
-                            { name: '划词解读 · 选中文字', text },
-                            { name: '划词解读 · 所在位置', text: label },
-                            { name: '划词解读 · 上下文片段', text: contextText },
-                        ],
-                    },
-                    content: [{ type: 'text', text: contextBody }],
-                }, explanation);
-                // 后续轮：小窗里的追问逐轮写成真实问答
-                for (let i = 0; i < turns.length; i += 1) {
-                    const turn = turns[i];
-                    if (!turn)
-                        continue;
-                    if (turn.role === 'user') {
-                        appendTurn({
-                            id: `sel-u-${stamp}-${i}`,
-                            role: 'user',
-                            source: { kind: 'user' },
-                            content: [{ type: 'text', text: turn.text }],
-                        }, turns[i + 1] && turns[i + 1]?.role === 'assistant' ? (turns[i + 1]?.text ?? '') : '（未记录）');
-                        i += 1; // 助手回答已随本轮写入
-                    }
-                    else {
-                        // 落单的助手消息（历史里没有对应提问）：单独成一轮
-                        appendTurn(null, turn.text);
-                    }
-                }
-                seeded = true;
-            }
-            // ⑤ 开场消息：让 agent 接手（也是整段历史落盘的触发点）
-            const opener = seeded
-                ? '（本会话由划词解读小窗升格而来，以上是这段文字的上下文与我们的讨论）请用一句话确认，然后等我继续提问。'
-                : [
-                    '【划词解读 · 升格为会话】',
-                    '下面这段文字来自一次划词解读小窗；上下文、结论与小窗里的追问一并附上，作为本次会话的既有背景。',
-                    '',
-                    '■ 选中文字',
-                    text,
-                    '',
-                    '■ 所在位置',
-                    label,
-                    '',
-                    '■ 选中处的上下文片段',
-                    contextText,
-                    '',
-                    '■ 解读 · 翻译',
-                    translation || '（未记录）',
-                    '',
-                    '■ 解读 · 详解',
-                    detail || '（未记录）',
-                    ...(turns.length > 0 ? ['', '■ 小窗里的追问', ...turns.map((t) => `${t.role === 'assistant' ? '答' : '我问'}：${t.text}`)] : []),
-                    '',
-                    '以上是背景，请把它作为本次会话的既有上下文；先不需要展开，等我继续提问。',
-                ].join('\n');
-            const promoteController = new AbortController();
-            await controller.prompt({
-                requestId: `sel-promote-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-                sessionId: newSessionId,
-                mode: 'queue',
-                content: [{ type: 'text', text: opener }],
-            }, promoteController.signal);
-            sendJson(res, 200, {
-                ok: true,
-                sessionId: newSessionId,
-                cwd: cwd ?? null,
-                workspaceId: workspaceId ?? null,
-                mode: seeded ? 'history' : 'packed',
-            });
-        }
-        catch (error) {
-            sendJson(res, 500, { error: `升格失败：${String(error?.message ?? error)}` });
-        }
-    };
-    const handleAnalyze = async (req, res) => {
-        if (req.method !== 'POST') {
-            sendJson(res, 405, { error: '只支持 POST' });
-            return;
-        }
-        let body;
-        try {
-            body = JSON.parse(await readBody(req, BODY_LIMIT));
-        }
-        catch (error) {
-            sendJson(res, 400, { error: `请求体解析失败：${String(error?.message ?? error)}` });
-            return;
-        }
-        const text = typeof body.text === 'string' ? body.text.trim() : '';
-        if (text.length === 0) {
-            sendJson(res, 400, { error: '缺少 text（选中文字）' });
-            return;
-        }
-        if (text.length > config.maxSelectionChars) {
-            sendJson(res, 413, { error: `选中文字过长（${text.length} > ${config.maxSelectionChars} 字符）` });
-            return;
-        }
-        if (!allow()) {
-            sendJson(res, 429, { error: `请求过于频繁（上限 ${config.maxRequestsPerMinute}/分钟）` });
-            return;
-        }
-        const override = typeof body.provider === 'string' && typeof body.model === 'string' && body.provider && body.model
-            ? { provider: body.provider, model: body.model }
-            : undefined;
-        // 名字避开下面的 isChat（那里判的是"提示词用追问那套"，此处判的是"模型用追问那个"）
-        const isChatRound = typeof body.question === 'string' && body.question.trim().length > 0;
-        const route = resolveRoute(override, await sessionModelOf(sessionIdOf(body)), isChatRound);
-        if (!route) {
-            sendJson(res, 503, { error: '尚未确定模型路由：请先在设置里选择默认模型后重试' });
-            return;
-        }
-        const context = clampText(body.context, config.maxContextChars);
-        const label = clampText(body.label, 80);
-        // 页面标题/地址不写进提示词：模型会把它当成「选中文字里的英文」去翻译（实测把标题 DSH 译了一遍）
-        // 会话背景：从 sessionQuery 读取当前会话的模型界面（live 优先，含持久化会话）
-        let background = null;
-        if (config.sessionContext) {
-            const sessionId = sessionIdOf(body);
-            if (sessionId) {
-                // 背景预算按阶段：首轮只要翻译（8 条够定指代）；详解与追问都是深度交互，吃满 24 条
-                const stage = typeof body.stage === 'string' ? body.stage : '';
-                const wantsFull = stage === 'detail' || typeof body.question === 'string';
-                background = await loadSessionBackground(sessionId, {
-                    maxMessages: wantsFull ? config.sessionContextMaxMessages : config.sessionContextFastMessages,
-                    maxChars: config.sessionContextMaxChars,
-                    marker: text,
-                });
-            }
-        }
-        // 顺序即缓存策略：前缀必须“只增不变”才能复用 ——
-        //   ① 会话背景（同一会话内基本不变）→ ② 固定说明 → ③ 动态尾部（选中文字/局部片段）
-        // 反过来写（动态在前、背景在后）会让缓存前缀在“选中文字”处就断掉：
-        // 实测同会话换一处选中，命中量从 5760 tokens 掉到 640~768。
-        const stablePrefix = [];
-        if (background && background.transcript) {
-            stablePrefix.push(`【会话背景】（按时间顺序；${background.marked ? '最后一条即选中文字所在的消息，已用 ▶ 标出，其后的对话未包含' : '未能定位选中位置，取的是最近的对话'}）`, background.transcript, '', '上面是会话背景；下面是需要你解读的【选中文字】及其上下文。', '');
-        }
-        const userText = [
-            ...stablePrefix,
-            '【选中文字】',
-            text,
-            '',
-            `【所在位置】${label || '页面内容'}`,
-            '',
-            '【选中处的上下文片段】（选中部分用【】标出）',
-            context || '（未能取到上下文片段，请仅根据选中文字与会话背景作答）',
-        ].join('\n');
-        const effort = typeof body.effort === 'string' && body.effort.length > 0 ? body.effort : config.reasoningEffort;
-        // 追问模式：客户端带 question 时，就是「就这段选中文字继续聊」
-        const question = typeof body.question === 'string' ? body.question.trim() : '';
-        const isChat = question.length > 0;
-        const historyMessages = [];
-        if (isChat) {
-            const rawHistory = Array.isArray(body.history) ? body.history : [];
-            for (const turn of rawHistory.slice(-20)) {
-                const item = turn;
-                const text = typeof item.text === 'string' ? item.text : '';
-                if (!text)
-                    continue;
-                if (item.role === 'assistant') {
-                    historyMessages.push(createAssistantMessage({ content: [{ type: 'text', text }], source: { provider: route.provider, model: route.model } }));
-                }
-                else {
-                    historyMessages.push(createUserMessage({ source: { kind: 'user' }, content: [{ type: 'text', text }] }));
-                }
-            }
-        }
-        const cacheKey = resultKeyOf(route.provider, route.model, sessionIdOf(body) + '|' + effort + '|' + (typeof body.stage === 'string' ? body.stage : 'translation'), background?.transcript ?? '', text, context);
-        const useResultCache = !isChat && config.resultCacheTtlMs > 0 && body.refresh !== true;
-        const cached = useResultCache ? resultCache.get(cacheKey) : undefined;
-        if (cached && Date.now() - cached.at < config.resultCacheTtlMs) {
-            res.writeHead(200, {
-                'content-type': 'text/event-stream; charset=utf-8',
-                'cache-control': 'no-store, no-transform',
-                connection: 'keep-alive',
-                'x-accel-buffering': 'no',
-            });
-            sse(res, {
-                type: 'start',
-                provider: route.provider,
-                model: route.model,
-                cached: true,
-                context: { chars: context.length, label, session: background ? { chars: background.transcript.length, marked: background.marked } : null },
-            });
-            sse(res, { type: 'delta', text: cached.text });
-            sse(res, { type: 'done', chars: cached.text.length, cached: true });
-            res.end();
-            return;
-        }
-        res.writeHead(200, {
-            'content-type': 'text/event-stream; charset=utf-8',
-            'cache-control': 'no-store, no-transform',
-            connection: 'keep-alive',
-            'x-accel-buffering': 'no',
-        });
-        const controller = new AbortController();
-        let finished = false;
-        /** 诊断：客户端（浏览器/探针）在流还没结束时就把连接关了 —— 会让上游被 abort，表现为"输出到一半停了"。 */
-        let clientClosedEarly = false;
-        const timer = setTimeout(() => controller.abort(), config.timeoutMs);
-        res.on('close', () => {
-            if (!finished) {
-                clientClosedEarly = true;
-                ctx.logger?.warn?.(`[${name}] 客户端提前断开（流未结束）：已中止上游，避免继续消耗 token`);
-                controller.abort();
-            }
-        });
-        // 可用工具（白名单，默认只有联网搜索/抓取）：交给模型自己决定要不要用。
-        // 注意工具是「按会话作用域」注册的（全局视图里看不到 web_search 等），
-        // 所以要拿该会话的 agent 当 scope 去查，并把同一个 agent 传给 execute。
-        const agents = ctx.get('agents');
-        const sessionId = sessionIdOf(body);
-        let agent = sessionId ? agents?.get?.(sessionId) : undefined;
-        let agentScope = agent ? 'session' : '';
-        if (!agent) {
-            // 回退：本会话还没起 agent（刚开的新会话／agent 已释放）时，用任一活跃 agent 当作用域。
-            // 不这么做的话，session-scoped 的 web_search/web_fetch 在全局视图里根本不可见 →
-            // 工具静默为空，模型还会把工具调用当正文吐出来（实测见过 <ds_safety_tool_call>）。
-            const live = agents?.list?.() ?? [];
-            if (live.length > 0) {
-                agent = live[0];
-                agentScope = 'fallback';
-            }
-        }
-        const toolSchemas = [];
-        /** 诊断：这一轮是不是走了"备用联网工具"（首选联网工具一个都不在）。 */
-        let toolFallbackUsed = false;
-        if (config.tools && config.maxToolRounds > 0) {
-            const registry = ctx.get('tools');
-            const split = (value) => value.split(',').map((item) => item.trim()).filter((item) => item.length > 0);
-            let visible = [];
-            try {
-                visible = registry?.schemas?.(agent) ?? [];
-            }
-            catch (error) {
-                ctx.logger?.warn?.(`[${name}] 读取工具表失败：${String(error?.message ?? error)}`);
-            }
-            const allowed = resolveToolNames(split(config.toolNames), split(config.fallbackToolNames), visible.map((schema) => schema.name));
-            toolFallbackUsed = !allowed.includes('advanced_search') && !allowed.includes('platform_search');
-            for (const schema of visible) {
-                if (allowed.includes(schema.name))
-                    toolSchemas.push(schema);
-            }
-        }
-        // 本机抓不了网页（fake-IP 代理 / SSRF 防护）时，把 web_fetch 摘掉：
-        // 否则模型每次都要白跑一轮（5~15s）才拿到"resolves to a non-public IP address"。
-        let fetchBlockedSample = '';
-        if (toolSchemas.some((schema) => schema.name === 'web_fetch')) {
-            const probe = await webFetchUsable();
-            if (!probe.usable) {
-                fetchBlockedSample = probe.sample;
-                for (let i = toolSchemas.length - 1; i >= 0; i -= 1) {
-                    if (toolSchemas[i]?.name === 'web_fetch')
-                        toolSchemas.splice(i, 1);
-                }
-                ctx.logger?.warn?.(`[${name}] 网页抓取不可用（域名解析到 ${probe.sample}，属保留地址段），已从工具表移除 web_fetch`);
-            }
-        }
-        // 文件类工具的边界：默认只允许会话工作目录；'*' = 不限制；配置了具体目录就用它。
-        // 拿不到工作目录时**不设限**（否则新会话里 read 直接全废），但会打日志说明。
-        const wantsFsTools = toolSchemas.some((schema) => FS_TOOL_NAMES.includes(schema.name));
-        let readRoot = '';
-        if (wantsFsTools) {
-            if (config.toolReadRoot === '*') {
-                readRoot = '';
-            }
-            else {
-                readRoot = config.toolReadRoot || (await resolveSessionCwd(sessionIdOf(body))) || '';
-                if (!readRoot)
-                    ctx.logger?.warn?.(`[${name}] 拿不到会话工作目录，文件工具本次不设边界`);
-            }
-        }
-        const stage = typeof body.stage === 'string' ? body.stage : '';
-        // 选中文字是代码：首轮走「注释」提示词（代码块 + 逐句注释 + 小结）
-        const isCode = body.kind === 'code';
-        const basePrompt = isChat
-            ? CHAT_SYSTEM_PROMPT
-            : stage === 'detail'
-                ? DETAIL_PROMPT
-                : isCode
-                    ? CODE_PROMPT
-                    : TRANSLATION_PROMPT;
-        // 一个工具都没有时明确禁止伪造调用（模型会照着自己的习惯吐 <ds_safety_tool_call> 之类的格式）
-        // 正文里不许写"盘算过程"（模型在工具轮里很容易把"I should search again…"这类写进正文）
-        const narrateRule = '\n\n【正文只写结论】不要把思考、盘算、自查过程写进正文（"我还得再搜一次""先看看拿到的标题""让我确认一下"这类一律不写）；需要工具就直接调用，调用前后都不要解说。';
-        // 输出偏好（小窗开关）：左档 Markdown / 右档 网页。
-        // 关档也要明确说"用 Markdown"——否则标签写着 Markdown、行为却可能自己给整页 HTML，开关就名不副实。
-        let webRule = '';
-        if (isChat && body.webAnswer !== true) {
-            webRule =
-                '\n\n【输出偏好：Markdown】用户把输出偏好设为 Markdown：默认用普通文字/Markdown 回答' +
-                    '（标题、列表、表格、代码块都可以）。' +
-                    '**这不禁止 HTML**——如果这个问题用一页 HTML 明显讲得更清楚，照样可以用网页回答；' +
-                    '只是不要单纯为了"好看"就把简单问题做成页面。';
-        }
-        if (isChat && body.webAnswer === true) {
-            const skill = await loadDesignSkill();
-            webRule =
-                '\n\n【输出偏好：网页】这不是"一律用网页"，而是**网页优先**：\n' +
-                    '- **复杂问题**（需要对比、流程、层级、图表，或者文字答案会长到不好读）→ 直接给完整的单文件 HTML' +
-                    '（放进 ```html 代码块），**页面本身就是答案**，不要再用文字复述一遍；\n' +
-                    '- **简单问题**（一两段话能说清、不需要并列或图示）→ **仍然直接用文字回答**。' +
-                    '不要为了用网页而用网页，也不要把简单问题包装成页面。\n' +
-                    '拿不准时按"能不能用一小段话讲清"来判断：能，就文字。\n' +
-                    '用网页时，页面会渲染在大约 **500px 宽**的小窗里，按下面的设计规范做：\n\n' +
-                    skill +
-                    (body.theme === 'dark'
-                        ? '\n\n【配色：跟随宿主，当前是深色】宿主界面此刻是**深色模式**，页面必须是深色：' +
-                            '背景用 #16181c~#1f2126 一档，正文 #e6e6e6，次级文字 #a1a1aa，分隔线 rgba(255,255,255,.12)，' +
-                            '卡片底色比页面底再亮一档。**不要白底黑字**，也不要只写 prefers-color-scheme（宿主的深浅由用户设置决定，与系统不一定一致）。\n'
-                        : '\n\n【配色：跟随宿主，当前是浅色】宿主界面此刻是**浅色模式**，页面必须是浅色：' +
-                            '背景用 #ffffff~#f7f7f8 一档，正文 #171717，次级文字 #6b7280，分隔线 rgba(0,0,0,.10)，' +
-                            '卡片底色与页面底拉开一档。**不要深色底**，也不要只写 prefers-color-scheme（宿主的深浅由用户设置决定，与系统不一定一致）。\n');
-        }
-        const fileRule = wantsFsTools
-            ? `\n\n【文件访问】你可以用 read/grep/glob 查看当前项目里的文件（范围：${readRoot || '不限'}）。超出该范围的路径会被拒绝；引用文件内容时只取必要的一两行，不要整段粘贴。`
-            : '';
-        const fetchRule = fetchBlockedSample
-            ? `\n\n【抓取网页不可用】本机域名解析到保留地址段（${fetchBlockedSample}），网页抓取会被安全策略拒绝：只做联网搜索，**不要尝试抓取具体网址**（省掉一次注定失败的往返）。`
-            : '';
-        const systemPrompt = (toolSchemas.length > 0
-            ? basePrompt
-            : `${basePrompt}\n\n【本轮没有可用工具】不要输出任何工具调用格式（如 <ds_safety_tool_call>、tool_calls、JSON 形式的调用），也不要声称你查过；需要实时/外部信息时直接说明你无法联网或无法读取，只基于已知信息作答。`) +
-            narrateRule +
-            webRule +
-            fileRule +
-            fetchRule;
-        // 三档分开：翻译（默认 low，只要快）／详解（默认 reasoningEffort=high，要深）／追问（chatReasoningEffort=high，要准）
-        // 三档分开：翻译（默认 low，只要快）／详解（默认 reasoningEffort=high，要深）／追问（默认 chatReasoningEffort=high）
-        // 但**追问档**允许请求覆盖（小窗的「推理等级（追问档）」控件靠这条生效）：
-        // 首轮/详解仍按各自的配置走 —— 首轮故意用低档换速度，不该被追问档的设置带跑。
-        await loadLeaky();
-        let bodyEffort = typeof body.effort === 'string' && body.effort.length > 0 ? body.effort : '';
-        // 这个模型在"关"档会把思考写进正文（实测过）：别再发 none，直接抬到 low —— 既没泄漏，也不慢
-        const routeKey = `${route.provider}/${route.model}`;
-        if (isChat && bodyEffort === 'off' && leakyOnOff.has(routeKey)) {
-            bodyEffort = 'low';
-            sse(res, {
-                type: 'notice',
-                code: 'effort-clamped',
-                tier: 'off',
-                text: '该模型在「关」档会把思考写进正文，已自动改用「低」档',
-            });
-        }
-        let requestEffort = isChat
-            ? bodyEffort || config.chatReasoningEffort || effort
-            : stage === 'detail'
-                ? effort
-                : config.translationReasoningEffort || effort;
-        // 已知这个模型不接受"关"档（之前撞过一次并记下来了）：直接换 low，不再先失败一轮。
-        // 首轮默认就是 off，所以这条对"默认配置 + 不吃 off 的模型"是必经之路。
-        if (requestEffort === 'off' && noOffRoutes.has(routeKey))
-            requestEffort = 'low';
-        // 规范四格 → 这个模型真实声明的档位（每次请求现算；'' = 这个模型不支持推理，干脆不带档位）。
-        // 注意：leaky / noOff 两条守卫仍在**规范档位**这一层判断（它们记的是"关档"的语义），
-        // 映射放在最后一步。
-        const sentEffort = effortForRoute(routeKey, requestEffort);
-        // 「关」这一格在这个模型上到底是哪个真实档位：重试判定与泄漏检查都要按**真实档位**比
-        // （模型可能没有 off，或叫 none/minimal —— 那就不能拿字符串 'off' 去比）
-        const offSlotEffort = requestEffort === 'off' ? sentEffort : effortForRoute(routeKey, 'off');
-        sse(res, {
-            type: 'start',
-            provider: route.provider,
-            model: route.model,
-            mode: isChat ? 'chat' : stage === 'detail' ? 'detail' : isCode ? 'code' : 'translation',
-            stage: stage === 'detail' ? 'detail' : 'translation',
-            backgroundMessages: background ? background.transcript.split('\n').filter((line) => /^\s*(▶\s*)?(用户|助手)：/.test(line)).length : 0,
-            effort: sentEffort,
-            tools: toolSchemas.map((schema) => schema.name),
-            toolScope: agentScope,
-            ...(toolFallbackUsed ? { toolFallbackUsed: true } : {}),
-            ...(wantsFsTools ? { readRoot: readRoot || '(不限)' } : {}),
-            ...(fetchBlockedSample ? { fetchBlocked: fetchBlockedSample } : {}),
-            context: {
-                chars: context.length,
-                label,
-                session: background
-                    ? {
-                        chars: background.transcript.length,
-                        marked: background.marked,
-                        // 背景短哈希：用于核对「前缀是否真的没变」（缓存命中的前提）
-                        hash: createHash('sha1').update(background.transcript).digest('hex').slice(0, 10),
-                    }
-                    : null,
-            },
-            ...(body.debug === true
-                ? { debug: { system: systemPrompt, user: userText, sizes: { system: systemPrompt.length, user: userText.length } } }
-                : {}),
-        });
-        let chars = 0;
-        const baseMessage = createUserMessage({
-            source: { kind: 'user' },
-            content: [{ type: 'text', text: userText }],
-        });
-        // 上一轮查过的东西一并带上：否则追问会反复重查同样的内容（一次工具往返 20~34s）
-        const toolDigest = typeof body.toolDigest === 'string' ? body.toolDigest.trim().slice(0, 2000) : '';
-        // 顺序很重要：把"已经查到的结果"放**前面**、问题放**最后**。
-        // 反过来的话，模型最后读到的是原始检索结果，容易"整理资料"而不是回答问题
-        //（实测：问新闻却把上一次的检索结果当成要总结的对象）。
-        const questionText = toolDigest
-            ? `【本会话已经查到的结果】（同一会话里查过的，不要重复查同样的内容；只在与本轮问题相关时才用）\n${toolDigest}\n\n【用户这一轮的问题】\n${question}`
-            : question;
-        const openingMessages = isChat
-            ? [...historyMessages, createUserMessage({ source: { kind: 'user' }, content: [{ type: 'text', text: questionText }] })]
-            : [];
-        try {
-            let errored = false;
-            let usage = null;
-            let answer = '';
-            const toolMessages = [];
-            let toolCalls = 0;
-            // 允许的工具轮 + 1 个**收尾轮**：收尾轮不带任何工具。
-            // 不加这一轮的话，模型每轮都调工具时循环直接结束，正文是空的——
-            // 用户看到的就是"转了半天，但没有任何回答"。
-            let errorMessage = '';
-            let errorCode;
-            const toolDigestLines = [];
-            /** 被残渣过滤器丢掉的字数：末尾那些"模型顺手又调了一次工具"的标记会让正文停在半句上。 */
-            /**
-             * 逐轮诊断（放进 done 事件）：原始字数 / 过滤后字数 / 思考字数 / 残渣丢弃 / finish 原因 / 输出 tokens。
-             * 用来回答"到底是模型没吐、还是被我们的过滤器吃掉了、还是上游掐流"——不靠猜。
-             */
-            const roundDiag = [];
-            let conclusionInfo = {
-                tried: false,
-                chars: 0,
-                rounds: 0,
-                error: '',
-            };
-            const toolRounds = config.maxToolRounds;
-            // 档位被上游拒绝时（400/401/500）重试一次：清单里声明的档位是**建议值**，
-            // 实测很多模型并不接受 max（qwen3.7-max 直接 400、minimax-m2.7/gpt-5.6-luna 500）。
-            //
-            // 以前这里限定了 `isChat && bodyEffort.length > 0` —— 只有追问、且客户端显式传了档位才重试。
-            // 于是**首轮**（档位来自配置、默认 off）撞上不吃 off 的模型时无人兜底，整个划词解读全挂。
-            // 现在按"这一轮实际在发显式档位"判，三种轮次一视同仁。
-            //
-            // 2026-10-09 改：重试**不再"去掉档位"**，而是换一个没试过的档（见 nextEffortFor）。
-            // 老代码对非 off 档的重试是 `roundEffort = ''`（省略 reasoning），
-            // 而省略对"必须开推理"的端点就是关掉推理 —— 实测 20 次重试 0 次成功。
-            // 同时给两次机会：上游偶发失败约一半，两次能把成功率抬到 ~90%（代价是多一次往返）。
-            const EFFORT_RETRY_LIMIT = 2;
-            // 重试与"泄漏检查"都看**真正发出去**的那个档位（sentEffort，映射之后的值）：
-            // 规范档位是"关"、但这个模型的关档叫 none/minimal 时，检查的必须是发出去的那个。
-            let effortRetries = sentEffort.length > 0 ? EFFORT_RETRY_LIMIT : 0;
-            const triedEfforts = new Set(sentEffort ? [sentEffort] : []);
-            const firstSentEffort = sentEffort;
-            let roundEffort = sentEffort;
-            for (let round = 0; round <= toolRounds; round += 1) {
-                const roundStartedAt = Date.now();
-                const wrapUp = round === toolRounds;
-                const stream = ctx.llm.stream({
-                    provider: route.provider,
-                    model: route.model,
-                    // 带上会话 id：主会话 agent loop 一直传它，适配器会据此设置上游的会话头。
-                    // 插件以前没传，结果是所有小窗请求共用静态会话头 —— 而中继是按会话跟踪的（实测长回答被掐）。
-                    ...(sessionId ? { sessionId: sessionId } : {}),
-                    system: undefined,
-                    messages: [
-                        // 第二参数（组装这段提示词的插件名）：**新老版本签名不一样，两边都得能编译**——
-                        //   · npm 上按 peer 范围 `>=0.1.5-rc <2` 解析到的是 0.1.5-rc.3：`(text, plugin)` 两个必填
-                        //     （CI 就是拿这份类型做构建校验的，少传就 TS2554）；
-                        //   · 本机 / 新版运行时（0.1.7-rc.x）：只剩 `(text)`，多传的参数会被忽略。
-                        // 所以统一走 systemMessageOf 这个宽松别名（见文件下方的定义），两边都调得动。
-                        systemMessageOf(wrapUp
-                            ? `${systemPrompt}\n\n【收尾】工具轮次已用完：直接基于已经拿到的信息给出结论，不要再请求工具，也不要复述查询过程。` +
-                                '正文里不要出现任何工具调用格式（包括 DeepSeek 的 DSML 写法，如 invoke/parameter 标记）——那些会被当作乱码展示给用户。'
-                            : systemPrompt, name),
-                        ...(round === 0 ? [baseMessage, ...openingMessages] : [baseMessage, ...openingMessages, ...toolMessages]),
-                    ],
-                    // 工具**每轮都在请求里**（照主会话的做法）：收尾轮以前故意不带工具"逼结论"，
-                    // 结果模型退到文本层、把工具调用标记写进正文（实测 wrapUp 轮 raw=726 → emitted=0）。
-                    // 主会话从不摘工具，模型也就从不写这种标记 —— 这里与它保持一致。
-                    ...(toolSchemas.length > 0 ? { tools: toolSchemas } : {}),
-                    ...(config.temperature >= 0 ? { temperature: config.temperature } : {}),
-                    ...(config.maxTokens > 0 ? { maxTokens: config.maxTokens } : {}),
-                    ...(roundEffort ? { reasoningEffort: ReasoningEffortId(roundEffort) } : {}),
-                    signal: controller.signal,
-                });
-                const assembler = new BlockAssembler();
-                // 本轮吐出的正文字数：这一轮如果最后是要调工具，那这些字其实是"过程旁白"
-                // （"我还得再搜一次""先看看拿到的标题"这类），要被撤回，不能当成答案留在小窗里
-                let roundText = '';
-                // 有的模型把思考内联在正文里（<think>…</think>）：拆出来走 thought，别当答案
-                // 每轮一个过滤器：未闭合的残渣块只在本轮内作废。
-                // 共用一个的话，某一轮吐了未闭合的 DSML（实测收尾轮很常见）会让 depth 一直 >0，
-                // 后面所有轮次的正文都被吞掉 —— 表现就是"只完成了工具查询，没有产出正文"（用户截图报的）。
-                const think = createThinkFilter();
-                let roundRaw = 0;
-                let roundEmitted = 0;
-                let roundThink = 0;
-                let roundFinish = '';
-                /** 诊断用：本轮最后若干分片的类型与大小（看上游是发了 finish 还是直接断流）。 */
-                const tailChunks = [];
-                const emit = (part) => {
-                    if (part.think) {
-                        roundThink += part.think.length;
-                        sse(res, { type: 'thought', text: part.think });
-                    }
-                    // 残渣过滤放在 think 之后：先分出思考，再把正文里的工具调用标记丢掉
-                    const text = part.text;
-                    if (text) {
-                        roundEmitted += text.length;
-                        chars += text.length;
-                        answer += text;
-                        roundText += text;
-                        sse(res, { type: 'delta', text: text });
-                    }
-                };
-                for await (const chunk of stream) {
-                    assembler.push(chunk);
-                    if (body.debug === true) {
-                        const size = chunk.type === 'text-delta' ? chunk.text.length : 0;
-                        tailChunks.push(`${chunk.type}:${size}`);
-                        if (tailChunks.length > 14)
-                            tailChunks.shift();
-                    }
-                    if (chunk.type === 'text-delta') {
-                        roundRaw += chunk.text.length;
-                        emit(think.push(chunk.text));
-                    }
-                    else if (chunk.type === 'reasoning-delta') {
-                        // 思考过程也透传：首字前那几秒如果只有转圈，用户会以为卡死了。
-                        // 客户端只留尾部一小段当"正在想什么"的提示，不进正文。
-                        sse(res, { type: 'thought', text: chunk.text });
-                    }
-                    else if (chunk.type === 'usage') {
-                        usage = chunk.usage;
-                    }
-                    else if (chunk.type === 'finish') {
-                        roundFinish = String(chunk.reason.kind);
-                        if (chunk.reason.kind === 'error' || chunk.reason.kind === 'aborted') {
-                            errored = true;
-                            // 先只记下来：如果接下来要"换档重试"，这条错误就不该发给用户
-                            // （否则客户端先渲染一条失败提示，重试的正文就贴在失败提示后面了）
-                            errorMessage =
-                                chunk.reason.failure?.message ?? `模型调用${chunk.reason.kind === 'aborted' ? '被中断' : '失败'}`;
-                            errorCode = chunk.reason.failure?.code;
-                        }
-                    }
-                }
-                emit(think.flush());
-                roundDiag.push({
-                    round,
-                    wrapUp,
-                    ms: Date.now() - roundStartedAt,
-                    raw: roundRaw,
-                    emitted: roundEmitted,
-                    think: roundThink,
-                    finish: roundFinish || '(none)',
-                    tools: assembler.blocks().filter((block) => block.type === 'tool-call').length,
-                    ...(body.debug === true ? { tailChunks } : {}),
-                    outTokens: usage?.outputTokens,
-                });
-                if (errored) {
-                    // 一个字都没吐出来 → 可以安全重试**同一轮**（保守：已经吐出正文的失败不重试，
-                    // 免得把半截答案丢掉）。重试换一个没试过的档位，而不是把档位去掉。
-                    if (roundText.length === 0 && effortRetries > 0) {
-                        const rejected = roundEffort;
-                        const next = nextEffortFor(routeKey, rejected, triedEfforts);
-                        if (next) {
-                            effortRetries -= 1;
-                            triedEfforts.add(next);
-                            // 只有"我们发的这个档位确实不被接受"才值得记成事实：
-                            //   · 发的是关档 + 上游说"必须开推理" → 这个 route 不吃关档，记下来；
-                            //   · 发的是开着的档（low/high/max）+ 上游还在说"推理不能关" → **这句不是冲我们来的**
-                            //     （我们没关它），是上游偶发抽风（实测同档位 5/8 成功）。这种情况不记、不诊断，
-                            //     只如实说"上游返回了错误，已换档重试"。
-                            // "必须开推理"这句只有在我们发的是**「关」那一格对应的真实档位**时才算数
-                            // （模型没有 off、关档落在 minimal/low 上时，字符串比较会漏判）
-                            const rejectedOffSlot = rejected === offSlotEffort;
-                            const tierIssue = rejectedOffSlot
-                                ? looksLikeReasoningRequired(errorMessage)
-                                : looksLikeUnsupportedTier(errorMessage);
-                            if (rejectedOffSlot && tierIssue)
-                                markNoOff(routeKey);
-                            requestEffort = next;
-                            roundEffort = next;
-                            errored = false;
-                            sse(res, {
-                                type: 'notice',
-                                code: tierIssue ? 'effort-rejected' : 'upstream-retry',
-                                ...(tierIssue ? { tier: rejected } : {}),
-                                text: tierIssue
-                                    ? rejectedOffSlot
-                                        ? `该模型不接受「关」档，已自动改用「${EFFORT_LABEL[next] ?? next}」档（以后不再尝试关档）`
-                                        : `「${EFFORT_LABEL[rejected] ?? rejected}」档该模型不支持，已改用「${EFFORT_LABEL[next] ?? next}」档重试`
-                                    : '上游这次返回了错误，已自动重试',
-                            });
-                            round -= 1;
-                            continue;
-                        }
-                    }
-                    sse(res, { type: 'error', message: errorMessage, code: errorCode });
-                    break;
-                }
-                const blocks = assembler.blocks();
-                const calls = blocks.filter((block) => block.type === 'tool-call');
-                if (calls.length === 0) {
-                    // 最终答案到手：如果发出去的是「关」那一格对应的真实档位，检查有没有把思考写进正文
-                    if (isChat && firstSentEffort === offSlotEffort) {
-                        const split = splitLeakedReasoning(answer);
-                        if (split.prefix) {
-                            markLeaky(routeKey);
-                            answer = split.rest;
-                            chars = answer.length;
-                            sse(res, { type: 'strip', text: split.prefix });
-                            sse(res, {
-                                type: 'notice',
-                                code: 'reasoning-leak',
-                                // 报**真实档位**（模型可能没有 off，叫 none/minimal）：客户端据此标对那个档位按钮
-                                tier: firstSentEffort,
-                                text: '该模型在「关」档会把思考写进正文，已撤回泄漏段；以后这一档会自动改用「低」',
-                            });
-                        }
-                        else if (looksLikeLeakedReasoning(answer)) {
-                            // 句式没认准（模型每次换说法）→ 这次不裁（怕误删正文），但记住它，下次自动抬档
-                            markLeaky(routeKey);
-                            sse(res, {
-                                type: 'notice',
-                                code: 'reasoning-leak',
-                                tier: firstSentEffort,
-                                text: '这个模型在「关」档会把思考写进正文；这一档以后自动改用「低」',
-                            });
-                        }
-                    }
-                    break;
-                }
-                // 既然这一轮要调工具，它刚才流出来的正文就是"过程旁白"，不是答案：
-                // 让前端把这部分撤回去（顺带当成思考尾巴显示），免得"我怎么想的"混进小窗正文。
-                // 实测踩过：追问"搜索今天的新闻"时，模型在工具轮里先吐了一段英文盘算
-                // （I have sources with dates… Maybe I should do one more search…），
-                // 然后才给中文结论，这段英文被当正文渲染进了消息框。
-                if (roundText.length > 0) {
-                    answer = answer.slice(0, Math.max(0, answer.length - roundText.length));
-                    sse(res, { type: 'drop', chars: roundText.length, text: roundText.slice(-2000), round });
-                }
-                // 有的模型不带工具定义也会返回调用；执行端同样遵守开关和轮数上限。
-                if (wrapUp || toolSchemas.length === 0)
-                    break;
-                // 执行工具→把结果回灌，再让模型继续（上限 maxToolRounds 轮）
-                toolMessages.push(createAssistantMessage({
-                    content: blocks,
-                    source: { provider: route.provider, model: route.model },
-                }));
-                for (const call of calls) {
-                    if (call.type !== 'tool-call')
-                        continue;
-                    toolCalls += 1;
-                    let parsed = {};
-                    try {
-                        parsed = call.arguments ? JSON.parse(call.arguments) : {};
-                    }
-                    catch {
-                        parsed = {};
-                    }
-                    const label2 = describeToolCall(call.name, parsed);
-                    const callId = String(call.id ?? `round${String(round)}-${String(toolCalls)}`);
-                    sse(res, { type: 'tool', phase: 'start', callId, name: call.name, detail: label2, round });
-                    const startedAt = Date.now();
-                    // 参数名有讲究：read/write/edit 用 file_path，grep/glob 用 path。
-                    // 只认 path 的话 read 的 file_path 会是 undefined → 边界检查被静默绕过（实测踩过）。
-                    const rawPath = parsed?.file_path ?? parsed?.path;
-                    const wantPath = typeof rawPath === 'string' ? rawPath : '';
-                    const execution = !toolSchemas.some((schema) => schema.name === call.name)
-                        ? { content: [{ type: 'text', text: `（调用已拒绝：${call.name} 不在本次允许的工具中）` }], isError: true }
-                        : FS_TOOL_NAMES.includes(call.name) && !isInsideRoot(readRoot, wantPath)
-                            ? {
-                                content: [
-                                    {
-                                        type: 'text',
-                                        text: `（越界已拒绝：文件类工具只能访问当前项目目录${readRoot ? `（${readRoot}）` : ''}，请求的路径是 ${wantPath || '(未给)'}）`,
-                                    },
-                                ],
-                                isError: true,
-                            }
-                            : await runTool(ctx, call.name, parsed, controller.signal, config.toolResultMaxChars, agent);
-                    // 结果也回传：小窗里能看见"查了什么、命中什么、链接是什么"，否则工具是个黑盒
-                    const digest = digestToolResult(execution.content);
-                    sse(res, {
-                        type: 'tool',
-                        phase: 'done',
-                        callId,
-                        name: call.name,
-                        detail: label2,
-                        round,
-                        ok: !execution.isError,
-                        ms: Date.now() - startedAt,
-                        chars: digest.chars,
-                        preview: digest.preview,
-                        urls: digest.urls,
-                    });
-                    toolMessages.push(createToolResultMessage({ callId: call.id, content: execution.content, isError: execution.isError }));
-                    // 结论轮要用：把"查了什么 + 拿到了什么"写成纯文本，避免重放工具调用链
-                    toolDigestLines.push(`· ${call.name}（${label2 || '查询'}）：${digest.preview}`);
-                }
-            }
-            if (!errored && answer.trim().length === 0 && toolCalls > 0 && triedEfforts.size === 1) {
-                // 收尾轮常常"只吐一段工具调用、不写正文"（实测「今天的新闻」一个字都没有）。
-                // 这里自己补结论轮：**不重放工具调用链**，而是把结果写成一段自包含的提示 ——
-                // 重放消息链的方式实测也不稳（模型面对 tool-call 历史仍可能继续吐工具调用）。
-                conclusionInfo.tried = true;
-                sse(res, { type: 'notice', code: 'conclusion-retry', text: '查询已完成，正在整理结论…' });
-                const conclusionUser = [
-                    // ⚠️ **必须带上用户这一轮问的是什么**：这一段是最终正文的来源，而它以前只有
-                    // 「选区块 + 检索资料 + 请给出最终答案」—— 模型看不到问题，就只能顺着选中文字写。
-                    // 实测症状：问"搜索今天的AI新闻。"，正文却在解释选区那个词（如 diagLog / exit）。
-                    // 特别是收尾轮也带上工具之后（照主会话的做法），正文**每次都**由这里产出，
-                    // 缺了问题就等于每次都答非所问。
-                    question ? `【用户这一轮的问题】（这就是你要回答的对象）\n${question}` : '',
-                    '',
-                    '【选中文字】（只是背景资料：问题需要它时才引用，不要拿它当回答的对象）',
-                    userText,
-                    '',
-                    '【已经查到的资料】',
-                    ...toolDigestLines.slice(0, 12),
-                    '',
-                    '请**直接回答上面那条「用户这一轮的问题」**：结论先行、必要处带来源链接。',
-                    '不要复述选中文字，也不要解释它是什么 —— 除非问题问的就是它。',
-                    '不要再请求工具，不要输出任何工具调用格式，也不要写"我先看看""让我核对一下"这类过程。',
-                ].join('\n');
-                // 先按当前档位试一次；空则**换一个档位**再试（同一档重发没意义）。
-                // 以前这里写死 `'off'`：对"必须开推理"的端点（noOffRoutes 里的那些）等于注定失败一轮 ——
-                // 用户看到的"工具查询完成了，但模型没有产出正文"就常有它一份。
-                const conclusionEfforts = [
-                    roundEffort,
-                    nextEffortFor(routeKey, roundEffort, new Set(roundEffort ? [roundEffort] : [])),
-                ].filter((id) => id.length > 0);
-                for (const attemptEffort of conclusionEfforts) {
-                    if (answer.trim().length > 0)
-                        break;
-                    conclusionInfo.rounds += 1;
-                    try {
-                        const resume = ctx.llm.stream({
-                            provider: route.provider,
-                            model: route.model,
-                            ...(sessionId ? { sessionId: sessionId } : {}),
-                            system: undefined,
-                            // 工具**依然带着**（照主会话：任何一轮都不摘工具）。
-                            // 以前这一轮不带工具，模型要调工具时只能退回文本层 —— 那正是正文里出现
-                            // DSML / ds_safety_tool_call 标记的唯一来源。带上之后它走协议层，正文就是正文。
-                            ...(toolSchemas.length > 0 ? { tools: toolSchemas } : {}),
-                            messages: [
-                                // 同上：多传的插件名在老版本运行时会被忽略，新版本类型上却是必填
-                                systemMessageOf(systemPrompt, name),
-                                createUserMessage({ source: { kind: 'user' }, content: [{ type: 'text', text: conclusionUser }] }),
-                            ],
-                            ...(config.temperature >= 0 ? { temperature: config.temperature } : {}),
-                            ...(config.maxTokens > 0 ? { maxTokens: config.maxTokens } : {}),
-                            ...(attemptEffort ? { reasoningEffort: ReasoningEffortId(attemptEffort) } : {}),
-                            signal: controller.signal,
-                        });
-                        const thinkAgain = createThinkFilter();
-                        for await (const chunk of resume) {
-                            if (chunk.type === 'text-delta') {
-                                const part = thinkAgain.push(chunk.text);
-                                if (part.think)
-                                    sse(res, { type: 'thought', text: part.think });
-                                const text = part.text;
-                                if (text) {
-                                    chars += text.length;
-                                    answer += text;
-                                    conclusionInfo.chars += text.length;
-                                    sse(res, { type: 'delta', text: text });
-                                }
-                            }
-                            else if (chunk.type === 'usage') {
-                                usage = chunk.usage;
-                            }
-                            else if (chunk.type === 'finish') {
-                                if (chunk.reason.kind === 'error') {
-                                    conclusionInfo.error = chunk.reason.failure?.message ?? '模型调用失败';
-                                }
-                            }
-                        }
-                        for (const tail of [thinkAgain.flush()])
-                            if (tail.think)
-                                sse(res, { type: 'thought', text: tail.think });
-                        // 结论轮也可能把"英文核对过程"写进正文：一律按泄漏裁一次
-                        const leaked = splitLeakedReasoning(answer);
-                        if (leaked.prefix) {
-                            answer = leaked.rest;
-                            chars = answer.length;
-                            sse(res, { type: 'strip', text: leaked.prefix });
-                            sse(res, { type: 'notice', code: 'reasoning-leak', text: '已去掉模型写进正文的核对过程' });
-                        }
-                    }
-                    catch (error) {
-                        conclusionInfo.error = String(error?.message ?? error);
-                        ctx.logger?.warn?.(`[${name}] 结论轮失败：${conclusionInfo.error}`);
-                    }
-                }
-            }
-            if (!errored && answer.trim().length === 0) {
-                // 兜底：连结论轮都没吐字时，至少给一句话（否则面板空白，看起来像"没返回结果"）
-                const note = toolCalls > 0
-                    ? '（工具查询完成了，但模型没有产出正文。可以再追问一句"直接说结论"，我按已查到的结果回答。）'
-                    : '（模型这次没有返回内容，可以点「重新生成」再试一次。）';
-                answer = note;
-                chars += note.length;
-                sse(res, { type: 'delta', text: note });
-            }
-            if (!errored) {
-                sse(res, {
-                    type: 'done',
-                    chars,
-                    usage,
-                    toolCalls,
-                    // 诊断用：结论轮/续写各试了几次、拿到多少字、失败原因
-                    ...(conclusionInfo.tried ? { conclusion: conclusionInfo } : {}),
-                    ...(roundDiag.length > 0 ? { rounds: roundDiag } : {}),
-                    clientClosedEarly,
-                });
-                if (useResultCache && answer.length > 0) {
-                    resultCache.set(cacheKey, { at: Date.now(), text: answer });
-                    if (resultCache.size > 200) {
-                        const oldest = resultCache.keys().next().value;
-                        if (oldest !== undefined)
-                            resultCache.delete(oldest);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            const err = error;
-            const aborted = err?.name === 'AbortError';
-            sse(res, {
-                type: 'error',
-                message: aborted ? `调用超时或已取消（${config.timeoutMs}ms）` : String(err?.message ?? err),
-            });
-        }
-        finally {
-            finished = true;
-            clearTimeout(timer);
-            res.end();
-        }
-    };
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/analyze`, handler: handleAnalyze }), `${name}: analyze route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/settings`, handler: handleSettings }), `${name}: settings route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/route`, handler: handleRoute }), `${name}: route route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/ping`, handler: handlePing }), `${name}: ping route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/history`, handler: handleHistory }), `${name}: history route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/panel`, handler: handlePanelSize }), `${name}: panel box route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/pill`, handler: handlePillPos }), `${name}: pill position route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/mic`, handler: handleMic }), `${name}: mic presence route`);
-    // 探针是懒启动的（第一次有人问才起），但**卸载时要收干净**：
-    // 否则插件热重载几次就会留下一串没人管的 mic-probe 进程。
-    ctx.effect(() => () => stopMicProbe(), `${name}: mic probe process`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/models`, handler: handleModels }), `${name}: models route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/promote`, handler: handlePromote }), `${name}: promote route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/quote-context`, handler: handleQuoteContext }), `${name}: quote-context route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/speech`, handler: handleSpeech }), `${name}: speech catalog route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/speech/transcribe`, handler: handleSpeechTranscribe }), `${name}: speech transcribe route`);
-    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/speech/prepare`, handler: handleSpeechPrepare }), `${name}: speech prepare route`);
-    ctx.logger?.info?.(`[${name}] 划词解读路由就绪：${API_PREFIX}/analyze`);
-}
-/**
- * 纯函数内部件，仅供单测直接调用（Cordis 只用 default export，多这几个具名导出没有副作用）。
- * 这三个都是"流式文本手术刀"，靠真实请求验证会被模型的随机发挥带偏，必须能确定性单测。
- */
+/** Public DSH plugin entry; implementation lives in host/. */
+export { name, inject, PLUGIN_SOURCE_KIND } from './host/constants.js';
+export { Config } from './host/config.js';
+export { apply } from './host/plugin.js';
+export { validateWave } from './host/speech.js';
+export { isInsideRoot } from './host/tools.js';
+export { transcriptOf, quoteContextOf } from './host/context.js';
+import { createThinkFilter, splitLeakedReasoning, looksLikeLeakedReasoning } from './host/filters.js';
+import { resolveToolNames } from './host/tools.js';
+import { looksLikeUnsupportedTier, looksLikeReasoningRequired, pickNextEffort, mapEffortToModel, effortMapOf } from './host/effort.js';
 export const __internals = {
     createThinkFilter,
     splitLeakedReasoning,