@yfwu2020/dsh-selection-explain 0.9.0 → 0.10.0

package/lib/index.js

@@ -12,9 +12,12 @@
  */
 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';
@@ -48,6 +51,170 @@ 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（缺省值即推荐值）。 */
@@ -117,6 +284,10 @@ export const Config = z.object({
     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'];
@@ -249,6 +420,244 @@ function looksLikeLeakedReasoning(text) {
     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)
@@ -283,113 +692,6 @@ function splitLeakedReasoning(text) {
         return { prefix: '', rest: body };
     return { prefix: head, rest: tail };
 }
-/**
- * 正文里不该出现的"工具调用残渣"。
- *
- * 收尾轮**不带工具**（为了逼模型给结论），模型这时会把"还想再 read 一下"当正文吐出来，
- * 而且用的可能是两种格式之一：
- *   ① 官方 safety 包装：`<ds_safety_tool_call>…</ds_safety_tool_call>`（客户端以前只认这个）
- *   ② DeepSeek 原生 DSML：全角竖线包起来的 `tool_calls / invoke / parameter` 块（实测漏过正文）
- *
- * 这里在**流里**就把它滤掉：客户端连 delta 都收不到，存盘/升格的内容也是干净的。
- * （客户端那份 sanitizeToolResidue 留作兜底：旧缓存、历史回放这些路径不经过 host。）
- */
-/** 全角竖线（U+FF5C）×2 + DSML + ×2：DSML 标记本身，用它拼正则避免源码里出现字面量。 */
-const DSML_MARK = '\uFF5C\uFF5CDSML\uFF5C\uFF5C';
-/**
- * "残渣标签"的两种形态。
- *
- * DSML 这边**不能只认 `tool_calls`**：实测模型吐出来的是**逐标签式**的，而且 marker 与标签名之间
- * **有一个空格** —— `<MARK parameter name="limit" string="false">40</MARK parameter>`、
- * `<MARK invoke name="read">…</MARK invoke>`、`<MARK calls>…</MARK calls>`。
- * 我第一版只匹配 `<\uFF5CDSML\uFF5Ctool_calls>`（无空格）→ 一个都没命中，残渣照漏（实测 4 轮漏 3 轮）。
- */
-const DSML_TAG = new RegExp(`<\\/?\\s*${DSML_MARK}\\s*(?:tool_calls|calls|invoke|parameter)\\b[^>]*>`, 'g');
-const SAFETY_TAG = /<\/?\s*ds_safety_tool_call\s*>/gi;
-/**
- * 把正文里的"工具调用残渣"整段丢掉。
- *
- * 为什么必须在流里做：收尾轮不带工具（为了逼模型给结论），模型会把"还想再调一次工具"当正文吐出来，
- * 客户端现有的 sanitizeToolResidue 只认官方 safety 包装，不认 DSML —— 用户看到的就是一段乱码标记。
- *
- * 算法：**按标签栈计数**。遇到开标签 depth+1、闭标签 depth-1；depth>0 期间的一切（含嵌套标签与参数值）
- * 全部丢弃；流在 depth>0 时结束 → 剩下的整段丢掉。这样三种实测形态（整块/缺包裹/单个标签）都能盖住。
- */
-function createResidueFilter() {
-    const HOLD = 32; // 标签可能被切开，没命中时留一小截尾巴再输出
-    let buffer = '';
-    let depth = 0;
-    let droppedChars = 0;
-    const scan = (text) => {
-        DSML_TAG.lastIndex = 0;
-        const dsml = DSML_TAG.exec(text);
-        SAFETY_TAG.lastIndex = 0;
-        const safety = SAFETY_TAG.exec(text);
-        if (dsml && safety)
-            return dsml.index <= safety.index ? dsml : safety;
-        return dsml ?? safety;
-    };
-    /**
-     * 该留多长的尾巴：除了固定 32 字，还要**精确扣住"半个标签"**。
-     * 踩过的坑：DSML 标签本身有 40+ 字（`<MARK parameter name="include" string="true">`），
-     * 只留 32 字时标签被切在中间 → 前半截被当正文发出去，后半截又不成标签 → 残渣漏进正文（实测漏过）。
-     * 判据：末尾最后一个 '<' 之后没有 '>'，就认为它是未完成的标签，从那个 '<' 起全部扣住。
-     */
-    const holdOf = (text) => {
-        const lastLt = text.lastIndexOf('<');
-        if (lastLt >= 0 && text.indexOf('>', lastLt) < 0)
-            return Math.max(HOLD, text.length - lastLt);
-        return HOLD;
-    };
-    const drain = (final) => {
-        let out = '';
-        for (;;) {
-            const hit = scan(buffer);
-            if (!hit) {
-                const hold = holdOf(buffer);
-                if (depth > 0) {
-                    // 在残渣块内部：丢掉，只留足以认出闭合标签的尾巴
-                    if (final)
-                        buffer = '';
-                    else
-                        buffer = buffer.length > hold ? buffer.slice(-hold) : buffer;
-                    break;
-                }
-                if (final) {
-                    out += buffer;
-                    buffer = '';
-                }
-                else if (buffer.length > hold) {
-                    out += buffer.slice(0, buffer.length - hold);
-                    buffer = buffer.slice(-hold);
-                }
-                break;
-            }
-            if (depth === 0)
-                out += buffer.slice(0, hit.index);
-            const closing = hit[0].charAt(1) === '/';
-            if (!closing)
-                droppedChars += hit[0].length;
-            depth = closing ? Math.max(0, depth - 1) : depth + 1;
-            buffer = buffer.slice(hit.index + hit[0].length);
-        }
-        return out;
-    };
-    return {
-        push: (text) => {
-            buffer += text;
-            return drain(false);
-        },
-        flush: () => {
-            const out = drain(true);
-            depth = 0; // 本轮结束就把状态归零：未闭合的残渣块不许影响下一轮
-            buffer = '';
-            return out;
-        },
-        /** 本轮被丢掉了多少字（用来判断"末尾残渣被删掉后句子没写完"）。 */
-        dropped: () => droppedChars,
-    };
-}
 function sendJson(res, status, body) {
     const text = JSON.stringify(body);
     res.writeHead(status, {
@@ -955,6 +1257,8 @@ export function apply(ctx, rawConfig) {
         bridgeSidebarPreview: rawConfig?.bridgeSidebarPreview ?? true,
         pillEnabled: rawConfig?.pillEnabled ?? true,
         pillIdleMs: rawConfig?.pillIdleMs ?? 10000,
+        voiceCancelOnSilence: rawConfig?.voiceCancelOnSilence ?? true,
+        voiceAutoSend: rawConfig?.voiceAutoSend ?? true,
     };
     /**
      * 出厂默认值（**不含**用户在设置页改过的部分）。
@@ -1065,16 +1369,26 @@ export function apply(ctx, rawConfig) {
         try {
             const raw = await readFile(leakyFile(), 'utf8');
             const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed?.routes)) {
+            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)
-                    if (typeof item === 'string' && item)
-                        leakyOnOff.add(item);
-            }
-            if (Array.isArray(parsed?.noOff)) {
+                    accept(item, leakyOnOff);
+            if (Array.isArray(parsed?.noOff))
                 for (const item of parsed.noOff)
-                    if (typeof item === 'string' && item)
-                        noOffRoutes.add(item);
-            }
+                    accept(item, noOffRoutes);
+            if (dropped > 0)
+                saveLeaky();
         }
         catch {
             /* 没有这个文件是常态 */
@@ -1086,10 +1400,33 @@ export function apply(ctx, rawConfig) {
             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();
@@ -1098,10 +1435,46 @@ export function apply(ctx, rawConfig) {
     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)
@@ -1124,6 +1497,8 @@ export function apply(ctx, rawConfig) {
                     continue;
                 let efforts = [];
                 let defaultEffort = null;
+                // null = 没读到（调用失败 / 拿不到信息）；true/false = 明确支持 / 不支持
+                let hasReasoning = null;
                 try {
                     let info = null;
                     if (typeof llm.resolveModelInfo === 'function') {
@@ -1132,11 +1507,15 @@ export function apply(ctx, rawConfig) {
                     else if (typeof llm.resolveModel === 'function') {
                         info = (await llm.resolveModel(provider.id, model.id));
                     }
-                    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;
+                    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 = [];
@@ -1148,6 +1527,8 @@ export function apply(ctx, rawConfig) {
                     name: String(model.name ?? model.id),
                     efforts,
                     defaultEffort,
+                    hasReasoning,
+                    effortMap: effortMapOf(efforts),
                 });
             }
         }
@@ -2753,7 +3134,14 @@ export function apply(ctx, rawConfig) {
                     '不要为了用网页而用网页，也不要把简单问题包装成页面。\n' +
                     '拿不准时按"能不能用一小段话讲清"来判断：能，就文字。\n' +
                     '用网页时，页面会渲染在大约 **500px 宽**的小窗里，按下面的设计规范做：\n\n' +
-                    skill;
+                    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 || '不限'}）。超出该范围的路径会被拒绝；引用文件内容时只取必要的一两行，不要整段粘贴。`
@@ -2794,6 +3182,13 @@ export function apply(ctx, rawConfig) {
         // 首轮默认就是 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,
@@ -2801,7 +3196,7 @@ export function apply(ctx, rawConfig) {
             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: requestEffort,
+            effort: sentEffort,
             tools: toolSchemas.map((schema) => schema.name),
             toolScope: agentScope,
             ...(toolFallbackUsed ? { toolFallbackUsed: true } : {}),
@@ -2830,8 +3225,11 @@ export function apply(ctx, rawConfig) {
         });
         // 上一轮查过的东西一并带上：否则追问会反复重查同样的内容（一次工具往返 20~34s）
         const toolDigest = typeof body.toolDigest === 'string' ? body.toolDigest.trim().slice(0, 2000) : '';
+        // 顺序很重要：把"已经查到的结果"放**前面**、问题放**最后**。
+        // 反过来的话，模型最后读到的是原始检索结果，容易"整理资料"而不是回答问题
+        //（实测：问新闻却把上一次的检索结果当成要总结的对象）。
         const questionText = toolDigest
-            ? `${question}\n\n【本会话已经查到的结果】（同一会话里查过的，不要重复查同样的内容）\n${toolDigest}`
+            ? `【本会话已经查到的结果】（同一会话里查过的，不要重复查同样的内容；只在与本轮问题相关时才用）\n${toolDigest}\n\n【用户这一轮的问题】\n${question}`
             : question;
         const openingMessages = isChat
             ? [...historyMessages, createUserMessage({ source: { kind: 'user' }, content: [{ type: 'text', text: questionText }] })]
@@ -2849,7 +3247,6 @@ export function apply(ctx, rawConfig) {
             let errorCode;
             const toolDigestLines = [];
             /** 被残渣过滤器丢掉的字数：末尾那些"模型顺手又调了一次工具"的标记会让正文停在半句上。 */
-            let residueDropped = 0;
             /**
              * 逐轮诊断（放进 done 事件）：原始字数 / 过滤后字数 / 思考字数 / 残渣丢弃 / finish 原因 / 输出 tokens。
              * 用来回答"到底是模型没吐、还是被我们的过滤器吃掉了、还是上游掐流"——不靠猜。
@@ -2868,9 +3265,18 @@ export function apply(ctx, rawConfig) {
             // 以前这里限定了 `isChat && bodyEffort.length > 0` —— 只有追问、且客户端显式传了档位才重试。
             // 于是**首轮**（档位来自配置、默认 off）撞上不吃 off 的模型时无人兜底，整个划词解读全挂。
             // 现在按"这一轮实际在发显式档位"判，三种轮次一视同仁。
-            const canRetryEffort = requestEffort.length > 0;
-            let effortRetried = false;
-            let roundEffort = requestEffort;
+            //
+            // 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;
@@ -2893,7 +3299,10 @@ export function apply(ctx, rawConfig) {
                             : systemPrompt, name),
                         ...(round === 0 ? [baseMessage, ...openingMessages] : [baseMessage, ...openingMessages, ...toolMessages]),
                     ],
-                    ...(!wrapUp && toolSchemas.length > 0 ? { tools: toolSchemas } : {}),
+                    // 工具**每轮都在请求里**（照主会话的做法）：收尾轮以前故意不带工具"逼结论"，
+                    // 结果模型退到文本层、把工具调用标记写进正文（实测 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) } : {}),
@@ -2908,7 +3317,6 @@ export function apply(ctx, rawConfig) {
                 // 共用一个的话，某一轮吐了未闭合的 DSML（实测收尾轮很常见）会让 depth 一直 >0，
                 // 后面所有轮次的正文都被吞掉 —— 表现就是"只完成了工具查询，没有产出正文"（用户截图报的）。
                 const think = createThinkFilter();
-                const residue = createResidueFilter();
                 let roundRaw = 0;
                 let roundEmitted = 0;
                 let roundThink = 0;
@@ -2921,7 +3329,7 @@ export function apply(ctx, rawConfig) {
                         sse(res, { type: 'thought', text: part.think });
                     }
                     // 残渣过滤放在 think 之后：先分出思考，再把正文里的工具调用标记丢掉
-                    const text = part.text ? residue.push(part.text) : '';
+                    const text = part.text;
                     if (text) {
                         roundEmitted += text.length;
                         chars += text.length;
@@ -2954,7 +3362,7 @@ export function apply(ctx, rawConfig) {
                         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' ? '被中断' : '失败'}`;
@@ -2963,19 +3371,6 @@ export function apply(ctx, rawConfig) {
                     }
                 }
                 emit(think.flush());
-                // 注意：residue.flush() 吐出的正文**不能再走 emit()** —— emit 会把它再喂回同一个过滤器，
-                // 于是 HOLD=32 又扣住尾巴，而本轮到此结束 → 最后 32 字永远不会发出去（实测 raw−emitted 恒为 32）。
-                {
-                    const tailText = residue.flush();
-                    if (tailText) {
-                        chars += tailText.length;
-                        answer += tailText;
-                        roundText += tailText;
-                        roundEmitted += tailText.length;
-                        sse(res, { type: 'delta', text: tailText });
-                    }
-                }
-                residueDropped += residue.dropped();
                 roundDiag.push({
                     round,
                     wrapUp,
@@ -2983,39 +3378,49 @@ export function apply(ctx, rawConfig) {
                     raw: roundRaw,
                     emitted: roundEmitted,
                     think: roundThink,
-                    residueDropped: residue.dropped(),
                     finish: roundFinish || '(none)',
                     tools: assembler.blocks().filter((block) => block.type === 'tool-call').length,
                     ...(body.debug === true ? { tailChunks } : {}),
                     outTokens: usage?.outputTokens,
                 });
                 if (errored) {
-                    // 一个字都没吐出来 + 是显式档位导致的失败 → 去掉档位重试**同一轮**
-                    // （保守：已经吐出正文的失败不重试，避免把半截答案丢掉）
-                    if (canRetryEffort && !effortRetried && roundText.length === 0) {
-                        effortRetried = true;
+                    // 一个字都没吐出来 → 可以安全重试**同一轮**（保守：已经吐出正文的失败不重试，
+                    // 免得把半截答案丢掉）。重试换一个没试过的档位，而不是把档位去掉。
+                    if (roundText.length === 0 && effortRetries > 0) {
                         const rejected = roundEffort;
-                        if (rejected === 'off') {
-                            // "关"被拒：记下这个 route，改用 low（最接近关的可接受档位），并让重试也用 low。
-                            // 只去掉档位（交给供应商默认）在有些模型上等于开了深度思考 —— 又慢又可能把思考写进正文。
-                            markNoOff(routeKey);
-                            requestEffort = 'low';
-                            roundEffort = 'low';
-                        }
-                        else {
-                            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;
                         }
-                        errored = false;
-                        sse(res, {
-                            type: 'notice',
-                            code: 'effort-rejected',
-                            tier: rejected,
-                            text: rejected === 'off'
-                                ? '该模型不支持「关」档，已自动改用「低」档（以后不再尝试关档）'
-                                : `「${rejected}」档位该模型不支持，已按默认档位重试`,
-                        });
-                        round -= 1;
-                        continue;
                     }
                     sse(res, { type: 'error', message: errorMessage, code: errorCode });
                     break;
@@ -3023,8 +3428,8 @@ export function apply(ctx, rawConfig) {
                 const blocks = assembler.blocks();
                 const calls = blocks.filter((block) => block.type === 'tool-call');
                 if (calls.length === 0) {
-                    // 最终答案到手：如果用的是 "关" 档，检查有没有把思考写进正文
-                    if (isChat && requestEffort === 'off') {
+                    // 最终答案到手：如果发出去的是「关」那一格对应的真实档位，检查有没有把思考写进正文
+                    if (isChat && firstSentEffort === offSlotEffort) {
                         const split = splitLeakedReasoning(answer);
                         if (split.prefix) {
                             markLeaky(routeKey);
@@ -3034,7 +3439,8 @@ export function apply(ctx, rawConfig) {
                             sse(res, {
                                 type: 'notice',
                                 code: 'reasoning-leak',
-                                tier: 'off',
+                                // 报**真实档位**（模型可能没有 off，叫 none/minimal）：客户端据此标对那个档位按钮
+                                tier: firstSentEffort,
                                 text: '该模型在「关」档会把思考写进正文，已撤回泄漏段；以后这一档会自动改用「低」',
                             });
                         }
@@ -3044,7 +3450,7 @@ export function apply(ctx, rawConfig) {
                             sse(res, {
                                 type: 'notice',
                                 code: 'reasoning-leak',
-                                tier: 'off',
+                                tier: firstSentEffort,
                                 text: '这个模型在「关」档会把思考写进正文；这一档以后自动改用「低」',
                             });
                         }
@@ -3120,23 +3526,38 @@ export function apply(ctx, rawConfig) {
                     toolDigestLines.push(`· ${call.name}（${label2 || '查询'}）：${digest.preview}`);
                 }
             }
-            if (!errored && answer.trim().length === 0 && toolCalls > 0 && !effortRetried) {
+            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');
-                // 先按当前档位试一次；空则用「关」档再试（有的模型在这一档更"直接给答案"）
-                for (const attemptEffort of [roundEffort, 'off']) {
+                // 先按当前档位试一次；空则**换一个档位**再试（同一档重发没意义）。
+                // 以前这里写死 `'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;
@@ -3146,6 +3567,10 @@ export function apply(ctx, rawConfig) {
                             model: route.model,
                             ...(sessionId ? { sessionId: sessionId } : {}),
                             system: undefined,
+                            // 工具**依然带着**（照主会话：任何一轮都不摘工具）。
+                            // 以前这一轮不带工具，模型要调工具时只能退回文本层 —— 那正是正文里出现
+                            // DSML / ds_safety_tool_call 标记的唯一来源。带上之后它走协议层，正文就是正文。
+                            ...(toolSchemas.length > 0 ? { tools: toolSchemas } : {}),
                             messages: [
                                 // 同上：多传的插件名在老版本运行时会被忽略，新版本类型上却是必填
                                 systemMessageOf(systemPrompt, name),
@@ -3157,13 +3582,12 @@ export function apply(ctx, rawConfig) {
                             signal: controller.signal,
                         });
                         const thinkAgain = createThinkFilter();
-                        const residueAgain = createResidueFilter();
                         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 ? residueAgain.push(part.text) : '';
+                                const text = part.text;
                                 if (text) {
                                     chars += text.length;
                                     answer += text;
@@ -3183,14 +3607,6 @@ export function apply(ctx, rawConfig) {
                         for (const tail of [thinkAgain.flush()])
                             if (tail.think)
                                 sse(res, { type: 'thought', text: tail.think });
-                        const tailText = residueAgain.flush();
-                        if (tailText) {
-                            chars += tailText.length;
-                            answer += tailText;
-                            conclusionInfo.chars += tailText.length;
-                            sse(res, { type: 'delta', text: tailText });
-                        }
-                        residueDropped += residueAgain.dropped();
                         // 结论轮也可能把"英文核对过程"写进正文：一律按泄漏裁一次
                         const leaked = splitLeakedReasoning(answer);
                         if (leaked.prefix) {
@@ -3257,6 +3673,10 @@ export function apply(ctx, rawConfig) {
     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`);
@@ -3271,9 +3691,13 @@ export function apply(ctx, rawConfig) {
  */
 export const __internals = {
     createThinkFilter,
-    createResidueFilter,
     splitLeakedReasoning,
     looksLikeLeakedReasoning,
     resolveToolNames,
+    looksLikeUnsupportedTier,
+    looksLikeReasoningRequired,
+    pickNextEffort,
+    mapEffortToModel,
+    effortMapOf,
 };
 //# sourceMappingURL=index.js.map