@yfwu2020/dsh-selection-explain 0.9.0 → 0.10.0

package/src/index.ts

@@ -12,9 +12,13 @@
  */
 import { createHash } from 'node:crypto'
 import { lookup } from 'node:dns/promises'
+import { spawn } from 'node:child_process'
+import type { ChildProcess } 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 type { Context } from '@deepseek-ai/cordis'
 import type { IncomingMessage, ServerResponse } from 'node:http'
@@ -64,6 +68,195 @@ export const inject = ['webServer', 'llm']
 /** 路由前缀。 */
 const API_PREFIX = '/selection-explain/api'
 
+// ───────────────────────── 麦克风占用检测 ─────────────────────────
+//
+// 回答一个问题：**此刻是不是某个输入法正在语音输入？**（豆包输入法、微信输入法……）
+//
+// 客户端拿它做什么：用户选中一段文字、同时正在用输入法说话时，就在那段文字下方弹一个
+// 临时输入框并自动聚焦 —— 输入法"上屏"的文字会直接落进那个框（IME 只认焦点元素，
+// 所以我们不需要读它的转写结果），点发送就跳过翻译/详解直接进追问。
+//
+// 怎么知道的：macOS 14.4 起 CoreAudio 暴露了进程对象列表，逐进程可读
+// `kAudioProcessPropertyIsRunningInput` —— 于是"谁在录"是一次精确查询，而不是猜。
+// **读这个状态不需要麦克风 TCC 授权**（只有真正录音才需要），这点很关键：插件不该为了
+// 一个"指示灯"去要用户的麦克风权限。
+//
+// 原生探针见 native/mic-probe.c（Node 没有 FFI，所以编个小二进制，构建脚本第 ⑤ 步产出）。
+// 这里只负责：懒启动、解析它吐的 JSON 行、缓存最新状态。编不出来 / 非 macOS 时
+// available:false —— 客户端据此完全不启用这个特性，不装作在检测。
+
+interface MicProcess {
+  pid: number
+  bundleId: string
+  name: string
+}
+
+/** 最新一次探针状态（进程集合变了才更新）。 */
+const micState = {
+  available: false,
+  capturing: false,
+  processes: [] as MicProcess[],
+  /** 不可用时的原因（not-macos / probe-missing / probe-failed / probe-exited）。 */
+  reason: '',
+}
+
+let micChild: ChildProcess | null = null
+/** 只尝试启动一次：失败就认（避免每个请求都去 spawn 一遍）。 */
+let micStarted = false
+/** 最近一次有人来问探针的时间（用来判断"没人看了"）。 */
+let micLastUse = 0
+/** "没人看就停"的检查定时器。 */
+let micIdleTimer: NodeJS.Timeout | null = 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(): void {
+  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) as { capturing?: boolean; processes?: MicProcess[] }
+          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(): void {
+  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(): void {
+  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: IncomingMessage, res: ServerResponse): void => {
+  // 每次有人来问都续一次命：只要页面在轮询，探针就不会到期
+  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
 
@@ -150,6 +343,25 @@ export interface Config {
    * 默认 10 秒：短于这个数会显得"刚看一眼就没了"，长了又失去"收起来不挡视线"的意义。
    */
   pillIdleMs: number
+  /**
+   * 开麦结束、**一个字都没说**时，直接收起临时输入框。
+   *
+   * 默认开（2026-10-09 用户指定）：等于替用户按了 Esc（带关机动画）。
+   * 关掉则回到"卡片留着" —— 一个字没说时可以接着手动打字。
+   *
+   * 注意"结束"不是"松手那一瞬间"：输入法在松手后还会做一次**智能整理**（改写输入框内容），
+   * 所以真正动作要等到文字定稿（见客户端的 VOICE_SETTLE_MS）。否则会取消掉马上就要落进来的整理结果。
+   */
+  voiceCancelOnSilence: boolean
+  /**
+   * 开麦结束、**已经说出文字**时，直接发送（跳过手动点发送键）。
+   *
+   * 默认开（2026-10-09 用户指定）：等于替用户点了发送键。
+   * 关掉则回到"先看一眼再点" —— 发送会开小窗、开始一次真实请求，不可逆。
+   *
+   * 同样要等文字定稿：松手那一刻输入法还没整理完，立刻发送发出去的是没整理的草稿。
+   */
+  voiceAutoSend: boolean
 }
 
 /** 配置 schema（缺省值即推荐值）。 */
@@ -219,6 +431,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),
 })
 
 /** 联网类工具名：用来判断"首选里的联网工具在不在"。 */
@@ -273,6 +489,8 @@ interface AnalyzeBody {
   model?: unknown
   /** 网页模式（小窗里的开关）：复杂问题默认用网页回答，并注入设计规范。 */
   webAnswer?: unknown
+  /** 客户端上报的当前深浅（'dark' | 'light'）：网页输出按它选配色。 */
+  theme?: unknown
   /** 追问模式下用户这一轮的问题。 */
   question?: unknown
   /** 追问模式下的历史轮次：[{ role: 'user' | 'assistant', text }]。 */
@@ -440,6 +658,245 @@ function looksLikeLeakedReasoning(text: string): boolean {
   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: Record<string, number> = {
+  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: unknown): string {
+  return String(value ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_-]+/g, '')
+}
+
+/**
+ * 每个声明档位的刻度：认得的名字用表，不认识的按**位置**在已知邻居之间线性插值
+ * （两头都没有已知锚点时按序号平铺到 0..8）。最后钳成不递减 —— 各 adapter 的声明都是升序，
+ * 插值不该把这个顺序弄反。
+ */
+function rankEfforts(declared: Array<{ id: string; name?: string }>): number[] {
+  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: number[] = []
+  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] as number) : null
+    const rightRank = right >= 0 ? (known[right] as number) : 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: Array<{ id: string; name?: string }>, canonical: string): string {
+  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: number[] = []
+  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: Array<{ id: string; name?: string }>): Record<string, string> {
+  const out: Record<string, string> = {}
+  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: Record<string, string> = { 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: string): boolean {
+  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: string): boolean {
+  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: string[],
+  defaultEffort: string | null | undefined,
+  rejected: string,
+  tried: Set<string>,
+): string {
+  const usable = (id: string | null | undefined): id is string => !!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: string): { prefix: string; rest: string } {
   const body = String(text || '')
   if (body.length < 40) return { prefix: '', rest: body }
@@ -469,108 +926,6 @@ function splitLeakedReasoning(text: string): { prefix: string; rest: string } {
   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(): { push: (text: string) => string; flush: () => string; dropped: () => number } {
-  const HOLD = 32 // 标签可能被切开，没命中时留一小截尾巴再输出
-  let buffer = ''
-  let depth = 0
-  let droppedChars = 0
-  const scan = (text: string): RegExpExecArray | null => {
-    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: string): number => {
-    const lastLt = text.lastIndexOf('<')
-    if (lastLt >= 0 && text.indexOf('>', lastLt) < 0) return Math.max(HOLD, text.length - lastLt)
-    return HOLD
-  }
-  const drain = (final: boolean): string => {
-    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: string) => {
-      buffer += text
-      return drain(false)
-    },
-    flush: () => {
-      const out = drain(true)
-      depth = 0 // 本轮结束就把状态归零：未闭合的残渣块不许影响下一轮
-      buffer = ''
-      return out
-    },
-    /** 本轮被丢掉了多少字（用来判断"末尾残渣被删掉后句子没写完"）。 */
-    dropped: () => droppedChars,
-  }
-}
 
 function sendJson(res: ServerResponse, status: number, body: unknown): void {
   const text = JSON.stringify(body)
@@ -1211,6 +1566,8 @@ export function apply(ctx: Context, rawConfig: Config): void {
     bridgeSidebarPreview: rawConfig?.bridgeSidebarPreview ?? true,
     pillEnabled: rawConfig?.pillEnabled ?? true,
     pillIdleMs: rawConfig?.pillIdleMs ?? 10000,
+    voiceCancelOnSilence: rawConfig?.voiceCancelOnSilence ?? true,
+    voiceAutoSend: rawConfig?.voiceAutoSend ?? true,
   }
 
   /**
@@ -1317,6 +1674,18 @@ export function apply(ctx: Context, rawConfig: Config): void {
     name: string
     efforts: Array<{ id: string; name: string }>
     defaultEffort: string | null
+    /**
+     * 这个模型到底支不支持"思考强度"：
+     *   true  = 有推理档位（efforts 非空）
+     *   false = 明确不支持（dsh-llm 的 resolveModelInfo 说它没有 reasoning）
+     *   null  = 没读到（还没加载 / 这次调用失败）→ 原样发规范档位，被拒时由换档重试兜
+     */
+    hasReasoning: boolean | null
+    /**
+     * 规范四格 → 这个模型**真实**的档位 id（'' = 没有可发的档位）。
+     * 由 `effortMapOf(model.efforts)` 实时算出，随清单一起下发 —— 设置页据此显示"这四格现在落到哪"。
+     */
+    effortMap: Record<string, string>
   }
   let modelCache: { at: number; items: ModelChoice[] } = { at: 0, items: [] }
   /** 哪些 provider/model 在 "关" 档会把思考写进正文（实测过一次就记住，之后自动改用「低」）。 */
@@ -1339,12 +1708,20 @@ export function apply(ctx: Context, rawConfig: Config): void {
     try {
       const raw = await readFile(leakyFile(), 'utf8')
       const parsed = JSON.parse(raw) as { routes?: unknown; noOff?: unknown }
-      if (Array.isArray(parsed?.routes)) {
-        for (const item of parsed.routes) if (typeof item === 'string' && item) leakyOnOff.add(item)
-      }
-      if (Array.isArray(parsed?.noOff)) {
-        for (const item of parsed.noOff) if (typeof item === 'string' && item) noOffRoutes.add(item)
+      let dropped = 0
+      const accept = (item: unknown, into: Set<string>): void => {
+        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 {
       /* 没有这个文件是常态 */
     }
@@ -1357,9 +1734,30 @@ export function apply(ctx: Context, rawConfig: Config): void {
     })
   }
 
+  /**
+   * 这条 route 的 provider 是不是**这台机器上真有的**。
+   *
+   * 为什么落盘前要查一下：这两个集合会写进 `~/.dsh/selection-explain/leaky-off.json`，
+   * 而请求体里的 provider 是可以伪造的（`resolveRoute` 在清单没加载出来时只做形状校验）。
+   * 实测踩过：`test-client.mjs` 的夹具 provider `p1` 被写进了用户真实的落盘文件
+   * （`p1/m-strong`、`p1/m-fast`）—— 之后再也没人清掉它。
+   * 宁可不记（顶多多撞一次上游，反正有重试），也不要往用户的文件里写不存在的东西。
+   */
+  function isRealProvider(provider: string): boolean {
+    if (!provider) return false
+    try {
+      const llm = ctx.get('llm') as { listProviders?: () => Array<{ id?: string }> } | undefined
+      const list = llm?.listProviders?.() ?? []
+      return list.some((item) => String(item?.id ?? '') === provider)
+    } catch {
+      return false
+    }
+  }
+
   /** 记住一个"关档会泄漏"的模型（内存 + 落盘）。 */
   function markLeaky(route: string): void {
     if (leakyOnOff.has(route)) return
+    if (!isRealProvider(route.split('/')[0] ?? '')) return
     leakyOnOff.add(route)
     if (leakyLoaded) saveLeaky()
   }
@@ -1367,9 +1765,49 @@ export function apply(ctx: Context, rawConfig: Config): void {
   /** 记住一个"不接受关档"的模型（内存 + 落盘）：下次直接改用 low，不再先撞一次。 */
   function markNoOff(route: string): void {
     if (noOffRoutes.has(route)) return
+    if (!isRealProvider(route.split('/')[0] ?? '')) return
     noOffRoutes.add(route)
     if (leakyLoaded) saveLeaky()
   }
+
+  /** 档位阶梯与判据都在模块层（纯函数，可单测）：这里只把清单数据喂给它。 */
+  function nextEffortFor(route: string, rejected: string, tried: Set<string>): string {
+    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: string, canonical: string): string {
+    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(): void {
+    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): Promise<ModelChoice[]> {
@@ -1404,6 +1842,8 @@ export function apply(ctx: Context, rawConfig: Config): void {
         if (!model?.id) continue
         let efforts: Array<{ id: string; name: string }> = []
         let defaultEffort: string | null = null
+        // null = 没读到（调用失败 / 拿不到信息）；true/false = 明确支持 / 不支持
+        let hasReasoning: boolean | null = null
         try {
           // 两个方法签名不同，各自显式标注，避免联合类型把返回值退化成 any
           type Resolved = { reasoning?: { efforts?: Array<{ id?: string; name?: string }>; defaultEffort?: string } } | null
@@ -1413,11 +1853,15 @@ export function apply(ctx: Context, rawConfig: Config): void {
           } else if (typeof llm.resolveModel === 'function') {
             info = (await llm.resolveModel(provider.id, model.id)) as Resolved
           }
-          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 = []
         }
@@ -1428,6 +1872,8 @@ export function apply(ctx: Context, rawConfig: Config): void {
           name: String(model.name ?? model.id),
           efforts,
           defaultEffort,
+          hasReasoning,
+          effortMap: effortMapOf(efforts),
         })
       }
     }
@@ -3123,7 +3569,14 @@ export function apply(ctx: Context, rawConfig: Config): void {
         '不要为了用网页而用网页，也不要把简单问题包装成页面。\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 || '不限'}）。超出该范围的路径会被拒绝；引用文件内容时只取必要的一两行，不要整段粘贴。`
@@ -3164,6 +3617,13 @@ export function apply(ctx: Context, rawConfig: Config): void {
     // 已知这个模型不接受"关"档（之前撞过一次并记下来了）：直接换 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',
@@ -3172,7 +3632,7 @@ export function apply(ctx: Context, rawConfig: Config): void {
       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 } : {}),
@@ -3201,8 +3661,11 @@ export function apply(ctx: Context, rawConfig: Config): void {
     })
     // 上一轮查过的东西一并带上：否则追问会反复重查同样的内容（一次工具往返 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: Message[] = isChat
       ? [...historyMessages, createUserMessage({ source: { kind: 'user' }, content: [{ type: 'text', text: questionText }] })]
@@ -3220,7 +3683,6 @@ export function apply(ctx: Context, rawConfig: Config): void {
       let errorCode: string | undefined
       const toolDigestLines: string[] = []
       /** 被残渣过滤器丢掉的字数：末尾那些"模型顺手又调了一次工具"的标记会让正文停在半句上。 */
-      let residueDropped = 0
       /**
        * 逐轮诊断（放进 done 事件）：原始字数 / 过滤后字数 / 思考字数 / 残渣丢弃 / finish 原因 / 输出 tokens。
        * 用来回答"到底是模型没吐、还是被我们的过滤器吃掉了、还是上游掐流"——不靠猜。
@@ -3239,9 +3701,18 @@ export function apply(ctx: Context, rawConfig: Config): void {
       // 以前这里限定了 `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<string>(sentEffort ? [sentEffort] : [])
+      const firstSentEffort = sentEffort
+      let roundEffort = sentEffort
       for (let round = 0; round <= toolRounds; round += 1) {
         const roundStartedAt = Date.now()
         const wrapUp = round === toolRounds
@@ -3267,7 +3738,10 @@ export function apply(ctx: Context, rawConfig: Config): void {
             ),
             ...(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) } : {}),
@@ -3282,7 +3756,6 @@ export function apply(ctx: Context, rawConfig: Config): void {
         // 共用一个的话，某一轮吐了未闭合的 DSML（实测收尾轮很常见）会让 depth 一直 >0，
         // 后面所有轮次的正文都被吞掉 —— 表现就是"只完成了工具查询，没有产出正文"（用户截图报的）。
         const think = createThinkFilter()
-        const residue = createResidueFilter()
         let roundRaw = 0
         let roundEmitted = 0
         let roundThink = 0
@@ -3295,7 +3768,7 @@ export function apply(ctx: Context, rawConfig: Config): void {
             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
@@ -3324,7 +3797,7 @@ export function apply(ctx: Context, rawConfig: Config): void {
             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' ? '被中断' : '失败'}`
@@ -3333,19 +3806,6 @@ export function apply(ctx: Context, rawConfig: Config): void {
           }
         }
         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,
@@ -3353,38 +3813,48 @@ export function apply(ctx: Context, rawConfig: Config): void {
           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 as { outputTokens?: number } | null)?.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
@@ -3392,8 +3862,8 @@ export function apply(ctx: Context, rawConfig: Config): void {
         const blocks: ContentBlock[] = 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)
@@ -3403,7 +3873,8 @@ export function apply(ctx: Context, rawConfig: Config): void {
               sse(res, {
                 type: 'notice',
                 code: 'reasoning-leak',
-                tier: 'off',
+                // 报**真实档位**（模型可能没有 off，叫 none/minimal）：客户端据此标对那个档位按钮
+                tier: firstSentEffort,
                 text: '该模型在「关」档会把思考写进正文，已撤回泄漏段；以后这一档会自动改用「低」',
               })
             } else if (looksLikeLeakedReasoning(answer)) {
@@ -3412,7 +3883,7 @@ export function apply(ctx: Context, rawConfig: Config): void {
               sse(res, {
                 type: 'notice',
                 code: 'reasoning-leak',
-                tier: 'off',
+                tier: firstSentEffort,
                 text: '这个模型在「关」档会把思考写进正文；这一档以后自动改用「低」',
               })
             }
@@ -3488,23 +3959,38 @@ export function apply(ctx: Context, rawConfig: Config): void {
           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
           try {
@@ -3513,6 +3999,10 @@ export function apply(ctx: Context, rawConfig: Config): void {
               model: route.model,
               ...(sessionId ? { sessionId: sessionId as never } : {}),
               system: undefined,
+              // 工具**依然带着**（照主会话：任何一轮都不摘工具）。
+              // 以前这一轮不带工具，模型要调工具时只能退回文本层 —— 那正是正文里出现
+              // DSML / ds_safety_tool_call 标记的唯一来源。带上之后它走协议层，正文就是正文。
+              ...(toolSchemas.length > 0 ? { tools: toolSchemas } : {}),
               messages: [
                 // 同上：多传的插件名在老版本运行时会被忽略，新版本类型上却是必填
                 systemMessageOf(systemPrompt, name),
@@ -3524,12 +4014,11 @@ export function apply(ctx: Context, rawConfig: Config): void {
               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
@@ -3545,14 +4034,6 @@ export function apply(ctx: Context, rawConfig: Config): void {
               }
             }
             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) {
@@ -3638,6 +4119,16 @@ export function apply(ctx: Context, rawConfig: Config): void {
     () => 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`,
@@ -3677,8 +4168,12 @@ export type { WebServer }
  */
 export const __internals = {
   createThinkFilter,
-  createResidueFilter,
   splitLeakedReasoning,
   looksLikeLeakedReasoning,
   resolveToolNames,
+  looksLikeUnsupportedTier,
+  looksLikeReasoningRequired,
+  pickNextEffort,
+  mapEffortToModel,
+  effortMapOf,
 }