@yfwu2020/dsh-selection-explain 0.9.1 → 0.10.0

package/scripts/test-client.mjs

@@ -29,7 +29,25 @@ class FakeEl {
     // 真实 DOM 里元素是 1、文本是 3：插件里有 target.nodeType 之类的判断，桩要跟上
     this.nodeType = String(tag) === '#text' ? 3 : 1
     this.children = []
+    // style 用**带 display setter** 的对象：真实浏览器里元素被 display:none 之后会失焦
+    // （activeElement 回到 body）。桩原来是个裸对象，不模拟这件事 —— 于是"卡片收起后
+    // 焦点还挂在它隐藏的 textarea 上"，让后面的"别处正在打字就不抢焦点"守卫误判
+    // （实测：自动聚焦规则一直不生效，查了半天才发现是桩不忠实）。
+    var displayValue = ''
     this.style = {}
+    Object.defineProperty(this.style, 'display', {
+      get: function () {
+        return displayValue
+      },
+      set: function (value) {
+        displayValue = value
+        if (value === 'none' && documentStub && documentStub.activeElement === this) {
+          documentStub.activeElement = body
+        }
+      },
+      enumerable: true,
+      configurable: true,
+    })
     this.dataset = {}
     this.attrs = {}
     this._text = ''
@@ -101,9 +119,25 @@ class FakeEl {
     for (const handler of this._listeners.get(type) || []) handler(event)
   }
   getBoundingClientRect() {
+    // 临时卡片：给一个**和选区自洽**的矩形（落在选区下方）。
+    // 用通用矩形（top:100）的话卡片会跑到选区上方，牵引线走"卡片在上方"那条分支，
+    // 断言就量不到真实场景（卡片在下方）——这个坑我踩过一次。
+    if (this.className === 'dsh-sel-vcard') {
+      return { left: 940, top: 222, right: 1300, bottom: 264, width: 360, height: 42 }
+    }
     return { left: 40, top: 100, right: 500, bottom: 400, width: 460, height: 300 }
   }
+  /**
+   * 真实 DOM：display:none 的元素没有盒子（空列表）——**祖先隐藏也算**。
+   * 插件判断"这个输入框是不是还在页面上"靠它（临时语音卡收起时隐藏的是卡片，不是里面的输入框）。
+   * ⚠️ 合并进原来那个固定矩形版本：类方法同名会**后者覆盖前者**，留两个的话新写的会被悄悄盖掉（踩过）。
+   */
   getClientRects() {
+    var node = this
+    while (node) {
+      if (node.style && node.style.display === 'none') return []
+      node = node.parentNode
+    }
     return [{ left: 40, top: 100, right: 200, bottom: 118, width: 160, height: 18 }]
   }
   get firstChild() {
@@ -239,11 +273,15 @@ const navigatorStub = {}
 // ───────────────────────── 载入 bundle ─────────────────────────
 const source = readFileSync(BUNDLE, 'utf8')
 globalThis.ResizeObserver = ResizeObserverStub
+// 临时实验：关掉收尾复核
+if (typeof windowStub !== 'undefined') windowStub.__DSH_DISABLE_FOCUS_VERIFY = false
 const ORIGIN = process.env.SEL_ORIGIN || 'http://127.0.0.1:3080'
 const sent = []
 const promoted = []
 /** A′：小窗历史的内存版存储（测试用）。 */
 const historyStore = new Map()
+/** 面板尺寸存档（桩）：拖拽/还原用例依赖它造出"上次记住的高度"。 */
+let sizeStore = null
 const historySaved = []
 let historyList = []
 const openedSessions = []
@@ -386,8 +424,76 @@ function withAbort(response, signal) {
   return new Response(stream, { headers: response.headers })
 }
 
+/**
+ * 麦克风占用桩（语音卡用例用）。
+ * 默认 available:false —— 和其它用例一样"这台机器没有这个能力"，谁都不受影响；
+ * 语音卡那条用例把它改成"豆包输入法正在录"，走完整条链路。
+ */
+const micStub = {
+  value: { ok: true, available: false, capturing: false, processes: [], reason: 'stub-default' },
+  /** 被问了几次（"只在引用浮标亮着时轮询"这条要数它，见 ⑨）。 */
+  hits: 0,
+}
+
+/**
+ * 设置桩：离线跑的时候给客户端一份"读得到"的设置。
+ * 默认空对象 = 所有设置都用各自的出厂默认（不写值的键，客户端按默认处理；
+ * 语音那两个收尾开关的出厂默认是**开**，所以下面「卡片留着」那段要先显式设成 false）。
+ * 用例里改 settingsStub.value 之后要调 hook.reloadSettings() ——
+ * 客户端只在启动时读一次设置，不重读的话改桩值不会生效。
+ */
+const settingsStub = { value: {} }
+
 const routeFetch = (input, init) => {
   const url = typeof input === 'string' ? input : ''
+  // 麦克风占用：读的是 host 上的 CoreAudio 探针，测试里由 micStub 决定
+  // ⚠️ 联机模式（SEL_ORIGIN 指向真宿主）下**不能**用空桩顶掉设置请求：
+  // 真实 spec 必须由宿主下发，否则设置页一个分类都画不出来（踩过）。
+  // 但用例又需要"临时把某个设置打开" —— 所以联机模式改成**代理**：
+  // 先读真宿主的设置拿到真实 spec，只把 values 里被用例覆盖的键换掉。
+  if (
+    process.env.SEL_ORIGIN &&
+    Object.keys(settingsStub.value).length &&
+    url.indexOf('/selection-explain/api/settings') >= 0 &&
+    !(init && init.method === 'POST')
+  ) {
+    return fetch(ORIGIN + '/selection-explain/api/settings', { headers: { accept: 'application/json' } })
+      .then((response) => response.json())
+      .then((payload) =>
+        new Response(
+          JSON.stringify(
+            Object.assign({}, payload, {
+              values: Object.assign({}, payload.values, settingsStub.value),
+            }),
+          ),
+          { headers: { 'content-type': 'application/json' } },
+        ),
+      )
+  }
+  if (!process.env.SEL_ORIGIN && url.indexOf('/selection-explain/api/settings') >= 0) {
+    if (init && init.method === 'POST') {
+      try {
+        // ⚠️ 这个 API 的 POST body 是 { values: {...} } 包一层的（宿主侧见 handleSettings），
+        // 不是扁平对象 —— 按扁平解析会一个键都读不到。
+        var posted = JSON.parse(String(init.body || '{}'))
+        Object.assign(settingsStub.value, (posted && posted.values) || {})
+      } catch (error) {
+        /* 桩不校验，校验是宿主的事（见 test-settings-host.mjs） */
+      }
+    }
+    return Promise.resolve(
+      new Response(
+        JSON.stringify({ ok: true, groups: [], values: Object.assign({}, settingsStub.value), defaults: {} }),
+        { headers: { 'content-type': 'application/json' } },
+      ),
+    )
+  }
+  if (url.endsWith('/selection-explain/api/mic')) {
+    micStub.hits += 1
+    return Promise.resolve(
+      new Response(JSON.stringify(micStub.value), { headers: { 'content-type': 'application/json' } }),
+    )
+  }
   // blob:（划词桥的交互式预览用例）：从内存表里读回我们自己建的那份文档。
   // content-type 跟着 blob 的 type 走（真实浏览器就是这么给的）——插件要靠它搬 charset。
   if (url.startsWith('blob:')) {
@@ -415,6 +521,16 @@ const routeFetch = (input, init) => {
     }
     return Promise.resolve(new Response(JSON.stringify(body), { headers: { 'content-type': 'application/json' } }))
   }
+  // 面板尺寸存档：内存版。以前没有桩 → 打到真实 host，既会改到用户的存档，
+  // 也没法造出"上次记住的高度"这个前提（而"拖拽上限被旧天花板卡住"正需要它）。
+  if (url.indexOf('/selection-explain/api/panel') >= 0) {
+    if (init && init.method === 'POST') {
+      const body = JSON.parse(String(init.body || '{}'))
+      sizeStore = body && body.clear === true ? null : body && body.size ? body.size : sizeStore
+      return Promise.resolve(new Response(JSON.stringify({ ok: true, size: sizeStore }), { headers: { 'content-type': 'application/json' } }))
+    }
+    return Promise.resolve(new Response(JSON.stringify({ ok: true, size: sizeStore }), { headers: { 'content-type': 'application/json' } }))
+  }
   // 小窗历史（A′）：内存版实现，避免打到真实 host 拿到脏历史
   if (url.indexOf('/selection-explain/api/history') >= 0) {
     if (init && init.method === 'DELETE') {
@@ -528,7 +644,9 @@ const routeFetch = (input, init) => {
     const payload = [
       `data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', stage: 'translation' })}\n\n`,
       `data: ${JSON.stringify({ type: 'delta', text: '## 翻译\n语音用例的翻译\n' })}\n\n`,
-      `data: ${JSON.stringify({ type: 'done', chars: 8 })}\n\n`,
+      `data: ${JSON.stringify({ type: 'done', chars: 8 })}
+
+`,
     ].join('')
     return Promise.resolve(new Response(payload, { headers: { 'content-type': 'text/event-stream' } }))
   }
@@ -561,6 +679,38 @@ const routeFetch = (input, init) => {
     })
     return Promise.resolve(new Response(stream, { headers: { 'content-type': 'text/event-stream' } }))
   }
+  // 首轮夹具：给"摘要继承用例"用（用未知文本会走真实模型，首轮一直不结束 → 追问被拒）
+  if (body && body.text === 'digest-probe' && !body.question) {
+    const payload = [
+      `data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', stage: 'translation' })}\n\n`,
+      `data: ${JSON.stringify({ type: 'delta', text: '## 翻译\n摘要用例的翻译\n' })}\n\n`,
+      `data: ${JSON.stringify({ type: 'done', chars: 8 })}\n\n`,
+    ].join('')
+    return Promise.resolve(new Response(payload, { headers: { 'content-type': 'text/event-stream' } }))
+  }
+  // 结论轮提示：notice 先到、正文 350ms 后到 —— 用来验"提示在正文到达后消失"（附带的探针）
+  if (body && body.question && body.text === 'notice-probe') {
+    const encoder = new TextEncoder()
+    const stream = new ReadableStream({
+      async start(controller) {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', mode: 'chat', effort: 'high' })}\n\n`))
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'notice', code: 'conclusion-retry', text: '查询已完成，正在整理结论…' })}\n\n`))
+        await new Promise((r) => setTimeout(r, 350))
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'delta', text: '这是结论。' })}\n\n`))
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', chars: 5 })}\n\n`))
+        controller.close()
+      },
+    })
+    return Promise.resolve(new Response(stream, { headers: { 'content-type': 'text/event-stream' } }))
+  }
+  if (body && body.text === 'notice-probe' && !body.question) {
+    const payload = [
+      `data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', stage: 'translation' })}\n\n`,
+      `data: ${JSON.stringify({ type: 'delta', text: '## 翻译\n提示用例的翻译\n' })}\n\n`,
+      `data: ${JSON.stringify({ type: 'done' })}\n\n`,
+    ].join('')
+    return Promise.resolve(new Response(payload, { headers: { 'content-type': 'text/event-stream' } }))
+  }
   // 分三段、每段隔 60ms 的追问流：用来验证滚动跟随（贴底→跟随 / 翻上去→不拽回）
   // 追问等待特效用例：首字前静默 450ms，用来观察气泡里的等待动画与走秒
   if (body && body.question && body.text === 'wait-ask-probe') {
@@ -570,7 +720,9 @@ const routeFetch = (input, init) => {
         controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', mode: 'chat', effort: 'low' })}\n\n`))
         await new Promise((r) => setTimeout(r, 450))
         controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'delta', text: '等到了回答。' })}\n\n`))
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done' })}\n\n`))
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done' })}
+
+`))
         controller.close()
       },
     })
@@ -663,7 +815,40 @@ const routeFetch = (input, init) => {
     return Promise.resolve(new Response(payload, { headers: { 'content-type': 'text/event-stream' } }))
   }
   if (body && body.question) {
+    // 追问失败注入（`globalThis.__askFailOnce = true`）：验"报错之后光标回不回到输入框"
+    if (globalThis.__askFailOnce) {
+      globalThis.__askFailOnce = false
+      return Promise.resolve(
+        new Response(JSON.stringify({ ok: false, error: 'no adapter registered for provider "p1"' }), {
+          status: 500,
+          headers: { 'content-type': 'application/json' },
+        }),
+      )
+    }
     const extra = globalThis.__askExtra || {}
+    // noticeGapMs：在 notice 与正文之间留一段空档。
+    // 验"过程提示在正文到达前看得见"必须有观察窗口 —— 一口气发完的话，
+    // 提示会在同一批 SSE 里被 delta 立刻撤掉，轮询根本抓不到。
+    if (extra.noticeGapMs) {
+      const encoder = new TextEncoder()
+      const stream = new ReadableStream({
+        async start(controller) {
+          controller.enqueue(
+            encoder.encode(`data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', mode: 'chat', effort: 'low' })}\n\n`),
+          )
+          if (extra.notice) {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'notice', ...extra.notice })}\n\n`))
+          }
+          await new Promise((r) => setTimeout(r, extra.noticeGapMs))
+          controller.enqueue(
+            encoder.encode(`data: ${JSON.stringify({ type: 'delta', text: extra.delta || '这是对追问的回答：' + body.question })}\n\n`),
+          )
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', chars: 12, toolCalls: 0 })}\n\n`))
+          controller.close()
+        },
+      })
+      return Promise.resolve(new Response(stream, { headers: { 'content-type': 'text/event-stream' } }))
+    }
     const payload = [
       `data: ${JSON.stringify({ type: 'start', provider: 'fixture', model: 'fixture', mode: 'chat', effort: 'low' })}\n\n`,
       ...(extra.notice && !extra.strip ? [`data: ${JSON.stringify({ type: 'notice', ...extra.notice })}\n\n`] : []),
@@ -1289,8 +1474,17 @@ if (HOST_UP) {
 
 // ── 以下全部是真实 host 集成断言（SSE 流式渲染 / 面板交互 / 历史 / 清理）──
 // CI 里没有宿主，跳过；本地开发有宿主时全跑。
+//
+// ⚠️⚠️ 这一节会**改真实配置**：模型选择用例会写 provider/model，还会点「恢复默认」。
+// 对着"用户正在用的插件"跑，副作用会留下来 —— 实测事故：联机测试把 provider/model 写成了
+// 夹具的 p1/m-fast，用户此后每次请求都失败（no adapter registered for provider "p1"）。
+// 所以这里先快照整份设置，本节结束时（见文件后面的 settingsSnapshot 还原）按快照写回。
+// 要跑"绝不留副作用"的设置用例，用 test-settings-host.mjs（隔离 DSH_HOME + 新加载宿主）。
 if (HOST_UP) {
 
+const settingsSnapshot = await (
+  await fetch(ORIGIN + '/selection-explain/api/settings', { headers: { accept: 'application/json' } })
+).json()
 const deadline = Date.now() + 90000
 while (Date.now() < deadline) {
   const state = hook.state()
@@ -2076,8 +2270,8 @@ assert(
   assert('跟随态那一行带「跟随」小标（这个勾来自主会话，不是自己选的）',
     !!on[0] && !!Array.from(walk(on[0])).find((n) => String(n.className) === 'dsh-sel-pickerfollow' && textOf(n) === '跟随'),
     on[0] ? Array.from(walk(on[0])).map((n) => String(n.className) + ':' + textOf(n)).join(', ') : '未找到')
-  assert('跟随态：档位按钮列的是**在用模型**声明的档位（m-fast 四档）',
-    tiersIn().map((b) => textOf(b)).join('/') === '关/低/高/最大', tiersIn().map((b) => textOf(b)).join('/'))
+  assert('档位按钮 = 与设置页同一套四个格子（关/低/高/最高，与模型无关）',
+    tiersIn().map((b) => textOf(b)).join('/') === '关/低/高/最高', tiersIn().map((b) => textOf(b)).join('/'))
 
   // 选一个具体模型：勾挪到那一行、「跟随」小标消失、档位收缩成它声明的那几档
   const strong = rowsIn().find((r) => textOf(r).indexOf('Strong Model') >= 0)
@@ -2089,8 +2283,8 @@ assert(
     on2.map((r) => textOf(r)).join(' | '))
   assert('选过之后：「跟随」小标消失（这个勾是你自己选的）',
     !Array.from(walk(menu)).some((n) => String(n.className) === 'dsh-sel-pickerfollow'), '')
-  assert('选过之后：档位收缩成该模型声明的 2 档',
-    tiersIn().map((b) => textOf(b)).join('/') === '关/高', tiersIn().map((b) => textOf(b)).join('/'))
+  assert('选过之后：档位仍是那四个格子（换模型不改词汇，只改它落到哪个档）',
+    tiersIn().map((b) => textOf(b)).join('/') === '关/低/高/最高', tiersIn().map((b) => textOf(b)).join('/'))
 
   // 还原：走抽屉里那颗「恢复默认」（客户端自己的路径，state 与 host 都回到跟随态）
   await new Promise((r) => setTimeout(r, 700))
@@ -2106,6 +2300,216 @@ assert(
   await new Promise((r) => setTimeout(r, 30))
 }
 
+// ⚠️ 这一段必须跑在**新加载**的宿主上（test-settings-host.mjs 用隔离目录新加载一份）。
+// 直接对着“正在跑的插件”跑会失败 —— 那是上一次启动时加载的旧代码，
+// 除非用户重载过插件。
+if (process.env.SEL_SETTINGS_ONLY === '1') {
+  // 新增的两个语音收尾开关（界面 · 语音输入）：必须在 spec 里、默认开、且只收布尔值。
+  // 尽量只读：唯一的写操作是"写回默认值"，写完回到默认，不留副作用。
+  {
+    const payload = await (await fetch(ORIGIN + '/selection-explain/api/settings', { headers: { accept: 'application/json' } })).json()
+    const items = (payload.groups || []).reduce((acc, g) => acc.concat(g.items || []), [])
+    const cancelItem = items.find((i) => i.key === 'voiceCancelOnSilence')
+    const sendItem = items.find((i) => i.key === 'voiceAutoSend')
+    assert(
+      '语音收尾的两个开关都在设置 spec 里（kind=switch，挂在界面组）',
+      !!cancelItem && !!sendItem && cancelItem.kind === 'switch' && sendItem.kind === 'switch',
+      JSON.stringify({ cancel: !!cancelItem, send: !!sendItem, kinds: [cancelItem && cancelItem.kind, sendItem && sendItem.kind] }),
+    )
+    assert(
+      '两个语音开关**默认都是开**（2026-10-09 用户指定）',
+      payload.defaults.voiceCancelOnSilence === true && payload.defaults.voiceAutoSend === true,
+      JSON.stringify({ cancel: payload.defaults.voiceCancelOnSilence, send: payload.defaults.voiceAutoSend }),
+    )
+    const bad = await (await fetch(ORIGIN + '/selection-explain/api/settings', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ values: { voiceAutoSend: 'yes' } }),
+    })).json()
+    assert(
+      '语音开关只接受布尔值（字符串被拒，且不写进配置）',
+      bad.ok === false && (bad.rejected || []).some((r) => r.key === 'voiceAutoSend'),
+      JSON.stringify(bad).slice(0, 140),
+    )
+    await fetch(ORIGIN + '/selection-explain/api/settings', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ values: { voiceAutoSend: false, voiceCancelOnSilence: false } }),
+    })
+    const off = await (await fetch(ORIGIN + '/selection-explain/api/settings', { headers: { accept: 'application/json' } })).json()
+    assert(
+      '两个语音开关能写回并读回（关掉也记得住）',
+      off.values.voiceAutoSend === false && off.values.voiceCancelOnSilence === false,
+      JSON.stringify({ send: off.values.voiceAutoSend, cancel: off.values.voiceCancelOnSilence }),
+    )
+    // 写回默认（开），不留副作用
+    await fetch(ORIGIN + '/selection-explain/api/settings', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ values: { voiceAutoSend: true, voiceCancelOnSilence: true } }),
+    })
+  }
+}
+
+// ── 设置页「思考强度」：四个格子不变，下面那行**跟着当前模型**说清落到哪一档 ──
+//   映射由 host 按模型声明实时算（`/models` 每个模型带 `effortMap`）；这里验客户端把它显示对了、
+//   换模型会跟着变、模型不支持推理时说清"这一组不生效"。
+{
+  const fixture = globalThis.__modelCatalogFixture
+  const weird = {
+    provider: 'p2', providerName: 'Provider Two', model: 'm-weird', name: 'Weird Model',
+    // 词汇表长得不一样：没有 off、顶档叫 xhigh（本机 grok-4.6 就是这种）
+    efforts: [
+      { id: 'low', name: 'Low' }, { id: 'medium', name: 'Medium' },
+      { id: 'high', name: 'High' }, { id: 'xhigh', name: 'Xhigh' },
+    ],
+    defaultEffort: null, hasReasoning: true,
+    effortMap: { off: 'low', low: 'medium', high: 'high', max: 'xhigh' },
+  }
+  const plain = {
+    provider: 'p2', providerName: 'Provider Two', model: 'm-plain', name: 'Plain Model',
+    efforts: [], defaultEffort: null, hasReasoning: false, effortMap: {},
+  }
+  globalThis.__modelCatalogFixture = { ...fixture, current: { provider: 'p2', model: 'm-weird' }, models: [...fixture.models, weird, plain] }
+
+  // 开抽屉（每次都强制重取清单）→ 那行提示应当报出这个模型的落点
+  settingsBtn.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+  const hintNode = () => Array.from(walk(settingsSheet)).find((n) => n.getAttribute && n.getAttribute('data-effortmap') === '1')
+  for (let i = 0; i < 40 && (!hintNode() || hintNode().textContent.indexOf('xhigh') < 0); i += 1) {
+    await new Promise((r) => setTimeout(r, 50))
+  }
+  // 拿小写比：右边是**模型自己的档位名**（Off/Low/Xhigh…），大小写不保证
+  const hintText = String((hintNode() || {}).textContent || '')
+  const hintLower = hintText.toLowerCase()
+  assert(
+    '四格还在（关/低/高/最高 四个格子没变），下面多一行实时映射',
+    !!hintNode() && String(hintNode().className).indexOf('dsh-sel-effortmap') >= 0,
+    hintText,
+  )
+  assert(
+    '映射说的是**当前模型**的真实档位（关→low · 低→medium · 高→high · 最高→xhigh）',
+    hintLower.indexOf('关 → low') >= 0 && hintLower.indexOf('低 → medium') >= 0 &&
+      hintLower.indexOf('高 → high') >= 0 && hintLower.indexOf('最高 → xhigh') >= 0,
+    hintText,
+  )
+  assert('四格本身一个不多一个不少（没有被模型带跑）', (hintText.match(/→/g) || []).length === 4, hintText)
+
+  // **从抽屉自己的模型下拉里换模型**（用户报的那条路径：原来只有胶囊跟着变，这行不动）
+  {
+    const pick = Array.from(walk(settingsSheet)).find((n) => n.className === 'dsh-sel-spick')
+    pick.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+    await new Promise((r) => setTimeout(r, 30))
+    const plainRow = Array.from(walk(settingsSheet))
+      .filter((n) => n.className === 'dsh-sel-spickrow')
+      .find((r) => textOf(r).indexOf('Plain Model') >= 0)
+    assert('（前提）下拉里能找到另一个模型', !!plainRow, textOf(pick))
+    plainRow.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+    for (let i = 0; i < 60 && String((hintNode() || {}).textContent || '').indexOf('不支持思考强度') < 0; i += 1) {
+      await new Promise((r) => setTimeout(r, 50))
+    }
+    assert(
+      '从设置页的模型下拉换模型：那行映射立刻跟着换（不再只有胶囊变）',
+      String((hintNode() || {}).textContent || '').indexOf('不支持思考强度') >= 0,
+      String((hintNode() || {}).textContent || ''),
+    )
+    // 走客户端自己的「恢复默认」把模型写回跟随态（别把真实配置留在具体模型上）
+    const resetBtn = Array.from(walk(settingsSheet)).find((n) => n.className === 'dsh-sel-sbtn' && textOf(n).indexOf('恢复默认') >= 0)
+    resetBtn.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+    await new Promise((r) => setTimeout(r, 900))
+  }
+
+  // 换成"明确不支持推理"的模型 → 说清这一组不生效（而不是假装能选）
+  globalThis.__modelCatalogFixture = { ...fixture, current: { provider: 'p2', model: 'm-plain' }, models: [...fixture.models, weird, plain] }
+  const backBtn2 = Array.from(walk(settingsSheet)).find((n) => n.className === 'dsh-sel-sheetback')
+  backBtn2.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+  await new Promise((r) => setTimeout(r, 20))
+  settingsBtn.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+  for (let i = 0; i < 40 && String((hintNode() || {}).textContent || '').indexOf('不支持思考强度') < 0; i += 1) {
+    await new Promise((r) => setTimeout(r, 50))
+  }
+  assert(
+    '模型不支持推理时：这行如实说"不生效（不会发送档位）"',
+    String((hintNode() || {}).textContent || '').indexOf('不支持思考强度') >= 0,
+    String((hintNode() || {}).textContent || ''),
+  )
+
+  // 两边**同词同源**：小窗那个档位控件与设置页「思考强度 · 追问」都是同一套四个格子，
+  //   读写同一个配置值（chatReasoningEffort），于是不需要任何反向映射
+  {
+    hook.openModel()
+    await new Promise((r) => setTimeout(r, 30))
+    const tierBtns = () => Array.from(walk(hook.modelNodes().menu)).filter((n) => String(n.className) === 'dsh-sel-tierbtn')
+    assert(
+      '小窗的档位按钮 = 设置页那四个格子（关/低/高/最高）',
+      tierBtns().map((b) => textOf(b)).join('/') === '关/低/高/最高',
+      tierBtns().map((b) => textOf(b)).join('/'),
+    )
+    assert('每个格子带自己的 slot 记号（不是模型档位 id）',
+      tierBtns().map((b) => b.getAttribute('data-slot')).join('/') === 'off/low/high/max',
+      tierBtns().map((b) => b.getAttribute('data-slot')).join('/'))
+
+    // 小窗里点「高」→ 设置页那一行同一格 + 内存里就是同一个值
+    const highBtn = tierBtns().find((b) => textOf(b) === '高')
+    highBtn.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+    await new Promise((r) => setTimeout(r, 30))
+    assert('（前提）小窗记下了这一格', hook.modelState().effort === 'high', String(hook.modelState().effort))
+    settingsBtn.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+    await new Promise((r) => setTimeout(r, 60))
+    const segOf = () => Array.from(walk(settingsSheet)).find(
+      (n) => String(n.className) === 'dsh-sel-seg' && n.attrs && n.attrs['aria-label'] === '追问',
+    )
+    assert(
+      '小窗点「高」→ 设置页那一行也是「高」（同一份数据，不需要映射）',
+      !!segOf() && segOf().getAttribute('data-value') === 'high',
+      segOf() ? String(segOf().getAttribute('data-value')) : '(未找到)',
+    )
+
+    // 反向：设置页点「低」→ 小窗那四个格子（菜单开着时）也跟着换
+    const segCells = Array.from(walk(segOf())).filter((n) => String(n.className) === 'dsh-sel-segcell')
+    const lowCell = segCells.find((c) => c.getAttribute('data-value') === 'low')
+    lowCell.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+    await new Promise((r) => setTimeout(r, 30))
+    assert('设置页点「低」→ 小窗也是同一格', hook.modelState().effort === 'low', String(hook.modelState().effort))
+    assert(
+      '小窗菜单里的选中态跟着换（不必重开菜单）',
+      Array.from(walk(hook.modelNodes().menu))
+        .filter((n) => String(n.className) === 'dsh-sel-tierbtn' && n.getAttribute('data-on') === '1')
+        .map((b) => textOf(b))
+        .join('/') === '低',
+      Array.from(walk(hook.modelNodes().menu)).filter((n) => n.getAttribute && n.getAttribute('data-on') === '1').map((b) => textOf(b)).join('/'),
+    )
+
+    // 词汇很怪的模型也一样只列四个格子 —— 这正是"不需要反向映射"的证明
+    globalThis.__modelCatalogFixture = { ...fixture, current: { provider: 'p2', model: 'm-weird' }, models: [...fixture.models, weird, plain] }
+    const backToPanel = Array.from(walk(settingsSheet)).find((n) => n.className === 'dsh-sel-sheetback')
+    backToPanel.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+    await new Promise((r) => setTimeout(r, 20))
+    settingsBtn.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+    await new Promise((r) => setTimeout(r, 80))
+    hook.openModel()
+    await new Promise((r) => setTimeout(r, 30))
+    assert(
+      '模型声明 minimal/xhigh 这种怪档位时，小窗仍然只列四个格子（不再出现 Xhigh/Medium）',
+      tierBtns().map((b) => textOf(b)).join('/') === '关/低/高/最高' &&
+        !tierBtns().some((b) => String(b.title).indexOf('Xhigh') >= 0 && !String(b.title).indexOf('该模型发')),
+      tierBtns().map((b) => textOf(b) + (b.title ? '(' + String(b.title) + ')' : '')).join(' / '),
+    )
+
+    // 收尾：恢复默认（写回跟随态）、收起抽屉与面板
+    const resetBtn2 = Array.from(walk(settingsSheet)).find((n) => n.className === 'dsh-sel-sbtn' && textOf(n).indexOf('恢复默认') >= 0)
+    resetBtn2.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+    await new Promise((r) => setTimeout(r, 900))
+    hook.close()
+    await new Promise((r) => setTimeout(r, 30))
+  }
+
+  // 收尾：抽屉还原、夹具还原（别影响后面的用例）
+  const backBtn3 = Array.from(walk(settingsSheet)).find((n) => n.className === 'dsh-sel-sheetback')
+  backBtn3.dispatch('click', { stopPropagation() {}, preventDefault() {} })
+  await new Promise((r) => setTimeout(r, 20))
+  globalThis.__modelCatalogFixture = fixture
+}
+
 if (process.env.SEL_SETTINGS_ONLY === '1') {
   console.log('=== 设置与模型集成测试结束（真实 host，临时数据目录）===')
   process.exit(process.exitCode ?? 0)
@@ -2415,7 +2819,23 @@ for (let i = 0; i < 120 && hook.state().phase !== 'done'; i += 1) await sleep(20
   for (let i = 0; i < 80 && sent.length === beforeWeb; i += 1) await sleep(20)
   const webPayload = sent[sent.length - 1] || {}
   assert('开启后追问请求带 webAnswer: true', webPayload.webAnswer === true, JSON.stringify({ webAnswer: webPayload.webAnswer, q: webPayload.question }))
+  // 网页输出还得带上当前深浅：深色 Harness 里给一张白底页面会很刺眼（host 据此注入配色规范）
+  assert('网页输出带上当前主题（dark/light）', webPayload.theme === 'dark' || webPayload.theme === 'light', JSON.stringify(webPayload.theme))
   await waitIdle()
+
+  // 主题检测必须优先读 **DSH 自己的信号**（body[data-ds-dark-theme]），而不是面板的合成底色。
+  // 踩过的坑：外观设成"跟随系统（暗）"时，面板底色取自 DSH 变量、自身透明 → 被算成浅色
+  // → 生成的网页是亮色（用户实测报的）。DSH 不管用户选哪一档，都会把最终配色投影到这个属性上。
+  {
+    body.setAttribute('data-ds-dark-theme', '')
+    const beforeDark = sent.length
+    hook.ask('深色下再来一次：三种方式对比')
+    for (let i = 0; i < 80 && sent.length === beforeDark; i += 1) await sleep(20)
+    const darkPayload = sent[sent.length - 1] || {}
+    assert('跟随系统的深色下，网页输出带 theme: dark', darkPayload.theme === 'dark', JSON.stringify(darkPayload.theme))
+    body.removeAttribute('data-ds-dark-theme')
+    await waitIdle()
+  }
   hook.setWebMode(false)
   const beforePlain = sent.length
   hook.ask('简单问题')
@@ -2538,13 +2958,16 @@ for (let i = 0; i < 120 && hook.state().phase !== 'done'; i += 1) await sleep(20
   assert('追问停止也有记录（自检可读）', /已停止/.test(String(hook.state().status || '')), String(hook.state().status))
 }
 
-// ───────────────────────── 没有工具时不许伪造调用 ─────────────────────────
+// ────────────── 正文不再做文本层清洗（照主会话的做法） ──────────────
+//
+// 以前这里断言"<ds_safety_tool_call> 被剥掉"。现在**故意不清洗**了：
+// 主会话从不摘工具，模型走协议层表达工具调用，正文里根本不会有这种标记；
+// 而留一道清洗，在标记"未闭合"时会把正文尾巴一起吃掉（实测：收尾轮 raw=726 → emitted=0）。
+// 所以这条用例改成锁住"原样显示"，防止以后又有人把清洗加回来。
 hook.open('fake-tool-probe', '', '伪造调用')
 for (let i = 0; i < 80 && hook.state().phase !== 'done'; i += 1) await sleep(20)
-assert('模型吐出的 <ds_safety_tool_call> 被剥掉', textOf(sections[0]).indexOf('ds_safety_tool_call') < 0 && textOf(sections[0]).indexOf('tool_name') < 0, textOf(sections[0]).slice(0, 60))
-assert('正文其余内容保留', textOf(sections[0]).indexOf('没有工具时的回答') >= 0, textOf(sections[0]).slice(0, 60))
-assert('明确告知"本轮没有可用工具"', textOf(sections[0]).indexOf('没有可用工具') >= 0, textOf(sections[0]).slice(0, 80))
-assert('自检钩子报出伪造残渣标记', hook.state().toolResidue === true, String(hook.state().toolResidue))
+assert('正文原样保留：客户端不再做文本层清洗', String(hook.state().raw).indexOf('ds_safety_tool_call') >= 0, String(hook.state().raw).slice(0, 60))
+assert('正文其余内容保留（不做手术就不会误伤）', textOf(sections[0]).indexOf('没有工具时的回答') >= 0, textOf(sections[0]).slice(0, 80))
 
 // ───────────────────────── 追问小窗（临时多轮对话） ─────────────────────────
 const askBox = Array.from(walk(panel)).find((n) => n.className === 'dsh-sel-askbox')
@@ -2841,7 +3264,6 @@ assert('追问等待期不重建节点（动画不被打断）', classesIn(askBu
 await sleep(400)
 const botBubbles = askBubbles()
 assert('首个字到达后等待特效换成正文', classesIn(botBubbles[botBubbles.length - 1], 'dsh-sel-wait').length === 0 && textOf(botBubbles[botBubbles.length - 1]).indexOf('等到了回答') >= 0, JSON.stringify(textOf(botBubbles[botBubbles.length - 1]).slice(0, 24)))
-
 // ───────────────────────── 本地缓存：同一个词再点一次必须秒回 ─────────────────────────
 hook.open('缓存探测词', '上下文片段 A', '缓存用例')
 for (let i = 0; i < 80 && hook.state().phase !== 'done'; i += 1) await sleep(20)
@@ -3031,6 +3453,65 @@ for (let i = 0; i < 40 && !textOf(sections[0]).trim(); i += 1) await sleep(20)
 assert('内存空了也能回放最近一条小窗', panel.style.display !== 'none' && textOf(sections[0]).trim().length > 0, textOf(sections[0]).slice(0, 40))
 assert('回放走的是历史，不重新调模型', sent.length === sentBeforeReplay, `新增请求 ${sent.length - sentBeforeReplay}`)
 
+// 生成中按 Enter：提示"还在生成"，但**你打的字必须留着**
+// （以前是"先清空、再被 ask() 拒掉" —— 字直接丢了，只剩一句提示）
+{
+  const slowStart2 = sent.length
+  hook.open('中止探测', '', '生成中发消息')
+  for (let i = 0; i < 60 && sent.length === slowStart2; i += 1) await sleep(20)
+  for (let i = 0; i < 60 && hook.state().phase !== 'streaming'; i += 1) await sleep(20)
+  assert('（前提）这一轮正在流式输出', hook.state().phase === 'streaming', String(hook.state().phase))
+  hook.askValue('生成中想好的下一句')
+  const sentBeforeBusy = sent.length
+  askBox.dispatch('keydown', { key: 'Enter', preventDefault() {}, stopPropagation() {} })
+  // 立刻读：流式的计时器每秒会把 status 覆盖成"生成中… Ns"，晚读就看不到了
+  const statusNow = String(hook.state().status || '')
+  await sleep(60)
+  assert(
+    '生成中按 Enter：你打的字还在输入框里（不会被清掉）',
+    askBox.value === '生成中想好的下一句',
+    JSON.stringify(askBox.value),
+  )
+  // 注意：这条提示目前**只在 state.lastStatus 里**（界面上不渲染）—— 见提交说明里的发现。
+  assert(
+    '生成中按 Enter：记下还在生成这条状态（供后续接上可见提示）',
+    /还在生成/.test(statusNow),
+    JSON.stringify(statusNow),
+  )
+  assert('生成中按 Enter：没有真的发出去', sent.length === sentBeforeBusy, String(sent.length - sentBeforeBusy))
+  hook.askValue('')
+  hook.close()
+  await sleep(40)
+}
+
+// 换选区不该继承上一段对话的检索结果（toolDigest 的语义单位是"一次对话"）
+// 踩过的坑：state 整页只建一次，digest 只在历史回放时按条目恢复、别处从不复位 ——
+// 于是某段对话搜过新闻之后，之后每一段新选区的追问都带着那段新闻。
+{
+  hook.open('digest-probe', '', '摘要继承用例')
+  for (let i = 0; i < 80 && hook.state().phase !== 'done'; i += 1) await sleep(20)
+  assert('新面板开局：检索摘要是空的', hook.state().toolDigest === '', JSON.stringify(String(hook.state().toolDigest).slice(0, 40)))
+  hook.ask('旁白追问')
+  for (let i = 0; i < 80 && !hook.state().toolDigest; i += 1) await sleep(20)
+  assert('工具检索会累进检索摘要', String(hook.state().toolDigest).length > 0, JSON.stringify(String(hook.state().toolDigest).slice(0, 40)))
+  hook.open('digest-probe-2', '', '另一段选区')
+  assert('换选区后不继承上一段的检索摘要', hook.state().toolDigest === '', JSON.stringify(String(hook.state().toolDigest).slice(0, 60)))
+  for (let i = 0; i < 40; i += 1) await sleep(20)
+}
+
+// 结论轮提示（"查询已完成，正在整理结论…"）在正文到达后必须消失
+// 踩过的坑：它写进 answerTurn.notice 之后再没有任何地方清掉 —— 回答早就写完了，黄条还挂着。
+{
+  const noticeEl = () => Array.from(walk(panel)).find((n) => String(n.className).indexOf('dsh-sel-notice') >= 0)
+  hook.open('notice-probe', '', '提示用例')
+  for (let i = 0; i < 80 && hook.state().phase !== 'done'; i += 1) await sleep(20)
+  hook.ask('这个提示会不会一直挂着')
+  for (let i = 0; i < 30 && !noticeEl(); i += 1) await sleep(20)
+  assert('结论轮提示会出现（过程状态）', !!noticeEl(), noticeEl() ? JSON.stringify(textOf(noticeEl()).slice(0, 20)) : '未找到')
+  for (let i = 0; i < 60 && noticeEl(); i += 1) await sleep(20)
+  assert('正文到达后提示消失（不再永远挂着）', !noticeEl(), noticeEl() ? JSON.stringify(textOf(noticeEl()).slice(0, 20)) : '')
+  for (let i = 0; i < 40; i += 1) await sleep(20)
+}
 // 收起小窗 = 中止这一轮，不该记成"失败"，而是"已停止"（点回来还能重新生成）
 const slowStart = sent.length
 hook.open('中止探测', '', '中止用例')
@@ -3192,7 +3673,7 @@ assert('点回来看到"已停止"的状态与可重试入口', hook.state().pha
   assert('拉到模型清单（3 个）', loaded.count === 3, JSON.stringify(loaded))
   assert('没选过模型时胶囊也有文案（跟随当前路由）', nodes.pill.textContent.trim().length > 0, nodes.pill.textContent)
   assert('菜单列出全部模型 + provider 名', rowsIn().length === 3, String(rowsIn().length))
-  assert('档位按钮来自该模型声明的等级（4 档）', tiersIn().map((b) => textOf(b)).join('/') === '关/低/高/最大', tiersIn().map((b) => textOf(b)).join('/'))
+  assert('档位按钮 = 与设置页同一套四个格子', tiersIn().map((b) => textOf(b)).join('/') === '关/低/高/最高', tiersIn().map((b) => textOf(b)).join('/'))
 
   // 点"Strong Model"
   const strong = rowsIn().find((r) => textOf(r).indexOf('Strong Model') >= 0)
@@ -3202,13 +3683,18 @@ assert('点回来看到"已停止"的状态与可重试入口', hook.state().pha
   const selectedSettings = await (await fetch(ORIGIN + '/selection-explain/api/settings')).json()
   assert('模型选择保存到统一设置', selectedSettings.values.provider === 'p1' && selectedSettings.values.model === 'm-strong', JSON.stringify(selectedSettings.values))
   assert('菜单里的勾选跟着换', rowsIn().filter((r) => r.getAttribute('data-on') === '1').length === 1, '')
-  assert('档位按钮收缩成该模型支持的 2 档', tiersIn().map((b) => textOf(b)).join('/') === '关/高', tiersIn().map((b) => textOf(b)).join('/'))
+  assert('换模型后档位仍是那四个格子（词汇与设置页一致，不跟模型走）', tiersIn().map((b) => textOf(b)).join('/') === '关/低/高/最高', tiersIn().map((b) => textOf(b)).join('/'))
 
-  // 点档位"低"→ 该模型没声明低档，仍然允许（host 会按 id 透传）；这里点"关"
+  // 点"关"那一格 → 记进配置（host 再按当前模型把它映射成真实档位）
   const offBtn = tiersIn().find((b) => textOf(b) === '关')
   offBtn.dispatch('click', { preventDefault() {}, stopPropagation() {} })
   assert('点档位 → 胶囊上的档位跟着变', nodes.pill.textContent.indexOf('关') >= 0, nodes.pill.textContent)
-  assert('档位落盘', String(windowStub.localStorage.getItem('dsh-selection-explain:effort')) === 'off', String(windowStub.localStorage.getItem('dsh-selection-explain:effort')))
+  // 档位只有**一份**数据：设置里的 chatReasoningEffort（不再有 localStorage 覆盖）
+  await new Promise(r => setTimeout(r, 700))
+  const effortSaved = await (await fetch(ORIGIN + '/selection-explain/api/settings')).json()
+  assert('档位写进统一设置（chatReasoningEffort），不再是浏览器本地覆盖',
+    effortSaved.values.chatReasoningEffort === 'off' && windowStub.localStorage.getItem('dsh-selection-explain:effort') === null,
+    JSON.stringify({ saved: effortSaved.values.chatReasoningEffort, local: windowStub.localStorage.getItem('dsh-selection-explain:effort') }))
 
   // 请求要带上 provider/model/effort（紧跟点档位之后断言，免得被后面的用例改状态影响）
   {
@@ -3220,35 +3706,6 @@ assert('点回来看到"已停止"的状态与可重试入口', hook.state().pha
     for (let i = 0; i < 300; i += 1) { const list = hook.turns(); if (list.length && !list.some((t) => t.streaming === true)) break; await sleep(20) }
   }
 
-  // 客户端兜底：旧缓存/历史回放里的工具调用残渣（两种形态：官方 safety + DSML 带空格形态）
-  {
-    const VB = String.fromCharCode(0xff5c)
-    const MK = VB + VB + 'DSML' + VB + VB
-    const dirty = `正文。<${MK} parameter name="limit" string="false">40</${MK} parameter>尾。`
-    hook.close()
-    await sleep(30)
-    hook.open('residue-probe', '上下文：清残渣', '残渣兜底用例')
-    for (let i = 0; i < 120 && hook.state().phase !== 'done'; i += 1) await sleep(20)
-    await sleep(30)
-    globalThis.__askExtra = { delta: dirty }
-    const before = hook.turns().length
-    hook.ask('残渣兜底追问')
-    for (let i = 0; i < 300; i += 1) {
-      const list = hook.turns()
-      if (list.length > before && !list.some((t) => t.streaming === true)) break
-      await sleep(20)
-    }
-    await sleep(60)
-    const stripped = hook.stripResidue(dirty)
-    assert('客户端兜底：函数本身能清掉带空格的 DSML（含孤立标签）', stripped.indexOf(MK) < 0 && !/parameter\s+name=/.test(stripped) && stripped.indexOf('正文。') >= 0, JSON.stringify(stripped))
-    const rendered = textOf(chatLog)
-    assert(
-      '客户端兜底：带空格的 DSML 残渣不会渲染进消息区',
-      rendered.indexOf(MK) < 0 && !/parameter\s+name=/.test(rendered) && rendered.indexOf('正文。') >= 0,
-      JSON.stringify(rendered.slice(-60)),
-    )
-    globalThis.__askExtra = null
-  }
 
   // strip 事件：把"模型写进正文的思考"从已流出的正文里撤回，并按"泄漏"记进记忆
   {
@@ -3294,7 +3751,7 @@ assert('点回来看到"已停止"的状态与可重试入口', hook.state().pha
     hook.openModel() // 菜单要先渲染出来，否则下面找不到按钮（前面的 strip 用例重渲染过）
     await sleep(20)
     const tierBtns = Array.from(walk(hook.modelNodes().menu)).filter((n) => String(n.className) === 'dsh-sel-tierbtn')
-    const pickBtn = tierBtns.find((b) => textOf(b) === '最大') || tierBtns[0]
+    const pickBtn = tierBtns.find((b) => textOf(b) === '最高') || tierBtns[0]
     if (pickBtn) pickBtn.dispatch('click', { preventDefault() {}, stopPropagation() {} })
     const chosen = hook.modelState().effort
     assert('用例前置：先选上一个档位', typeof chosen === 'string' && chosen.length > 0, String(chosen))
@@ -3352,9 +3809,9 @@ assert('点回来看到"已停止"的状态与可重试入口', hook.state().pha
   const rows = () => Array.from(walk(hook.modelNodes().menu)).filter((n) => String(n.className) === 'dsh-sel-pickerrow')
   rows()[0].dispatch('click', { preventDefault() {}, stopPropagation() {} })
   const tiers = () => Array.from(walk(hook.modelNodes().menu)).filter((n) => String(n.className) === 'dsh-sel-tierbtn')
-  const maxBtn = tiers().find((b) => textOf(b) === '最大')
+  const maxBtn = tiers().find((b) => textOf(b) === '最高')
   maxBtn.dispatch('click', { preventDefault() {}, stopPropagation() {} })
-  assert('选到「最大」档后胶囊显示它', hook.modelState().effort === 'max', String(hook.modelState().effort))
+  assert('选到「最高」那一格后胶囊显示它', hook.modelState().effort === 'max', String(hook.modelState().effort))
 
   // 让这一轮流式里含一条 effort-rejected notice（模拟 host 的回退）
   hook.close()
@@ -3367,12 +3824,54 @@ assert('点回来看到"已停止"的状态与可重试入口', hook.state().pha
   const last = turns[turns.length - 1]
   assert('轮次上记下了提示文案', String(last.notice || '').indexOf('已按默认档位重试') >= 0, String(last.notice))
   assert('提示行渲染进了气泡（不是只记在状态里）', Array.from(walk(chatLog)).some((n) => String(n.className).indexOf('dsh-sel-notice') >= 0 && textOf(n).indexOf('已按默认档位重试') >= 0), textOf(chatLog).slice(-60))
-  assert('被拒后自动回退：档位选择清空（不再拿同一个组合撞墙）', hook.modelState().effort === null, String(hook.modelState().effort))
-  assert('回退同时清掉持久化', String(windowStub.localStorage.getItem('dsh-selection-explain:effort')) === '', String(windowStub.localStorage.getItem('dsh-selection-explain:effort')))
+  // 档位只有**一份**数据（配置里的 chatReasoningEffort）：被拒时不再偷偷清掉用户的选择
+  //（清掉会让人以为自己没选过），这一轮该发什么由 host 的换档重试兜；标记留给菜单划斜线。
+  assert('被拒后**保留**用户选的那一格（唯一一份数据，不偷偷清）', hook.modelState().effort === 'max', String(hook.modelState().effort))
+  assert('档位不再写浏览器本地覆盖（已并入配置这一个源）',
+    windowStub.localStorage.getItem('dsh-selection-explen:effort') === null &&
+      windowStub.localStorage.getItem('dsh-selection-explain:effort') === null,
+    String(windowStub.localStorage.getItem('dsh-selection-explain:effort')))
   // 菜单里该档位被标成"实测不支持"
   hook.openModel()
   const bad = Array.from(walk(hook.modelNodes().menu)).filter((n) => n.getAttribute && n.getAttribute('data-bad') === '1')
-  assert('菜单里把被拒的档位标出来（划斜线 + tooltip）', bad.length === 1 && textOf(bad[0]) === '最大', bad.map((b) => textOf(b)).join(','))
+  assert('菜单里把被拒的那一格标出来（划斜线 + tooltip）', bad.length === 1 && textOf(bad[0]) === '最高', bad.map((b) => textOf(b)).join(','))
+
+  // ② 上游**偶发**错误（host 已换档重试）：提示要出现，但绝不能当成"这一档不支持" ——
+  //    2026-10-09 实测：同一档位时好时坏（low/high 各 5/8 成功），所以它不能清档位、不能标 bad。
+  {
+    const highBtn = tiers().find((b) => textOf(b) === '高')
+    highBtn.dispatch('click', { preventDefault() {}, stopPropagation() {} })
+    assert('（前提）先把档位设成「高」', hook.modelState().effort === 'high', String(hook.modelState().effort))
+    hook.close()
+    await sleep(30)
+    globalThis.__askExtra = { notice: { code: 'upstream-retry', text: '上游这次返回了错误，已自动重试' }, noticeGapMs: 400 }
+    hook.ask('上游偶发错误的用例')
+    let sawNotice = false
+    for (let i = 0; i < 200 && hook.turns().some((t) => t.streaming === true); i += 1) {
+      if (String((hook.turns()[hook.turns().length - 1] || {}).notice || '').indexOf('已自动重试') >= 0) sawNotice = true
+      await sleep(20)
+    }
+    await sleep(60)
+    const afterUpstream = hook.turns()[hook.turns().length - 1] || {}
+    assert('上游偶发错误的提示出现过', sawNotice, String(afterUpstream.notice))
+    assert(
+      '正文到了之后这句**过程提示**撤掉（不是挂在回答上的结论）',
+      String(afterUpstream.notice || '') === '',
+      String(afterUpstream.notice),
+    )
+    assert(
+      '偶发错误**不动**用户的档位选择（这是与 effort-rejected 的关键区别）',
+      hook.modelState().effort === 'high',
+      String(hook.modelState().effort),
+    )
+    hook.openModel()
+    const badAfter = Array.from(walk(hook.modelNodes().menu)).filter((n) => n.getAttribute && n.getAttribute('data-bad') === '1')
+    assert(
+      '偶发错误不写进"实测该模型不支持"（菜单里仍然只有「最大」被标）',
+      badAfter.length === 1 && textOf(badAfter[0]) === '最高',
+      badAfter.map((b) => textOf(b)).join(','),
+    )
+  }
   globalThis.__askExtra = null
 }
 
@@ -3697,8 +4196,8 @@ let bridgeOwnedBlob = ''
   assert('只挂引用、没写问题时发送键可用', askSend.disabled === false, 'disabled=' + askSend.disabled)
   assert(
     '小窗里的引用**不带上下文**（小窗这几轮对话本来就会随历史进模型）',
-    quotes[0].context === '' && quotes[0].session === false,
-    JSON.stringify({ context: quotes[0].context, session: quotes[0].session }),
+    !!quotes[0] && quotes[0].context === '' && quotes[0].session === false,
+    JSON.stringify({ context: quotes[0] && quotes[0].context, session: quotes[0] && quotes[0].session }),
   )
   assert(
     '引用浮标画在面板**之上**（小窗里划词才看得见、点得着）',
@@ -3721,7 +4220,9 @@ let bridgeOwnedBlob = ''
       `${longQuote && longQuote.text.length} · ${hook.state().status}`,
     )
     const chipList = Array.from(walk(quotesBox)).filter((n) => n.className === 'dsh-sel-quotechip-x')
-    chipList[chipList.length - 1].dispatch('click', { stopPropagation() {} })
+    // 前面若已失败（引用没挂上），这里就没有 chip —— 别让它把整个脚本打断
+    const lastChip = chipList[chipList.length - 1]
+    if (lastChip) lastChip.dispatch('click', { stopPropagation() {} })
     await sleep(5)
     assert('删掉超长那条后回到 1 条', hook.quotes().length === 1, JSON.stringify(hook.quotes().map((q) => q.text.length)))
     // 把浮标状态也归零：不然下面那次"再点一次"的点击会把这段长文又加回来
@@ -4799,6 +5300,753 @@ function sliceFunction(text, name) {
 // ───────────────────────── 关闭 / 清理 ─────────────────────────
 hook.close()
 assert('Esc/关闭后隐藏', panel.style.display === 'none')
+// ───────────────────────── 语音卡：选中文字 + 输入法正在语音输入 ─────────────────────────
+// 这条链路的关键是"我们不读输入法的转写结果"：输入法上屏只认焦点元素，
+// 所以只要在它开麦时把焦点拿到自己的输入框上，说的话就会自己落进来。
+{
+  // 也认 setAttribute('class') —— SVG 元素的 className 是只读对象，插件只能用 setAttribute
+  const find = (cls) =>
+    Array.from(walk(mount)).find(
+      (n) => n.className === cls || (n.getAttribute && n.getAttribute('class') === cls),
+    )
+
+  hook.close()
+  await sleep(20)
+
+  // host 报：豆包输入法正在采集麦克风
+  micStub.value = {
+    ok: true,
+    available: true,
+    capturing: true,
+    processes: [{ pid: 513, bundleId: 'com.bytedance.inputmethod.doubaoime', name: 'DoubaoIme' }],
+    reason: '',
+  }
+  // 同一行里如果有行内元素（<code>/粗体），getClientRects() 会给多个矩形且底边不等高 ——
+  // 必须归并成一条，否则会"划两层"、渐隐还会出现在行中间（用户实测的两个问题，同一根因）。
+  // 注意：插件在 checkSelection 时就把 range **存下来了**，所以补丁必须打在捕获之前；
+  // 而且桩的 getRangeAt() 每次返回新对象（createRange()），所以补丁要打在 createRange 上。
+  const realCreateRange = documentStub.createRange.bind(documentStub)
+  // 起点所在的"块"：底边 110 —— 落在下面那段大选区（100..200）**中间**。
+  // 老代码只按这个块算，卡片就会压在剩下的选中文字上（用户报的"大段文字时卡片遮住文字"）。
+  const blockEl = {
+    nodeType: 1,
+    parentElement: null,
+    getBoundingClientRect: () => ({ left: 40, top: 100, right: 500, bottom: 110, width: 460, height: 10 }),
+  }
+  const realGCS = windowStub.getComputedStyle
+  windowStub.getComputedStyle = (el) =>
+    el === blockEl
+      ? { display: 'block', backgroundColor: 'rgba(0,0,0,0)' }
+      : realGCS
+        ? realGCS(el)
+        : { display: '', backgroundColor: 'rgba(0,0,0,0)' }
+  documentStub.createRange = () => {
+    const r = realCreateRange()
+    r.startContainer = blockEl
+    // 真实浏览器实测的形状（选区跨整段时）：一个**块级盒子**（h=53，盖住两行）
+    // + 每行两个片段（行内 code 会给出外盒/内盒）。
+    // 块盒不丢掉的话会把两行吞成一组 → 只有一条下划线（用户报的"有些行没有划线"）。
+    r.getClientRects = () => [
+      { left: 20, top: 100, right: 580, bottom: 153, width: 560, height: 53 },
+      { left: 20, top: 102, right: 187, bottom: 123, width: 167, height: 21 },
+      { left: 187, top: 105, right: 346, bottom: 122, width: 159, height: 17 },
+      { left: 20, top: 128, right: 83, bottom: 149, width: 63, height: 21 },
+      { left: 83, top: 128, right: 533, bottom: 149, width: 450, height: 21 },
+    ]
+    // 选区本体很大（跨到 200），起点块只到 110
+    // 选区右缘故意放到很靠右（innerWidth 1440）：老规则"正文列左边→选区右缘"会算出 560，
+    // 现在统一 360 —— 这条断言就是为了钉住"不再随选区位置变宽"。
+    r.getBoundingClientRect = () => ({ left: 40, top: 100, right: 1300, bottom: 200, width: 1260, height: 100 })
+    return r
+  }
+
+  // 造一次真选区（走 mouseup 那条路）：浮标一出现就开始看麦克风
+  windowStub.getSelection = () => selection
+  documentStub.dispatch('mouseup', { target: body })
+  await sleep(250)
+
+  const opened = hook.voiceCard()
+  assert('检测到输入法开麦 → 语音卡自己弹出来', opened.open === true, JSON.stringify(opened))
+  assert('卡片处于"在听"状态（竖条呼吸）', opened.voiced === true, JSON.stringify(opened))
+  assert(
+    '大段选区：卡片按**整个选区**的底边落位（不压在选中的文字上）',
+    !!opened.geometry && opened.geometry.top === '222px',
+    'top=' + String(opened.geometry && opened.geometry.top) + '（按起点块算会是 132px，正好压在选区里）',
+  )
+  assert(
+    '卡片宽度固定 360（不随选区位置变宽；老规则在这里会给出 560）',
+    !!opened.geometry && opened.geometry.width === '360px',
+    JSON.stringify(opened.geometry),
+  )
+
+  const box = find('dsh-sel-vcard-box')
+  const sendBtn = find('dsh-sel-vcard-send')
+  assert('卡片里有输入框（IME 上屏要落在它身上）', !!box && !!sendBtn, String(!!box) + '/' + String(!!sendBtn))
+  // 「在听」指示器 = 卡片左缘那根 3px 竖条（B1 + 动1，用户选定）
+  const vbar = find('dsh-sel-vbar')
+  const cardNode = find('dsh-sel-vcard')
+  assert(
+    '卡片里有那根「在听」竖条，且是卡片的第一个子元素（正文排在它右边）',
+    !!vbar && !!cardNode && !!cardNode.children && cardNode.children[0] === vbar,
+    vbar ? '竖条存在；是第一个子元素=' + String(!!cardNode && cardNode.children[0] === vbar) : '没找到竖条',
+  )
+  // 选中提示（下划线 + 牵引线）：**只在卡片打开后才画** —— 选中/浮标阶段不画（那时原生底纹还在）
+  const uline = find('dsh-sel-uline')
+  const thread = find('dsh-sel-thread')
+  assert(
+    '卡片打开后画了下划线（按选区逐行矩形）',
+    !!uline && /px$/.test(String(uline.style.width)),
+    uline ? String(uline.style.width) : 'none',
+  )
+  assert(
+    '下划线是两端渐隐的（U3）',
+    !!uline && /linear-gradient/.test(String(uline.style.background)),
+    uline ? String(uline.style.background).slice(0, 46) : 'none',
+  )
+  // （旧的"圆点 display:block"断言删了：圆点现在是 SVG 子元素，没有自己的 display，
+  //   由下面的 cx/cy 断言覆盖 —— 那才是它真正要表达的东西。）
+  const threadPath = find('dsh-sel-threadpath')
+  const threadDot = find('dsh-sel-threaddot')
+  const d = threadPath ? String(threadPath.getAttribute('d')) : ''
+  assert(
+    '牵引线是 **SVG 贝塞尔**（path 里有 C 曲线段，不再是直线）',
+    !!threadPath && d.indexOf('C') > 0,
+    d ? d.slice(0, 64) : 'none',
+  )
+  assert(
+    '牵引线终点 = **算出来的最终位置** + 4px（222+4=226：一开始就瞄准最终位置，不跟随形变、也不指到解读按钮上）',
+    / 964 226$/.test(d),
+    'd 的结尾=' + JSON.stringify(d.slice(-14)),
+  )
+  assert(
+    '牵引线起点有锚点圆（cx/cy 落在选区末行中点）',
+    !!threadDot && String(threadDot.getAttribute('cx')) === '276.5' && String(threadDot.getAttribute('cy')) === '151',
+    threadDot ? 'cx=' + String(threadDot.getAttribute('cx')) + ' cy=' + String(threadDot.getAttribute('cy')) : 'none',
+  )
+
+  const merged = Array.from(walk(mount)).filter((n) => n.className === 'dsh-sel-uline')
+  assert(
+    '块级盒子被丢掉，两行各有一条下划线（不再整段只剩一条）',
+    merged.length === 2,
+    '下划线条数=' + merged.length + '（应为 2；不丢块盒会是 1）',
+  )
+  assert(
+    '第一行：归并成一条（20..346），取最低底边 123+3',
+    !!merged[0] && merged[0].style.width === '326px' && merged[0].style.top === '126px',
+    merged[0] ? String(merged[0].style.width) + ' / top=' + String(merged[0].style.top) : 'none',
+  )
+  assert(
+    '第二行也有自己的下划线（20..533）',
+    !!merged[1] && merged[1].style.width === '513px' && merged[1].style.top === '152px',
+    merged[1] ? String(merged[1].style.width) + ' / top=' + String(merged[1].style.top) : 'none',
+  )
+
+  documentStub.createRange = realCreateRange
+  windowStub.getComputedStyle = realGCS
+
+  // 焦点：桩 DOM 的 focus() 是空实现，这里换成可观测的再重开一次
+  let focused = false
+  if (box) box.focus = () => { focused = true }
+  hook.voiceCardClose()
+  hook.voiceCardOpen()
+  assert('打开卡片时把焦点抢到输入框（上屏只认焦点元素）', focused === true, String(focused))
+
+  // 形变期间正文宽度被钉在终值（否则每帧重新折行 → 卡顿）；结束后必须解开，
+  // 否则之后打字时正文宽度不会再跟着卡片走
+  await sleep(520)
+  assert(
+    '形变结束后解开正文宽度（回到 flex 布局）',
+    !box.style.width && !box.style.flex,
+    'width=' + String(box.style.width) + ' flex=' + String(box.style.flex),
+  )
+
+  // 开麦结束、一个字都没说 —— 先验**关掉**这两个收尾开关时的老行为：
+  // 卡片**不退出**（用户可以接着手动打字），只是不再显示"在听"。
+  // ⚠️ 这两个开关的出厂默认是**开**（2026-10-09 用户指定），所以这里必须显式设成 false；
+  //    打开后的两条收尾在文件末尾单独验。
+  settingsStub.value = { voiceCancelOnSilence: false, voiceAutoSend: false }
+  hook.reloadSettings()
+  await sleep(120)
+  micStub.value = { ok: true, available: true, capturing: false, processes: [], reason: '' }
+  await sleep(520)
+  const silent = hook.voiceCard()
+  assert('（关掉时）开麦结束但一个字都没说：卡片留着不退出', silent.open === true, JSON.stringify(silent))
+  assert('此时不再显示「在听」（麦克风已经松开了）', silent.voiced === false, JSON.stringify(silent))
+  // 恢复"正在录"：后面几步按原样继续
+  micStub.value = {
+    ok: true,
+    available: true,
+    capturing: true,
+    processes: [{ pid: 513, bundleId: 'com.bytedance.inputmethod.doubaoime', name: 'DoubaoIme' }],
+    reason: '',
+  }
+  await sleep(520)
+
+  // 说话：文字落进输入框（输入法上屏走的就是这条路）
+  if (box) {
+    box.value = '这是在推迟还是提前？'
+    box.dispatch('input', { target: box, preventDefault() {}, stopPropagation() {} })
+  }
+  const filled = hook.voiceCard()
+  assert('有字之后才摆出发送键', filled.hasText === true, JSON.stringify(filled))
+
+  // 发送：跳过翻译与详解，直接进追问
+  const beforeSend = hook.state()
+  // 焦点探针：小窗自己的规则 —— **一轮输出结束（成功或失败）后**把光标交回输入框。
+  // 注意这不是"从临时卡进小窗"的特例：划词解读、打开历史都走同一条规则。
+  let askFocused = 0
+  const realAskFocus = askBox.focus
+  askBox.focus = () => {
+    askFocused += 1
+  }
+  // 交接动画（方案二「缩放长出」）的观测点：必须在点发送**之前**挂上 ——
+  // 插件会在 showPanel 里连续写两次 style.transform（先摆起点、再设 none），
+  // 桩 DOM 没有布局，量不出真实矩形，但"起点是不是把面板压到卡片那一格"可以从写入值上直接验。
+  const panelEl = find('dsh-sel-panel')
+  const growWrites = []
+  let panelTransformNow = panelEl.style.transform
+  Object.defineProperty(panelEl.style, 'transform', {
+    configurable: true,
+    get: () => panelTransformNow,
+    set: (value) => { growWrites.push(value); panelTransformNow = value },
+  })
+  // 发送那一刻焦点确实在卡片输入框里（真实状态）——正是它让"开窗聚焦"那次让了路
+  documentStub.activeElement = box
+  if (sendBtn) sendBtn.dispatch('click', { target: sendBtn, preventDefault() {}, stopPropagation() {} })
+  await sleep(80)
+  const afterSend = hook.state()
+  assert('发送后卡片收起', hook.voiceCard().open === false, JSON.stringify(hook.voiceCard()))
+  // 卡片矩形是桩给的 940,222,360×42；面板是通用矩形 40,100,460×300
+  //   → 起点 translate(900,122) scale(360/460, 42/300)
+  const growStart = 'translate(900.0px,122.0px) scale(0.7826,0.1400)'
+  assert(
+    '交接起点：把面板压到卡片那一格（translate + scale，原点左上），终点回到 none',
+    growWrites.indexOf(growStart) >= 0 &&
+      growWrites.indexOf(growStart) === growWrites.length - 2 &&
+      growWrites[growWrites.length - 1] === 'none' &&
+      panelEl.style.transformOrigin === '0 0',
+    JSON.stringify({ writes: growWrites, origin: panelEl.style.transformOrigin }),
+  )
+  assert(
+    '交接只动 transform，260ms 同一族曲线（不动 width/left/top —— 那是布局属性，会掉帧）',
+    String(panelEl.style.transition) === 'transform 260ms cubic-bezier(.2,.8,.2,1)',
+    String(panelEl.style.transition),
+  )
+
+  // 卡片隐藏后浏览器会把焦点收回 body —— 桩里不会（它不模拟"隐藏即失焦"），
+  // 所以这里持续保持这个**忠实状态**：否则焦点会一直挂在已隐藏的卡片输入框上，
+  // 后面的礼貌守卫就会误判成"人家正在别处打字"（实测就是这么卡的）。
+  for (let i = 0; i < 60 && hook.state().phase !== 'done'; i += 1) {
+    documentStub.activeElement = body
+    await sleep(60)
+  }
+  assert('（前提）这一轮输出已经结束', hook.state().phase === 'done', String(hook.state().phase))
+  // 别再往 body 上还原了：聚焦是在这一轮结束那一刻发生的，紧接着断言才对得上
+  //（之前循环退出后还还原一次，把自己刚要验的焦点冲掉了 —— 实测就是这么红的）
+  await sleep(260)
+  assert(
+    '小窗规则：一轮输出结束后，光标自动回到小窗输入框（可以直接继续追问）',
+    // 只断言"规则触发了"：桩里的 activeElement 会被好几个角色来回改（临时卡片的输入框也在抢），
+    // 断言它等于 askBox 会很脆、也未必反映真实浏览器。真正的插入符在无头 Chrome 里画不出来
+    // （无头不渲染 caret），所以这一层只能验到"规则执行了"，插入符靠真机确认。
+    askFocused > 0,
+    'focus 次数=' + String(askFocused) + ' 卡在=' + String(hook.focusBail()),
+  )
+  askBox.focus = realAskFocus
+  // 还原焦点：不还原的话它会一直停在别处，后面用例开卡片会被"别处正在打字"那条守卫挡掉
+  documentStub.activeElement = body
+  // 交接动画必须**自己收尾**：把内联的 transform / transition / transformOrigin 清干净。
+  // 留着的话下一次开窗量几何会量到半截 transform（拖拽改大小、设置抽屉都会跟着歪）。
+  await sleep(460) // 260ms 动画 + 140ms 兜底（桩里没有 transitionend，走的就是兜底那条）
+  assert(
+    '交接收尾：内联 transform / transition / transformOrigin 全部清掉',
+    !panelEl.style.transform && !panelEl.style.transition && !panelEl.style.transformOrigin,
+    JSON.stringify({ tf: panelEl.style.transform, tr: panelEl.style.transition, og: panelEl.style.transformOrigin }),
+  )
+
+  // 追问失败也要把光标交回输入框 —— 这条路原来漏了规则（用户实测："报错之后输入框没有光标"）
+  {
+    let focusAfterAskError = 0
+    const realAskFocus2 = askBox.focus
+    askBox.focus = () => {
+      focusAfterAskError += 1
+    }
+    globalThis.__askFailOnce = true
+    const sentBeforeAsk = sent.length
+    hook.ask('这条追问会失败')
+    await sleep(200)
+    // 追问的问答在 chat log 里（不在翻译正文 panelBody 里），所以整个面板一起找
+    for (let i = 0; i < 50 && !!globalThis.__askFailOnce; i += 1) await sleep(60)
+    // 前置条件用**可证明的事实**：请求发出去了、而且被桩的失败注入接走了。
+    //（不查"面板里有没有『追问失败』这行字"：桩里那行渲染文本用 textOf 够不到，
+    //  查它会得到一个恒假的断言 —— 那是测试环境的事，不是产品行为。）
+    assert(
+      '（前提）追问请求发了，且这次被桩按失败处理',
+      sent.length - sentBeforeAsk > 0 && !globalThis.__askFailOnce,
+      '请求数=' + String(sent.length - sentBeforeAsk) + ' 失败注入已消费=' + String(!globalThis.__askFailOnce),
+    )
+    assert(
+      '追问失败后，光标也回到小窗输入框（这条路原来漏了"一轮结束就交回光标"的规则）',
+      focusAfterAskError > 0,
+      'focus 次数=' + String(focusAfterAskError),
+    )
+    askBox.focus = realAskFocus2
+    documentStub.activeElement = body
+  }
+  assert('跳过解读：翻译一节是空的（没请求 /analyze）', !afterSend.translation, JSON.stringify(beforeSend) + ' → ' + JSON.stringify(afterSend))
+  assert('直接进了追问：面板开着', panel.style.display !== 'none', String(panel.style.display))
+
+  // Esc 收卡片（还没发出去时）
+  micStub.value = { ok: true, available: true, capturing: true, processes: [{ pid: 513, bundleId: 'com.bytedance.inputmethod.doubaoime', name: 'DoubaoIme' }], reason: '' }
+  hook.close()
+  await sleep(20)
+  documentStub.dispatch('mouseup', { target: body })
+  await sleep(250)
+  const reopened = hook.voiceCard()
+  if (reopened.open) {
+    documentStub.dispatch('keydown', { key: 'Escape', target: body, preventDefault() {}, stopPropagation() {} })
+    await sleep(20)
+    assert('Esc 收起语音卡', hook.voiceCard().open === false, JSON.stringify(hook.voiceCard()))
+    // 取消后**不还回**「✦ 解读」浮标（用户要求：取消就是取消，别再冒出来问"要不要解读"）
+    assert(
+      '取消后不还回「✦ 解读」浮标',
+      button.style.display === 'none',
+      '浮标 display=' + String(button.style.display),
+    )
+    // 取消时播"老式电视机关机"（A 方案）：卡片先留在画面上塌缩，动画结束才真正隐藏
+    const closingState = hook.voiceCard()
+    const cardEl = find('dsh-sel-vcard')
+    const crtLine = find('dsh-sel-crtline')
+    assert('取消时先播关机动画（卡片还在画面上）', closingState.closing === true, JSON.stringify(closingState))
+    assert(
+      '关机动画挂在卡片上（data-off=a）',
+      !!cardEl && cardEl.getAttribute('data-off') === 'a',
+      cardEl ? String(cardEl.getAttribute('data-off')) : 'no card',
+    )
+    assert(
+      '亮线拆成 5 段 + 2 个火花，宽度跟着卡片、颜色按明暗给',
+      !!crtLine &&
+        crtLine.style.width === '360px' &&
+        !!crtLine.style.color &&
+        !!crtLine.children &&
+        crtLine.children.length === 7,
+      crtLine
+        ? crtLine.style.width + ' / ' + String(crtLine.style.color) + ' / 子元素 ' + String(crtLine.children.length)
+        : 'no line',
+    )
+    // 桩环境没有 animationend，走 640ms 兜底
+    await sleep(780)
+    const closed = hook.voiceCard()
+    assert(
+      '关机动画结束后卡片才真正隐藏',
+      closed.closing === false && !!cardEl && cardEl.style.display === 'none' && !cardEl.getAttribute('data-off'),
+      JSON.stringify(closed) + ' / display=' + (cardEl ? String(cardEl.style.display) : '?'),
+    )
+    assert('亮线也一并收掉', !!crtLine && !crtLine.getAttribute('data-off'), crtLine ? String(crtLine.getAttribute('data-off')) : 'no line')
+    assert(
+      '卡片收起后选中提示一并清掉',
+      !find('dsh-sel-uline') && !!thread && thread.style.display === 'none',
+      '下划线=' + String(!!find('dsh-sel-uline')) + ' 牵引线 display=' + (thread ? String(thread.style.display) : '?'),
+    )
+  } else {
+    assert('Esc 收起语音卡', false, '卡片没能再次打开：' + JSON.stringify(reopened))
+  }
+
+  // ── 两个语音收尾开关（设置页「界面 · 语音输入」，**默认都开**）──
+  // 关掉时的行为（"卡片留着"）上面已经验过；这里验打开后的两条收尾。
+  // 关键：松手**不是**决定时刻 —— 输入法在松手后还会做一次智能整理（改写输入框内容），
+  // 所以两个动作都要等文字定稿（连续 VOICE_SETTLE_MS=500ms 没变化）才发生。
+  {
+    const IME = [{ pid: 513, bundleId: 'com.bytedance.inputmethod.doubaoime', name: 'DoubaoIme' }]
+    const recording = { ok: true, available: true, capturing: true, processes: IME, reason: '' }
+    const stopped = { ok: true, available: true, capturing: false, processes: [], reason: '' }
+
+    // ① 「空录音时收起」：松手后不立刻收，等定稿才收（而且走取消路径）
+    settingsStub.value = { voiceCancelOnSilence: true, voiceAutoSend: false }
+    hook.reloadSettings()
+    await sleep(320)
+    hook.close()
+    micStub.value = recording
+    await sleep(420)
+    hook.voiceCardOpen()
+    if (box) {
+      box.value = ''
+      box.dispatch('input', { target: box, preventDefault() {}, stopPropagation() {} })
+    }
+    await sleep(80)
+    micStub.value = stopped
+    await sleep(300)
+    assert(
+      '松手后**不会立刻**取消（要等文字定稿：输入法松手后还会智能整理）',
+      hook.voiceCard().open === true,
+      JSON.stringify(hook.voiceCard()),
+    )
+    await sleep(900)
+    const cardSilent = find('dsh-sel-vcard')
+    assert('定稿后才取消（空录音）', hook.voiceCard().open === false, JSON.stringify(hook.voiceCard()))
+    assert(
+      '空录音收起走的是**取消**路径（关机动画 data-off=a，不是无声消失）',
+      !!cardSilent && cardSilent.getAttribute('data-off') === 'a',
+      cardSilent ? String(cardSilent.getAttribute('data-off')) : 'no card',
+    )
+
+    // ② 「说完直接发送」：松手后等定稿才发；期间模拟豆包的智能整理改写输入框
+    settingsStub.value = { voiceCancelOnSilence: false, voiceAutoSend: true }
+    hook.reloadSettings()
+    await sleep(320)
+    await sleep(800) // 等上一条关机动画彻底收尾
+    hook.close()
+    await sleep(20)
+    micStub.value = recording
+    await sleep(420)
+    hook.voiceCardOpen()
+    if (box) {
+      box.value = '这是 在推迟 还是提前' // 整理之前：有空格、没标点
+      box.dispatch('input', { target: box, preventDefault() {}, stopPropagation() {} })
+    }
+    await sleep(80)
+    const sentBefore = sent.length
+    micStub.value = stopped
+    await sleep(300)
+    assert(
+      '松手后**不会立刻**发送（要等文字定稿）',
+      hook.voiceCard().open === true && sent.length === sentBefore,
+      JSON.stringify(hook.voiceCard()) + ' / sent=' + String(sent.length - sentBefore),
+    )
+    // 模拟智能整理：松手之后才改写输入框，而且是**直接改 value、不派发 input**（真实情况就是这样）
+    const cleaned = '这是在推迟还是提前，release notes 要不要一起改。'
+    if (box) box.value = cleaned
+    await sleep(300)
+    assert(
+      '整理过程中仍然不发（每改一次就重新计时）',
+      hook.voiceCard().open === true && sent.length === sentBefore,
+      JSON.stringify(hook.voiceCard()) + ' / sent=' + String(sent.length - sentBefore),
+    )
+    // 主信号：输入法的智能整理**走合成 API 提交**（实测 8 次录音里 6 次都有）
+    if (box) box.dispatch('compositionend', { data: cleaned })
+    await sleep(260)
+    assert(
+      '收到 compositionend 后**短窗口内**就决定（260ms 就发了 —— 兜底的 700ms 静默还没到）',
+      hook.voiceCard().open === false,
+      JSON.stringify(hook.voiceCard()),
+    )
+    assert(
+      '发出去的是**整理之后**的文字（不是松手那一刻的草稿）',
+      // 问题在 question 字段（text 是选中的原文）
+      sent.slice(sentBefore).some((b) => b && (b.question === cleaned || b.text === cleaned)),
+      JSON.stringify(sent.slice(sentBefore).map((b) => b && b.question)),
+    )
+
+    // ③ 出厂默认就是开：桩里**不写这两个键**时，空录音同样等定稿后收起。
+    // 这一条挡住"设置还没加载完 / 读失败就退回关"的回归 —— 那会和 host 侧 Config 的缺省值不一致。
+    settingsStub.value = {}
+    hook.reloadSettings()
+    await sleep(320)
+    await sleep(800) // 等上一条发送彻底收尾
+    hook.close()
+    await sleep(20)
+    micStub.value = recording
+    await sleep(420)
+    hook.voiceCardOpen()
+    if (box) {
+      box.value = ''
+      box.dispatch('input', { target: box, preventDefault() {}, stopPropagation() {} })
+    }
+    await sleep(80)
+    micStub.value = stopped
+    await sleep(900)
+    assert(
+      '默认（桩里不写这两个键）也是开：空录音照样等定稿后收起',
+      hook.voiceCard().open === false,
+      JSON.stringify(hook.voiceCard()),
+    )
+
+    // 收尾：设置清回默认，别影响后面的用例
+    settingsStub.value = {}
+    hook.reloadSettings()
+    await sleep(300)
+  }
+
+  // ── ⑨ 小窗开着时开麦 = 点一下「❝ 引用」（2026-10-09 定的行为）──
+  //   ① 只在引用浮标亮着时才问麦克风；② 开麦 → 引用挂进来 + 光标进小窗输入框；
+  //   ③ **不弹语音卡**（卡片是"面板没开、字没处落"的产物）；④ 同一次录音只处理一次；
+  //   ⑤ 别处正在打字 → 不加引用、也不抢焦点。
+  {
+    const recording2 = {
+      ok: true,
+      available: true,
+      capturing: true,
+      processes: [{ pid: 513, bundleId: 'com.bytedance.inputmethod.doubaoime', name: 'DoubaoIme' }],
+      reason: '',
+    }
+    const stopped2 = { ok: true, available: true, capturing: false, processes: [], reason: '' }
+    // 选区桩本段自带：上面两族的 selectText / selectOn 都是块内作用域，这里够不着。
+    // textEl 是模块级的（划词那一段就在用它），所以直接搭在它上面。
+    const quoteRect9 = { left: 40, top: 620, right: 320, bottom: 640, width: 280, height: 20 }
+    const selectDoc = (text) => {
+      const range = {
+        startContainer: textEl,
+        endContainer: textEl,
+        cloneRange: () => range,
+        getClientRects: () => [quoteRect9],
+        getBoundingClientRect: () => quoteRect9,
+      }
+      windowStub.getSelection = () => ({
+        isCollapsed: false,
+        rangeCount: 1,
+        toString: () => text,
+        getRangeAt: () => range,
+      })
+    }
+    const priorSelection = windowStub.getSelection
+    micStub.value = stopped2
+    hook.close()
+    await sleep(40)
+    hook.open('voice-quote-probe', '开麦引用的上下文片段', '开麦引用')
+    for (let i = 0; i < 120 && hook.state().phase !== 'done'; i += 1) await sleep(20)
+    assert('（前提）开麦引用用例的首轮出完', hook.state().phase === 'done', hook.state().phase)
+    assert('（前提）引用区是空的', hook.quotes().length === 0, JSON.stringify(hook.quotes().map((q) => q.text)))
+
+    const focusHits = { count: 0 }
+    const realAskFocus3 = askBox.focus
+    askBox.focus = () => {
+      focusHits.count += 1
+    }
+
+    // ① 没有引用浮标 → 不问麦克风（探针只在被问时活着）
+    const hitsIdle = micStub.hits
+    await sleep(520)
+    assert('没有引用浮标时**不**轮询麦克风（省掉常驻探针）', micStub.hits === hitsIdle, `${hitsIdle} → ${micStub.hits}`)
+
+    // ② 浮标亮着 → 开始问
+    selectDoc('这半句是要被引用的')
+    documentStub.dispatch('mouseup', { target: textEl })
+    await sleep(30)
+    assert('（前提）引用浮标亮着', hook.quoteState().visible === true, JSON.stringify(hook.quoteState()))
+    const hitsFloat = micStub.hits
+    await sleep(520)
+    assert('引用浮标亮着时才问麦克风', micStub.hits > hitsFloat, `${hitsFloat} → ${micStub.hits}`)
+
+    // ③ 开麦 → 引用挂进来 + 光标进小窗输入框 + 不弹语音卡
+    micStub.value = recording2
+    await sleep(320)
+    const autoQuotes = hook.quotes()
+    assert(
+      '开麦 → 选中的那段自动挂进引用（= 点一下引用浮标）',
+      autoQuotes.length === 1 && autoQuotes[0].text === '这半句是要被引用的' && autoQuotes[0].label === '主界面选中',
+      JSON.stringify(autoQuotes),
+    )
+    assert('开麦 → 引用浮标自己收了（"已经进去了"的信号）', hook.quoteState().visible === false, JSON.stringify(hook.quoteState()))
+    assert('开麦 → 光标进了小窗输入框（输入法上屏的字落在这儿）', focusHits.count > 0, 'focus 次数=' + focusHits.count)
+    assert('开麦 → **不**弹语音卡（面板开着时字直接落进小窗）', hook.voiceCard().open === false, JSON.stringify(hook.voiceCard()))
+    assert('开麦 → 状态里交代了这次引用', /已加入引用/.test(String(hook.state().status)), String(hook.state().status))
+
+    // ④ 同一次录音里只处理一次（200ms 一拍，不抑制会反复加 / 反复抢焦点）
+    const focusAfterAuto = focusHits.count
+    await sleep(340)
+    assert(
+      '同一次录音只处理一次（不反复加引用、不反复抢焦点）',
+      hook.quotes().length === 1 && focusHits.count === focusAfterAuto,
+      `引用=${hook.quotes().length} focus=${focusAfterAuto}→${focusHits.count}`,
+    )
+
+    // ⑤ 别处正在打字 → 不抢（守卫与语音卡那条完全一致）
+    micStub.value = stopped2
+    await sleep(320) // 这一轮结束：抑制复位
+    const otherBox = documentStub.createElement('textarea')
+    documentStub.activeElement = otherBox
+    selectDoc('别处打字时不该被抢')
+    documentStub.dispatch('mouseup', { target: textEl })
+    await sleep(30)
+    assert('（前提）浮标又亮了', hook.quoteState().visible === true, JSON.stringify(hook.quoteState()))
+    const focusBeforeGuard = focusHits.count
+    micStub.value = recording2
+    await sleep(320)
+    assert('别处正在打字：不加引用', hook.quotes().length === 1, JSON.stringify(hook.quotes().map((q) => q.text)))
+    assert(
+      '别处正在打字：不抢焦点（人家的听写不能被拽进小窗）',
+      focusHits.count === focusBeforeGuard,
+      `focus=${focusBeforeGuard}→${focusHits.count}`,
+    )
+
+    // ⑥ 自动引用**做过一次之后**，机制还得活着（不能因为抑制标记没复位就"下次不响应了"）
+    //    这一步专门挡那条回归：交接后浮标收起 → 轮询停 → 若复位只挂在"轮到没在录"那一拍上，
+    //    标记会一直 true，下一次开麦什么都不发生（实测就是这么静默失效的）。
+    micStub.value = stopped2
+    documentStub.activeElement = body
+    selectDoc('第二次开麦也要能自动引用')
+    documentStub.dispatch('mouseup', { target: textEl })
+    await sleep(30)
+    assert('（前提）浮标第三次亮起', hook.quoteState().visible === true, JSON.stringify(hook.quoteState()))
+    const focusBeforeSecond = focusHits.count
+    micStub.value = recording2
+    await sleep(340)
+    const second = hook.quotes()
+    assert(
+      '上一次自动引用之后，下一次开麦照样生效（抑制标记跟着轮询复位）',
+      second.length === 2 && second[1].text === '第二次开麦也要能自动引用' && focusHits.count > focusBeforeSecond,
+      JSON.stringify({ quotes: second.map((q) => q.text), focus: `${focusBeforeSecond}→${focusHits.count}` }),
+    )
+
+    // ⑦ **一口气说不停**时换一段引用也要能生效：麦克风一直没松（探针一直报"在录"），
+    //    这时若"这次录音处理过没有"的标记只在"轮到没在录"那一拍才复位，就永远没机会复位 ——
+    //    下一次划词纵有浮标也毫无反应。这条用例专门盯那个死锁（撤掉 stopMicWatch 里的复位就会红）。
+    // ⚠️ 这里**不能**断言"浮标亮着"：麦克风本来就开着，浮标一亮就会被这一拍立刻收走
+    //    （动作比断言快 —— 实测就是"前提"红、主断言绿）。直接看结果。
+    const hitsBeforeThird = micStub.hits
+    selectDoc('一直说不停时换的这段引用')
+    documentStub.dispatch('mouseup', { target: textEl })
+    await sleep(360)
+    assert('（前提）换选区后轮询确实又跑起来了', micStub.hits > hitsBeforeThird, `${hitsBeforeThird} → ${micStub.hits}`)
+    const third = hook.quotes()
+    assert(
+      '麦克风一直没松、这时换一段引用：照样自动挂进来（不靠"没在录"那一拍复位）',
+      third.length === 3 && third[2].text === '一直说不停时换的这段引用',
+      JSON.stringify({ quotes: third.map((q) => q.text), mic: micStub.value.capturing }),
+    )
+
+    // 收尾：焦点 / 麦克风 / 选区 / 面板都还原，别影响后面的用例
+    askBox.focus = realAskFocus3
+    micStub.value = stopped2
+    documentStub.activeElement = body
+    windowStub.getSelection = priorSelection
+    hook.close()
+    await sleep(40)
+  }
+
+  // ── ⑩ 侧边栏网页里的选区也能弹卡（不透明源 iframe：父页面**没有**那段 Range）──
+  //   撤掉修复就会红的地方：
+  //     ① `openVCard` 原来第一句就是 `!state.selection.range → return`，帧内选区永远弹不出卡；
+  //     ② 几何原来只认 Range，桥给的锚点矩形用不上；
+  //     ③ 卡片一抢焦点，帧内选区就塌（输入法上屏要的正是焦点）→ 桥报 clear；
+  //        若照旧清掉 state.selection，"发送"和"说完了没有"两条都会断（轮询也会停）；
+  //     ④ 发送时不能读顶层 DOM（读不到那个帧），要用桥采好的上下文；
+  //     ⑤ 帧内按下（父页面收不到那个 mousedown）也要收卡。
+  {
+    const priorQuerySelectorAll = documentStub.querySelectorAll
+    const frame = new FakeEl('iframe')
+    frame.setAttribute('data-html-preview', 'true')
+    frame.setAttribute('sandbox', 'allow-scripts')
+    frame.setAttribute('srcdoc', '<!doctype html><html><body><p>网页里的正文</p></body></html>')
+    frame.isConnected = true
+    const frameWindow = { name: 'voice-card-sidebar-frame' }
+    frame.contentWindow = frameWindow
+    documentStub.querySelectorAll = (selector) => (selector === 'iframe' ? [frame] : [])
+    hook.bridgeScan()
+    assert('（前提）这一帧被桥上（不然下面那条消息不会被认）', frame.getAttribute('data-dsh-sel-bridged') === '1', String(frame.getAttribute('data-dsh-sel-bridged')))
+
+    const IME3 = [{ pid: 513, bundleId: 'com.bytedance.inputmethod.doubaoime', name: 'DoubaoIme' }]
+    const recording3 = { ok: true, available: true, capturing: true, processes: IME3, reason: '' }
+    const stopped3 = { ok: true, available: true, capturing: false, processes: [], reason: '' }
+    hook.close()
+    await sleep(20)
+    documentStub.activeElement = body
+    micStub.value = recording3
+    windowStub.dispatch('message', {
+      source: frameWindow,
+      data: {
+        __dshSel: 1,
+        kind: 'selection',
+        sel: {
+          text: '网页里选中的这段',
+          context: '前文【网页里选中的这段】后文',
+          keyContext: '前文',
+          label: '',
+          // 帧内坐标（帧自己的 getBoundingClientRect 是桩的 40/100）→ 视口 50/120..160/138
+          rect: { x: 10, y: 20, right: 120, bottom: 38, w: 110, h: 18 },
+        },
+      },
+    })
+    assert('（前提）浮标出现在网页选区处', button.style.display === 'inline-flex', String(button.style.display))
+    await sleep(300)
+    const frameCard = hook.voiceCard()
+    assert('侧边栏网页里的选区也能弹卡（不再被 range 守卫挡掉）', frameCard.open === true, JSON.stringify(frameCard))
+    assert(
+      '卡片按桥给的锚点矩形定位（帧偏移 40/100 + 帧内坐标 → 左 8 / 上 160）',
+      !!frameCard.geometry && frameCard.geometry.left === '8px' && frameCard.geometry.top === '160px',
+      JSON.stringify(frameCard.geometry),
+    )
+    // 帧内那条：逐行矩形拿不到（父页面碰不到那个 Range），所以**只画牵引线、不画下划线** ——
+    // 画下划线会与帧内可能还在的原生底纹"划两层"。
+    const frameThread = find('dsh-sel-thread')
+    const framePath = find('dsh-sel-threadpath')
+    assert('帧内选区不画下划线（那需要逐行矩形，而且有"划两层"的风险）', !find('dsh-sel-uline'), String(!!find('dsh-sel-uline')))
+    assert(
+      '但牵引线留着：从锚点矩形竖直指向卡片（M105 140 = 选区末行中点）',
+      !!frameThread && frameThread.style.display === 'block' && !!framePath && String(framePath.getAttribute('d')).indexOf('M105 140') === 0,
+      framePath ? String(framePath.getAttribute('d')).slice(0, 40) : 'no path',
+    )
+
+    // 抢焦点 → 帧内选区塌掉 → 桥报 clear：**卡片开着时不能清选区**
+    windowStub.dispatch('message', { source: frameWindow, data: { __dshSel: 1, kind: 'clear' } })
+    assert(
+      '卡片开着时帧内报 clear：卡片不关、选区不清（发送与轮询都还要用）',
+      hook.voiceCard().open === true && hook.selection() !== null,
+      JSON.stringify({ card: hook.voiceCard().open, sel: hook.selection() }),
+    )
+    assert('麦克风轮询还在（靠它判断"说完了没有"）', hook.voiceCard().watching === true, JSON.stringify(hook.voiceCard()))
+
+    // 帧内重报（滚动 / 挪选区）：跟着挪卡片，不要又冒出浮标
+    windowStub.dispatch('message', {
+      source: frameWindow,
+      data: { __dshSel: 1, kind: 'selection', sel: { text: '网页里选中的这段', context: '前文【网页里选中的这段】后文', keyContext: '前文', label: '', rect: { x: 10, y: 60, right: 120, bottom: 78, w: 110, h: 18 } } },
+    })
+    const moved = hook.voiceCard()
+    assert(
+      '帧内重报：卡片跟着挪（锚点 120→160 → top 160→200），浮标不冒出来',
+      moved.open === true && !!moved.geometry && moved.geometry.top === '200px' && button.style.display === 'none',
+      JSON.stringify({ top: moved.geometry && moved.geometry.top, pill: button.style.display }),
+    )
+
+    // 说话 → 发送：上下文用桥采好的那份
+    if (box) {
+      box.value = '这段在说什么？'
+      box.dispatch('input', { target: box, preventDefault() {}, stopPropagation() {} })
+    }
+    hook.voiceCardSend()
+    await sleep(60)
+    const framePayload = hook.payload()
+    assert(
+      '发送后用桥采好的上下文（顶层 DOM 里根本没有这段文字）',
+      !!framePayload && framePayload.context === '前文【网页里选中的这段】后文',
+      framePayload && framePayload.context,
+    )
+    assert(
+      '发送后卡片收起、面板开着',
+      hook.voiceCard().open === false && panel.style.display !== 'none',
+      JSON.stringify({ card: hook.voiceCard().open, panel: panel.style.display }),
+    )
+
+    // 帧内按一下 = 收卡（父页面收不到那个 mousedown，只能靠桥的 press）
+    hook.close()
+    await sleep(20)
+    windowStub.dispatch('message', {
+      source: frameWindow,
+      data: { __dshSel: 1, kind: 'selection', sel: { text: '第二段网页文字', context: '【第二段网页文字】', keyContext: '', label: '', rect: { x: 10, y: 20, right: 120, bottom: 38, w: 110, h: 18 } } },
+    })
+    await sleep(300)
+    assert('（前提）卡片又弹出来了', hook.voiceCard().open === true, JSON.stringify(hook.voiceCard()))
+    windowStub.dispatch('message', { source: frameWindow, data: { __dshSel: 1, kind: 'press' } })
+    const afterPress = hook.voiceCard()
+    assert('帧内按下：卡片收掉（并播关机动画）', afterPress.open === false && afterPress.closing === true, JSON.stringify(afterPress))
+    await sleep(800) // 桩里没有 animationend，走 640ms 兜底
+
+    // 收尾：选区清掉、帧从扫描里摘掉、麦克风复位
+    windowStub.dispatch('message', { source: frameWindow, data: { __dshSel: 1, kind: 'clear' } })
+    assert('卡片收起后帧内的 clear 照旧生效（选区状态收干净）', hook.selection() === null, JSON.stringify(hook.selection()))
+    frame.isConnected = false
+    micStub.value = stopped3
+    documentStub.activeElement = body
+    documentStub.querySelectorAll = priorQuerySelectorAll
+    hook.close()
+    await sleep(40)
+  }
+
+  micStub.value = { ok: true, available: false, capturing: false, processes: [], reason: 'stub-default' }
+  hook.close()
+  await sleep(20)
+}
+
 for (const dispose of disposers.reverse()) {
   try {
     dispose()
@@ -4806,6 +6054,57 @@ for (const dispose of disposers.reverse()) {
     console.log('cleanup 抛错:', error && error.message)
   }
 }
+// ────────── 拖拽上限 = 视口高度 − 8，不是"上次关闭小窗之前的高度" ──────────
+// 踩过的坑：开窗时把"记住的高度"写成 max-height 当天花板，而拖拽只写 height、不抬天花板 →
+// 拖大的部分被那条旧天花板直接截掉。取证：maxHeight 仍停在开窗时的那条 300px。
+{
+  sizeStore = { w: 380, h: 300 } // 造一个很小的"上次记住的高度"
+  hook.close()
+  await sleep(40)
+  hook.open('size-ceiling-probe', '', '尺寸天花板用例')
+  for (let i = 0; i < 80 && hook.state().phase !== 'done'; i += 1) await sleep(20)
+  await sleep(30)
+  // 注：这里**不**断言"开窗时已应用记住的高度" —— loadPanelSize 整页只请求一次，
+  // 而它在本次用例跑之前（sizeStore 还是 null 时）就已经标记"问过了"，桩里造不出这个前提。
+  // 好在下面的断言本身就能抓住这个 bug：没有修复时拖拽只写 height、不抬 max-height，
+  // maxHeight 会停在开窗时的值（或为空），dragH > 300 直接不成立。
+  const grip = Array.from(walk(panel)).find((n) => String(n.className).indexOf('dsh-sel-grip-corner') >= 0)
+  assert('（前提）找得到右下角拖拽手柄', !!grip, String(grip && grip.className))
+  grip.dispatch('pointerdown', { button: 0, clientX: 0, clientY: 0, pointerId: 1, preventDefault() {}, stopPropagation() {} })
+  windowStub.dispatch('pointermove', { clientX: 0, clientY: 800 })
+  const dragH = parseInt(panel.style.maxHeight, 10)
+  assert('拖高之后天花板跟着抬高（不再被旧高度卡住）', dragH > 300, String(panel.style.maxHeight))
+  assert('上限是视口高度 − 8', dragH <= 900 - 8, String(panel.style.maxHeight))
+  assert('拖出来的高度当场生效（height 与天花板一致）', panel.style.height === panel.style.maxHeight, JSON.stringify({ h: panel.style.height, max: panel.style.maxHeight }))
+  windowStub.dispatch('pointerup', {})
+  await sleep(380) // 等防抖存档落盘（走桩，不会写进真实 host）
+  grip.dispatch('dblclick', { preventDefault() {}, stopPropagation() {} })
+  await sleep(40)
+  assert('双击手柄恢复默认（天花板清空）', panel.style.maxHeight === '', JSON.stringify(panel.style.maxHeight))
+  sizeStore = null
+}
+
+// ⚠️ 放在**最后**：这一节前面/中间还有别的用例会写模型设置，早了会被覆盖掉。
+// 还原真实配置：这一段跑在"用户正在用的插件"上时，把进本节之前的快照写回去。
+// 隔离宿主（test-settings-host.mjs）下也无害 —— 那份宿主本来就是一次性的。
+{
+  const values = (settingsSnapshot && settingsSnapshot.values) || {}
+  // 只发有值的、且不是虚拟键的（虚拟键会被宿主拒掉，返回 rejected 里，无害但还是别发）
+  const restore = {}
+  Object.keys(values).forEach((key) => {
+    if (key === 'modelChoice') return
+    if (values[key] === undefined || values[key] === null) return
+    restore[key] = values[key]
+  })
+  if (Object.keys(restore).length) {
+    await fetch(ORIGIN + '/selection-explain/api/settings', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ values: restore }),
+    })
+  }
+}
+
 assert('清理后 DOM 归零', mount.children.length === 0 && body.children.indexOf(container) >= 0)
 assert('清理后划词桥自己建的预览 blob 被回收', bridgeOwnedBlob !== '' && !blobStore.has(bridgeOwnedBlob), bridgeOwnedBlob)
 assert('清理后钩子移除', windowStub.__dshSelectionExplain === undefined)