@yfwu2020/dsh-selection-explain 0.9.1 → 0.10.1

package/scripts/test-effort-map.mjs

@@ -0,0 +1,129 @@
+/**
+ * 四格 → 模型真实档位：映射规则的确定性单测（不碰网络、不依赖宿主）。
+ *
+ * 为什么要有这一份：设置页那四个格子（关/低/高/最高）是**插件自己的词汇**，而每个模型
+ * 声明的档位词汇表各不相同 —— 本机 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、以及一档都不声明）。
+ * 映射是**运行时按模型声明现算**的（没有任何按模型写死的表），所以这份用例既锁住
+ * "见过的那几种"，也用**随机生成、插件作者没见过的词汇表**验两条不变量：
+ *   ① 落点永远是这个模型声明过的档位（否则 dsh-llm 直接抛 UNSUPPORTED_REASONING_EFFORT）；
+ *   ② 关 ≤ 低 ≤ 高 ≤ 最高（按声明的先后顺序，声明都是升序）。
+ */
+import { __internals } from '../lib/index.js'
+
+const { mapEffortToModel, effortMapOf } = __internals
+
+let failed = 0
+function assert(name, ok, detail) {
+  if (ok) {
+    console.log('  ✓ ' + name)
+  } else {
+    failed += 1
+    console.log('  ✗ ' + name + (detail ? ' — ' + detail : ''))
+  }
+}
+
+/** 把一个模型声明的 id 列表转成映射函数用的形状（name 就取 id）。 */
+const decl = (ids) => ids.map((id) => ({ id, name: id }))
+/** 四格一次算完，返回 ['关','低','高','最高'] 的落点。 */
+const four = (ids) => {
+  const map = effortMapOf(decl(ids))
+  return [map.off, map.low, map.high, map.max]
+}
+const show = (ids) => {
+  const r = four(ids)
+  return `${ids.join('>')}  →  关=${r[0]} 低=${r[1]} 高=${r[2]} 最高=${r[3]}`
+}
+
+console.log('[1] 本机真实词汇表（2026-10-10 从 /models 抓下来的形状）')
+const REAL = [
+  // 最常见：四档，名字与四个格子一一对应 → 恒等映射
+  { ids: ['off', 'low', 'high', 'max'], want: ['off', 'low', 'high', 'max'] },
+  // 六档，中间多出 medium / xhigh：仍然落在名为 low / high 的那两档上
+  { ids: ['off', 'low', 'medium', 'high', 'xhigh', 'max'], want: ['off', 'low', 'high', 'max'] },
+  // 没有 off（deepseek-v4.1-flash 这种）：关落到它最弱的那档
+  { ids: ['low', 'high', 'max'], want: ['low', 'high', 'high', 'max'] },
+  // 只有两档（deepseek-v4-pro / glm-5.2）：最弱留给关，其余都只能落最强
+  { ids: ['high', 'max'], want: ['high', 'max', 'max', 'max'] },
+  // 五档且没有 max（glm-5.1 / mimo-*）：最高落到它最强的那档
+  { ids: ['off', 'minimal', 'low', 'medium', 'high'], want: ['off', 'low', 'medium', 'high'] },
+  // 四档但顶档叫 xhigh（qwen3.8-max/flash）
+  { ids: ['off', 'low', 'medium', 'xhigh'], want: ['off', 'low', 'medium', 'xhigh'] },
+  // 没有 off 但有 xhigh（grok-4.6/4.7）
+  { ids: ['low', 'medium', 'high', 'xhigh'], want: ['low', 'medium', 'high', 'xhigh'] },
+  // 最少见的一档（kimi-k3 只有 max）：四格都只能落它
+  { ids: ['max'], want: ['max', 'max', 'max', 'max'] },
+  // 完全不支持推理（typesafe/jev-latest）：四个格子都空 → 调用方据此不发档位
+  { ids: [], want: ['', '', '', ''] },
+  // 两档（hy4-preview / kimi-k2.6）：关=off，其余落它唯一的高档
+  { ids: ['off', 'high'], want: ['off', 'high', 'high', 'high'] },
+]
+for (const item of REAL) {
+  const got = four(item.ids)
+  assert(show(item.ids), JSON.stringify(got) === JSON.stringify(item.want), '期望 ' + JSON.stringify(item.want))
+}
+
+console.log('\n[2] 没见过的词汇表也要落位（别的 adapter 可能叫 a/b/c、tier1…、或数字）')
+const ALIEN = [
+  { ids: ['a', 'b', 'c', 'd'], want: ['a', 'b', 'c', 'd'] },
+  { ids: ['tier1', 'tier2', 'tier3', 'tier4', 'tier5'], want: ['tier1', 'tier2', 'tier4', 'tier5'] },
+  { ids: ['1', '2', '3'], want: ['1', '2', '2', '3'] },
+  { ids: ['x', 'y'], want: ['x', 'y', 'y', 'y'] },
+  // 半认半不认：'low' 认得出深度，其余按位置插值
+  { ids: ['stage0', 'low', 'stage2', 'stage3'], want: ['stage0', 'low', 'stage2', 'stage3'] },
+]
+for (const item of ALIEN) {
+  const got = four(item.ids)
+  assert(show(item.ids), JSON.stringify(got) === JSON.stringify(item.want), '期望 ' + JSON.stringify(item.want))
+}
+
+console.log('\n[3] 两条不变量：落点必须已声明；关 ≤ 低 ≤ 高 ≤ 最高（按声明顺序）')
+/** 造一批"升序"的词汇表：长度 1..7，名字在几套风格之间轮换（含插件作者没见过的）。 */
+const NAMERS = [
+  (i) => ['off', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'][i] ?? `known${i}`,
+  (i) => ['none', 'minimal', 'light', 'mid', 'high', 'max', 'highest'][i] ?? `style${i}`,
+  (i) => `tier${i + 1}`,
+  (i) => String.fromCharCode(97 + i), // a, b, c…
+  (i) => `档位${i + 1}`,
+  (i) => `stage${i * 2}`,
+]
+let cases = 0
+let bad = 0
+for (let n = 1; n <= 7; n += 1) {
+  for (let style = 0; style < NAMERS.length; style += 1) {
+    const ids = []
+    for (let i = 0; i < n; i += 1) ids.push(NAMERS[style](i))
+    const got = four(ids)
+    cases += 1
+    // ① 每个落点都必须是这个模型声明过的 id
+    for (const value of got) {
+      if (!ids.includes(value)) {
+        bad += 1
+        console.log('  ✗ 未声明的落点：' + show(ids) + ' 里出现了 ' + JSON.stringify(value))
+        break
+      }
+    }
+    // ② 单调：按下标比较（声明都是升序）
+    const order = got.map((value) => ids.indexOf(value))
+    const monotone = order.every((value, index) => index === 0 || order[index - 1] <= value)
+    if (!monotone) {
+      bad += 1
+      console.log('  ✗ 非单调：' + show(ids) + ' 下标=' + JSON.stringify(order))
+    }
+    // ③ 两端钉死：关 = 最弱、最高 = 最强（列表升序 = 下标顺序）
+    if (got[0] !== ids[0] || got[3] !== ids[n - 1]) {
+      bad += 1
+      console.log('  ✗ 两端没钉住：' + show(ids))
+    }
+  }
+}
+assert(`${cases} 组合成词汇表全部满足不变量`, bad === 0, `${bad} 组有问题`)
+
+console.log('\n[4] 显式值、大小写与连字符都认（adapter 的显示名可能写成 "X-High" / "Very High"）')
+assert("显示名 'X-High' 认成最高档之下的那一档", mapEffortToModel([{ id: 'a', name: 'Low' }, { id: 'b', name: 'X-High' }], 'max') === 'b')
+assert("id 大写 'OFF' 也算关", mapEffortToModel([{ id: 'OFF', name: 'Off' }, { id: 'HIGH', name: 'High' }], 'off') === 'OFF')
+assert('没见过的规范值按"关"处理（不会越界）', mapEffortToModel(decl(['off', 'low', 'high']), 'something-else') === 'off')
+
+console.log(failed === 0 ? '\n全部通过 ✓' : `\n${failed} 项失败 ✗`)
+process.exit(failed === 0 ? 0 : 1)

package/scripts/test-effort-retry.mjs

@@ -0,0 +1,109 @@
+/**
+ * 档位重试策略的确定性单测（不碰网络、不依赖宿主）。
+ *
+ * 为什么必须有这一份：这套逻辑的输入是**上游错误的文案**，而它曾经把
+ * 「偶发上游 400」误判成「这个档位不被支持」，连锁出三个错：
+ *   ① 给用户一句错诊断（「该档位不支持」）；
+ *   ② 把这次偶发失败**永久记进** leaky-off.json（以后再也不发这个档）；
+ *   ③ 客户端清掉用户选的档位。
+ * 2026-10-09 实测（活宿主 /analyze，交错发送排除时间漂移）：
+ *   opencode-go/step-5-preview-free：effort=low 成功 5/8、effort=high 成功 5/8
+ *   —— **同一档位时好时坏，档位不是变量**；对照 longcat-2.5-preview-free 6/6 成功。
+ * 所以下面第一条断言就是那个回归闸门。
+ *
+ * 另一条被锁住的事实：老代码重试时把档位**整个去掉**（省略 reasoning），
+ * 实测 20 次重试 0 次成功 —— 对"必须开推理"的端点，省略等于把推理关掉。
+ * 新策略永远给一个显式档位（pickNextEffort 不会返回空，除非真的没档可换）。
+ */
+import { __internals } from '../lib/index.js'
+
+const { looksLikeUnsupportedTier, looksLikeReasoningRequired, pickNextEffort } = __internals
+
+let failed = 0
+function assert(name, ok, detail) {
+  if (ok) {
+    console.log('  ✓ ' + name)
+  } else {
+    failed += 1
+    console.log('  ✗ ' + name + (detail ? ' — ' + detail : ''))
+  }
+}
+
+// ── ① 那条真实的上游文案 ──
+const STEP5_FLAKY =
+  '400: {"type":"server_error","message":"Upstream request failed: [400] Reasoning is mandatory for this endpoint and cannot be disabled."}'
+
+console.log('[1] 偶发上游错误不能被当成"档位不支持"')
+assert('step-5 那句原文 → 不是"档位无效"', looksLikeUnsupportedTier(STEP5_FLAKY) === false)
+assert('step-5 那句原文 → 是"必须开推理"（只在发关档时才算数）', looksLikeReasoningRequired(STEP5_FLAKY) === true)
+assert(
+  '同一句在发 high 时不该被当成档位问题（我们没关推理）',
+  // 调用方的判据：rejected !== 'off' 时用 looksLikeUnsupportedTier
+  looksLikeUnsupportedTier(STEP5_FLAKY) === false,
+)
+
+console.log('\n[2] 真正"档位不被支持"的措辞要认得出来')
+for (const text of [
+  'provider "opencode-go" model "x" does not support reasoning effort "max"',
+  'invalid reasoning effort: max',
+  'unsupported reasoning_effort value',
+  '该模型不支持 reasoning 档位',
+  'thinking 参数无效',
+  'Unrecognized effort "medium"',
+]) {
+  assert('认得：' + text.slice(0, 42), looksLikeUnsupportedTier(text) === true)
+}
+
+console.log('\n[3] 无关错误不要误判成档位问题')
+for (const text of [
+  'Upstream request failed: [500] internal error',
+  'network timeout',
+  '401 unauthorized: invalid api key',
+  'Rate limit exceeded',
+  '模型调用失败',
+]) {
+  assert('不误判：' + text.slice(0, 34), looksLikeUnsupportedTier(text) === false)
+}
+
+console.log('\n[4] 换档：永远给显式档位，且不重复发同一个档')
+const DECLARED = ['off', 'low', 'high', 'max']
+assert('off 被拒 → 低（最接近关的可接受档）', pickNextEffort(DECLARED, null, 'off', new Set(['off'])) === 'low')
+assert('low 被拒 → 高', pickNextEffort(DECLARED, null, 'low', new Set(['low'])) === 'high')
+assert('high 被拒 → 最大', pickNextEffort(DECLARED, null, 'high', new Set(['high'])) === 'max')
+assert(
+  'max 被拒 → 退到高（**不是**退回关：off 恰恰最容易被拒）',
+  pickNextEffort(DECLARED, null, 'max', new Set(['max'])) === 'high',
+)
+assert(
+  '模型声明的 defaultEffort 优先',
+  pickNextEffort(DECLARED, 'medium', 'high', new Set(['high'])) === 'medium',
+)
+assert(
+  'defaultEffort 就是被拒的那个 → 继续沿阶梯找',
+  pickNextEffort(DECLARED, 'high', 'high', new Set(['high'])) === 'max',
+)
+assert(
+  '没档位可换时返回空串（调用方据此不重试，而不是省略档位）',
+  pickNextEffort(['high'], null, 'high', new Set(['high'])) === '',
+)
+assert(
+  '不会发模型没声明的档（只声明 off/low 时不去发 high）',
+  pickNextEffort(['off', 'low'], null, 'low', new Set(['low'])) === 'off',
+)
+assert(
+  '连着重试两次：两次都不重复（off → low → high）',
+  (() => {
+    const tried = new Set(['off'])
+    const a = pickNextEffort(DECLARED, null, 'off', tried)
+    tried.add(a)
+    const b = pickNextEffort(DECLARED, null, a, tried)
+    return a === 'low' && b === 'high'
+  })(),
+)
+assert(
+  '清单还没加载（declared 空）时也能换：走完整阶梯',
+  pickNextEffort([], null, 'low', new Set(['low'])) === 'high',
+)
+
+console.log(failed === 0 ? '\n全部通过 ✓' : `\n${failed} 项失败 ✗`)
+process.exit(failed === 0 ? 0 : 1)

package/scripts/test-filters.mjs

@@ -1,9 +1,12 @@
 /**
- * 流式文本手术刀的确定性单测：思考过滤器 / 工具调用残渣过滤器 / 泄漏思考判别。
+ * 流式文本手术刀的确定性单测：思考过滤器 / 泄漏思考判别 / 工具清单解析。
  *
  * 为什么单独一个文件：这三件事都只能靠"模型吐什么"来发现（思考内联、DSML 残渣都是实测撞出来的），
  * 而模型每次发挥不同 —— 靠真实请求验证会时灵时不灵。这里把 lib/index.js 里的纯函数直接拿来打表。
  *
+ * 注：原先这里还有一节"工具调用残渣过滤器" —— 那个过滤器已经**整体删除**（不再做文本层清洗，
+ * 改为照主会话的做法：工具每轮都带在请求里，模型走协议层表达调用，正文里不会有这种标记）。
+ *
  * 跑法：node scripts/test-filters.mjs（已挂进 npm test）
  */
 import { createRequire } from 'node:module'
@@ -13,7 +16,7 @@ import { dirname, resolve } from 'node:path'
 const HERE = dirname(fileURLToPath(import.meta.url))
 const require = createRequire(import.meta.url)
 const { __internals } = require(resolve(HERE, '..', 'lib', 'index.js'))
-const { createThinkFilter, createResidueFilter, splitLeakedReasoning, looksLikeLeakedReasoning, resolveToolNames } = __internals
+const { createThinkFilter, splitLeakedReasoning, looksLikeLeakedReasoning, resolveToolNames } = __internals
 
 let pass = 0
 let fail = 0
@@ -68,92 +71,6 @@ const M = VB + VB + 'DSML' + VB + VB
   assert('think：没有标签时原样输出（不误伤）', a.text + b.text === '普通正文，没有思考标签' && a.think + b.think === '', '')
 }
 
-// ───────────────────────── 工具调用残渣过滤器 ─────────────────────────
-{
-  // 实测形态①：整块包裹
-  const f = createResidueFilter()
-  const block = `<${M}tool_calls>\n<${M}invoke name="read">\n<${M}parameter name="path">/tmp/a.json</${M}parameter>\n</${M}invoke>\n</${M}tool_calls>`
-  const out = f.push(`前面有正文。${block}后面还有正文。` ) + f.flush()
-  assert('残渣：整块包裹的 DSML 被丢掉、前后正文保留', out === '前面有正文。后面还有正文。', JSON.stringify(out))
-}
-{
-  // 实测形态②：marker 与标签名之间有空格 + 没有外层包裹（漏得最多的那种）
-  const f = createResidueFilter()
-  const raw = `结论在这里。\n<${M} calls>\n<${M} invoke name="glob">\n<${M} parameter name="include" string="true">*.json</${M} parameter>\n</${M} invoke>\n</${M} calls>\n就这样。`
-  const out = f.push(raw) + f.flush()
-  // 残渣块自带换行，整块删掉后会留一个空行 —— 语义上没问题（正文两段仍在），断言里把连续空行归一
-  assert('残渣：带空格的 calls/invoke/parameter 三件套被丢掉', out.replace(/\n{2,}/g, '\n') === '结论在这里。\n就这样。', JSON.stringify(out))
-}
-{
-  // 实测形态③：单个孤立标签 + 参数值（没有 invoke/calls 包裹）
-  const f = createResidueFilter()
-  const raw = `正文 A。<${M} parameter name="limit" string="false">40</${M} parameter>正文 B。`
-  const out = f.push(raw) + f.flush()
-  assert('残渣：孤立的 parameter 标签也被丢掉', out === '正文 A。正文 B。', JSON.stringify(out))
-}
-{
-  // 未闭合（流被截断）→ 从标记起全部丢掉
-  const f = createResidueFilter()
-  const out = f.push(`结论在这里。\n<${M} invoke name="read">`) + f.flush()
-  assert('残渣：未闭合的块整段丢掉（不留在正文里）', out === '结论在这里。\n', JSON.stringify(out))
-}
-{
-  // 逐字喂（最坏分块）：marker 被切碎也不能漏
-  const f = createResidueFilter()
-  const whole = `答案 A。<${M} calls><${M} invoke name="grep">x</${M} invoke></${M} calls>答案 B。`
-  let out = ''
-  for (const ch of whole) out += f.push(ch)
-  out += f.flush()
-  assert('残渣：逐字符喂也不漏（marker 被切碎）', out === '答案 A。答案 B。', JSON.stringify(out))
-}
-{
-  // 标签被切在中间（40+ 字的标签，只留 32 字尾巴时会漏前半截）
-  const f = createResidueFilter()
-  const tag = `<${M} parameter name="include" string="true">`
-  const at = 24 // 切在 '<MARK parameter name="incl' 中间
-  const part1 = '正文 A。' + tag.slice(0, at)
-  const part2 = tag.slice(at) + '值' + `</${M} parameter>` + '正文 B。'
-  const out = f.push(part1) + f.push(part2) + f.flush()
-  assert('残渣：标签被切在中间也不漏（尾部要扣住半个标签）', out === '正文 A。正文 B。', JSON.stringify(out))
-}
-{
-  const f = createResidueFilter()
-  const out = f.push('前<ds_safety_tool_call><tool_name>web_search</tool_name></ds_safety_tool_call>后') + f.flush()
-  assert('残渣：官方 ds_safety_tool_call 同样被丢掉', out === '前后', JSON.stringify(out))
-}
-{
-  const f = createResidueFilter()
-  const text = '正常一段话：<parameter> 不是 DSML 标记；invoke 与 calls 只是英文词。'
-  const out = f.push(text) + f.flush()
-  assert('残渣：普通文本不受影响（没有 marker 的尖括号不误伤）', out === text, JSON.stringify(out))
-}
-
-{
-  // 本轮吐了未闭合的残渣块 → 只在本轮内作废；flush 之后新一轮必须能正常输出
-  // （共用一个过滤器时，这里会让"后续所有轮次的正文"被吞掉：实测表现为"只完成了工具查询，没有产出正文"）
-  const f = createResidueFilter()
-  const first = f.push(`本轮旁白。<${M} invoke name="grep">`) + f.flush()
-  const second = f.push('下一轮的正文，必须原样出来。') + f.flush()
-  assert('残渣：未闭合块只在本轮内作废（flush 后重置深度）', first === '本轮旁白。' && second === '下一轮的正文，必须原样出来。', JSON.stringify({ first, second }))
-}
-{
-  // 同一轮内，未闭合块之后的内容仍然要被丢掉（不能因为"怕误伤"就放行）
-  const f = createResidueFilter()
-  const out = f.push(`本轮旁白。<${M} invoke name="read">后面的参数碎片`) + f.flush()
-  assert('残渣：同一轮内未闭合块之后的内容仍被丢掉', out === '本轮旁白。', JSON.stringify(out))
-}
-
-{
-  // dropped()：统计被丢掉的字数（用来判断"末尾残渣删掉后句子没写完"）
-  const f = createResidueFilter()
-  const out = f.push(`结论写到一半就<${M} invoke name="read">`) + f.flush()
-  assert('残渣：dropped() 统计被丢掉的字数', out === '结论写到一半就' && f.dropped() > 0, `dropped=${f.dropped()}`)
-  const clean = createResidueFilter()
-  clean.push('干净文本，没有残渣。')
-  clean.flush()
-  assert('残渣：干净文本的 dropped() 为 0（不误判成截断）', clean.dropped() === 0, `dropped=${clean.dropped()}`)
-}
-
 // ───────────────────────── 泄漏思考判别 ─────────────────────────
 {
   // 三次实测撞到的真实样本

package/scripts/test-mic-idle.mjs

@@ -0,0 +1,158 @@
+/**
+ * 麦克风探针的生命周期：划词即启动 → 没人看就停 → 再划词再启动。
+ *
+ * 为什么单测它：探针是个常驻原生进程（每秒读 4 次 CoreAudio），原来一旦启动就留到插件卸载 ——
+ * 而插件装着的绝大多数时间没人划词，等于白跑。现在跟着页面的轮询走：
+ * 页面只在"有选区 / 卡片开着"时轮询，探针也就只在那时活着。
+ *
+ * 验三条：
+ *   ① 有人来问才起（之前一直没人问 → 不起）；
+ *   ② 一直有人问 → **不会**停（划词期间不能抖）；
+ *   ③ 没人问满 MIC_IDLE_MS → 停，且状态回落 available=false（不假装还在听）；
+ *   ④ 停了之后再来问 → 能重新起（micStarted 必须复位，否则第二次永远起不来）。
+ *
+ * 用法：node scripts/test-mic-idle.mjs
+ */
+import { createServer } from 'node:http'
+import { mkdtemp, readFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// ⚠️ 这个功能**只在 macOS 上有**：探针读的是 CoreAudio（宿主在非 darwin 上直接报
+// available=false，见 src/index.ts 的平台门禁）。别的平台上这些用例必然全红 ——
+// 与真浏览器冒烟同一套约定：**跑不了就 SKIP、退出码 0**，别把发布流水线卡在一台
+// 没有这个能力的机器上（2026-10-10 实测：ubuntu CI 上 6/7 条红，v0.9.1 那次 CI 之后
+// 才把本用例加进 npm test 链，所以这是第一次真跑到 Linux 上）。
+if (process.platform !== 'darwin') {
+  console.log('SKIP  麦克风探针是 macOS 专属（宿主在非 darwin 上直接报 available=false）—— 本机跳过')
+  process.exit(0)
+}
+
+const dir = await mkdtemp(join(tmpdir(), 'dsh-mic-idle-'))
+const logPath = join(dir, 'probe.log')
+// ⚠️ 环境变量必须在 **import 之前** 设好：宿主那几个常量是在模块求值时读的，
+// 而 ESM 的 import 会被提升到测试体之前 —— 直接 import 的话，这里的赋值就晚了。
+process.env.DSH_SEL_FAKE_PROBE_LOG = logPath
+process.env.DSH_SEL_MIC_PROBE = fileURLToPath(new URL('./fixtures/fake-mic-probe.sh', import.meta.url))
+process.env.DSH_SEL_MIC_IDLE_MS = '150'
+process.env.DSH_SEL_MIC_CHECK_MS = '40'
+const { apply } = await import('../lib/index.js')
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+const logText = async () => {
+  try {
+    return await readFile(logPath, 'utf8')
+  } catch {
+    return ''
+  }
+}
+const starts = async () => ((await logText()).match(/start/g) || []).length
+const stops = async () => ((await logText()).match(/stop/g) || []).length
+
+const routes = new Map()
+const disposers = []
+const ctx = {
+  llm: { listProviders: () => [] },
+  get: () => undefined,
+  on: () => () => {},
+  effect: (fn) => {
+    const dispose = fn()
+    disposers.push(dispose)
+    return dispose
+  },
+  logger: { info() {}, warn() {} },
+  webServer: {
+    register: (route) => {
+      routes.set(route.path, route.handler)
+      return () => routes.delete(route.path)
+    },
+  },
+}
+
+let passed = 0
+let failed = 0
+function check(label, ok, detail) {
+  if (ok) {
+    passed += 1
+    console.log(`PASS  ${label}${detail ? ' — ' + detail : ''}`)
+  } else {
+    failed += 1
+    console.log(`FAIL  ${label}${detail ? ' — ' + detail : ''}`)
+  }
+}
+
+try {
+  apply(ctx, {})
+  const server = createServer((req, res) => {
+    const handler = routes.get(new URL(req.url, 'http://localhost').pathname)
+    if (!handler) {
+      res.writeHead(404)
+      res.end()
+      return
+    }
+    Promise.resolve(handler(req, res)).catch(() => {
+      if (!res.headersSent) res.writeHead(500)
+      res.end()
+    })
+  })
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
+  const origin = 'http://127.0.0.1:' + server.address().port
+  const ask = async () => (await fetch(`${origin}/selection-explain/api/mic`)).json()
+
+  // ① 没人问的时候，探针不该存在
+  await sleep(120)
+  check('没人来问 → 探针不启动', (await starts()) === 0, 'start 次数=' + (await starts()))
+
+  // ② 有人问 → 起
+  const first = await ask()
+  await sleep(120)
+  check(
+    '第一次来问 → 探针启动，且状态是 available',
+    first.ok === true && first.available === true && (await starts()) === 1,
+    `available=${first.available} start=${await starts()}`,
+  )
+
+  check(
+    '探针以约定的采样间隔启动（--watch 125：发现"开麦"的延迟减半）',
+    (await logText()).includes('--watch 125'),
+    JSON.stringify((await logText()).split('\n')[0]),
+  )
+
+  // ③ 一直有人问 → 不停（划词期间不能抖）
+  for (let i = 0; i < 5; i += 1) {
+    await ask()
+    await sleep(40)
+  }
+  check('持续有人问 → 探针不重启也不停', (await starts()) === 1 && (await stops()) === 0, `start=${await starts()} stop=${await stops()}`)
+
+  // ④ 没人问满 IDLE → 停
+  await sleep(600)
+  check('没人问满 MIC_IDLE_MS → 探针停掉', (await stops()) === 1, 'stop 次数=' + (await stops()))
+
+  // ⑤ 再来问 → 能重新起（micStarted 必须被复位，否则第二次永远起不来）
+  const again = await ask()
+  await sleep(160)
+  check(
+    '再划词 → 探针重新启动',
+    again.available === true && (await starts()) === 2,
+    `available=${again.available} start 次数=${await starts()}`,
+  )
+
+  server.close()
+} finally {
+  for (const dispose of disposers) {
+    try {
+      dispose()
+    } catch {
+      /* 忽略 */
+    }
+  }
+  await sleep(400)
+  const after = await stops()
+  check('插件卸载 → 探针被停掉', after >= 1, 'stop 次数=' + after)
+  await rm(dir, { recursive: true, force: true })
+}
+
+console.log(`\n麦克风探针生命周期：${passed} 通过 / ${failed} 失败`)
+process.exit(failed ? 1 : 0)