@yfwu2020/dsh-selection-explain 0.1.3 → 0.4.0

package/src/client/index.js

@@ -30,6 +30,33 @@ window.__ModuleLoader__.load({
     var HISTORY = '/selection-explain/api/history'
     /** 模型清单（带每个模型支持的推理等级）。 */
     var MODELS = '/selection-explain/api/models'
+    /**
+     * 语音输入（小窗麦克风）：识别在 host 上做，浏览器只负责录一段规范 WAV 送过去。
+     *   · 目录接口说清"能不能录、要录多久、要不要先准备模型"；
+     *   · 音频不落盘、不进会话，转写完即丢（客户端的引用里也不会出现音频）。
+     */
+    var SPEECH_API = '/selection-explain/api/speech'
+    var SPEECH_TRANSCRIBE = SPEECH_API + '/transcribe'
+    var SPEECH_PREPARE = SPEECH_API + '/prepare'
+    /** 兜底限制（host 的 limits 优先；拿不到目录时按这套走）。 */
+    var VOICE_FALLBACK_SECONDS = 60
+    var VOICE_MAX_BYTES = 4 * 1024 * 1024
+    /** 目录缓存时长：同一分钟内反复点麦克风不再重复问 host。 */
+    var VOICE_CATALOG_TTL = 60 * 1000
+    /**
+     * 实时字幕（半句预览 + 停顿定稿）：
+     *   · 说话时每 ~1.3s 把"还没定稿的这半句"送去识别一次，结果**整段替换**上一拍的预览；
+     *   · 检测到 ~0.6s 静音（一句话说完了）就把这句送去识别并**定稿**，之后不再变。
+     * 只在本地识别器上默认开（云端每拍一次都是付费调用）；窗口固定 ≤10 秒，
+     * 这样说到第 40 秒也不会变慢（实测 8s 窗口 185ms、40s 整段要 1.1s）。
+     */
+    var VOICE_PREVIEW_EVERY = 1300
+    var VOICE_PREVIEW_WINDOW = 10
+    var VOICE_PAUSE_MS = 600
+    var VOICE_PAUSE_MIN_MS = 400
+    var VOICE_COMMIT_MAX_SECONDS = 25
+    /** "有声"的门限（RMS）：低于它算静音，连着 0.6s 就是一句话说完了。 */
+    var VOICE_SILENCE_RMS = 0.012
     /** 选区长度上限（与 host 默认值一致，host 还会再校验一次）。 */
     var MAX_SELECTION = 4000
     /** 上下文窗口：选区前后各取多少字符。 */
@@ -37,6 +64,37 @@ window.__ModuleLoader__.load({
 
     /** key 只取选中文字**之前**这么多字：后缀会随新消息变化，不能进 key。 */
     var KEY_CONTEXT_CHARS = 300
+    /**
+     * 引用（❝）：小窗开着时，把**小窗里选中的正文**或**主界面上选中的文字**
+     * 挂进小窗输入框，发送时作为材料一并发给模型。
+     *   · 一次最多几段 —— 每段都会进本轮提问，堆太多等于把问题埋掉；
+     *   · 每段字数上限 —— 超了截断（引用整条回答时最长的那种会撞上）。
+     */
+    var MAX_QUOTES = 4
+    var MAX_QUOTE_CHARS = 3000
+    /**
+     * 引用**选区**的长度上限（比 MAX_QUOTE_CHARS 宽得多）。
+     *
+     * 划一大段（比如整条回答）时也要让浮标出来 —— 出来之后按 MAX_QUOTE_CHARS 截断并说明；
+     * 早先这里直接用 MAX_QUOTE_CHARS 判断，结果是"划长一点就没反应"，
+     * 而用户根本不知道为什么（浮标不出现 = 没有任何反馈）。
+     */
+    var MAX_QUOTE_SELECTION = 20000
+    /** 只挂了引用、一个字都没写时，用它当提问（不替用户编复杂问题）。 */
+    var QUOTE_ONLY_QUESTION = '就上面引用的文字，说说它在这里是什么意思。'
+    /**
+     * 引用的上下文：**只带模型看不到的东西**。
+     *   · 小窗自己的正文（回答 / 两节 / 顶部原文条）→ **不带**：那几轮对话本来就会随 history
+     *     进模型，出处靠标签说清（「小窗第 2 轮回答」「小窗「翻译」节」）；
+     *   · 主界面（会话）→ 由 host 从会话记录里取"引用所在那一组对话 ± 一组"（干净文本、按轮取整），
+     *     见 QUOTE_CONTEXT_API；客户端先用局部窗口兜底，发送前才去问 host；
+     *   · 侧边栏网页 → 帧内桥采的局部窗口。
+     */
+    var QUOTE_CONTEXT_API = '/selection-explain/api/quote-context'
+    /** 会话版上下文的等待上限（毫秒）：超了就用客户端那份，不让发送卡住。 */
+    var QUOTE_CONTEXT_TIMEOUT = 1500
+    /** 会话版上下文的等待上限（毫秒）：超了就用客户端那份，不让发送卡住。 */
+    var QUOTE_CONTEXT_TIMEOUT = 1500
     /** 面板 z-index 顶部。 */
     var Z_BTN = 2147483000
     var Z_PANEL = 2147483001
@@ -75,6 +133,74 @@ window.__ModuleLoader__.load({
       return ms < 1000 ? ms + 'ms' : (ms / 1000).toFixed(1) + 's'
     }
 
+    // ────────────────────────── 录音（语音输入）──────────────────────────
+    // 这一节是**纯函数 + 浏览器能力判断**，不碰面板状态：小窗的编排在 apply() 里。
+    // 单位换算和 WAV 头必须和 host 的 validateWave 逐字段对上（16kHz / 单声道 / PCM16），
+    // 对不上 host 会直接拒收 —— 这是刻意的：宁可明确报"音频格式不对"，
+    // 也不要让识别服务按错误的采样率去听一段快放。
+
+    /** 录音时长：0:07（上限 60 秒，所以只有分:秒）。 */
+    function formatClock(ms) {
+      var seconds = Math.max(0, Math.floor(ms / 1000))
+      var mm = Math.floor(seconds / 60)
+      var ss = seconds % 60
+      return mm + ':' + (ss < 10 ? '0' : '') + ss
+    }
+
+    /**
+     * Float32 采样（16kHz 单声道）→ 规范的 PCM16 WAV。
+     * @param samples 采样（-1..1）
+     * @returns Uint8Array（44 字节头 + 数据）
+     */
+    function encodeWave(samples) {
+      var bytes = new Uint8Array(44 + samples.length * 2)
+      var view = new DataView(bytes.buffer)
+      function ascii(offset, text) {
+        for (var i = 0; i < text.length; i += 1) view.setUint8(offset + i, text.charCodeAt(i))
+      }
+      ascii(0, 'RIFF')
+      view.setUint32(4, 36 + samples.length * 2, true)
+      ascii(8, 'WAVE')
+      ascii(12, 'fmt ')
+      view.setUint32(16, 16, true) // fmt 块长度
+      view.setUint16(20, 1, true) // PCM
+      view.setUint16(22, 1, true) // 单声道
+      view.setUint32(24, 16000, true) // 采样率
+      view.setUint32(28, 32000, true) // 字节率
+      view.setUint16(32, 2, true) // 块对齐
+      view.setUint16(34, 16, true) // 位深
+      ascii(36, 'data')
+      view.setUint32(40, samples.length * 2, true)
+      for (var i = 0; i < samples.length; i += 1) {
+        // 先夹到 [-1,1]：重采样后的浮点偶尔会略微越界，直接乘会绕回成刺耳的爆音
+        var value = samples[i] < -1 ? -1 : samples[i] > 1 ? 1 : samples[i]
+        view.setInt16(44 + i * 2, Math.round(value * (value < 0 ? 32768 : 32767)), true)
+      }
+      return bytes
+    }
+
+    /** 字节 → base64（分块喂 fromCharCode，几十万采样一次性展开会爆栈）。 */
+    function bytesToBase64(bytes) {
+      var text = ''
+      for (var i = 0; i < bytes.length; i += 8192) {
+        text += String.fromCharCode.apply(null, bytes.subarray(i, i + 8192))
+      }
+      return btoa(text)
+    }
+
+    /** 这个浏览器能不能录音（不支持时麦克风按钮直接给解释，而不是点了才报错）。 */
+    function recordingSupported() {
+      try {
+        if (typeof navigator === 'undefined' || !navigator.mediaDevices) return false
+        if (typeof navigator.mediaDevices.getUserMedia !== 'function') return false
+        // 全部走 window.*：浏览器里 window 就是全局对象，测试里也能注入同一套桩
+        if (typeof window.MediaRecorder === 'undefined') return false
+        return typeof window.AudioContext !== 'undefined' || typeof window.webkitAudioContext !== 'undefined'
+      } catch (error) {
+        return false
+      }
+    }
+
     // ────────────────────────────── 样式 ──────────────────────────────
 
     var CSS = [
@@ -272,10 +398,45 @@ window.__ModuleLoader__.load({
       'border-radius:22px;border:1px solid var(--dsw-alias-border-l3,rgba(140,140,140,.35));',
       'background:var(--dsw-alias-bg-base,transparent)}',
       '.dsh-sel-ask:focus-within{border-color:var(--sel-a1,#0d9488)}',
-      '.dsh-sel-askbox{width:100%;min-height:26px;max-height:96px;overflow-y:auto;resize:none;padding:4px 0 0;',
+      // 高度由 JS 跟着内容长（autoGrowAskBox）：textarea 自己只会缩在 rows=1 的高度里，
+      // 换行之后下面的字就被裁掉了（语音输入时最明显 —— 字是自己长出来的，用户根本没在敲键盘）。
+      // 这里给个上限：过了就内部滚动，面板不会被一段长文顶穿。
+      '.dsh-sel-askbox{width:100%;min-height:26px;max-height:132px;overflow-y:hidden;resize:none;padding:4px 0 0;',
       'border:0;background:transparent;color:inherit;font:inherit;font-size:13px;line-height:1.5;outline:none}',
+      // 引用区（composer 第一行之上）：每段一张小卡片，来源一行小字 + 内容一行（超出省略）+ 右侧 ✕。
+      // 卡片是**待发送**的引用，发送后整片清空 —— 它属于"这条消息"，不属于会话。
+      '.dsh-sel-quotes{display:none;flex-direction:column;gap:4px;max-height:96px;overflow-y:auto;',
+      'scrollbar-width:thin;padding:1px 0 0}',
+      '.dsh-sel-quotes[data-show="1"]{display:flex}',
+      '.dsh-sel-quotechip{display:flex;align-items:center;gap:7px;padding:4px 4px 4px 8px;border-radius:10px;',
+      'border-left:2px solid color-mix(in srgb,var(--sel-a1,#0d9488) 55%,transparent);',
+      'background:color-mix(in srgb,var(--sel-a1,#0d9488) 7%,transparent)}',
+      '.dsh-sel-quotechip-src{flex:0 0 auto;font-size:10.5px;line-height:1.5;opacity:.66;white-space:nowrap;',
+      'max-width:96px;overflow:hidden;text-overflow:ellipsis}',
+      '.dsh-sel-quotechip-text{flex:1 1 auto;min-width:0;font-size:12px;line-height:1.5;opacity:.9;',
+      'overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
+      '.dsh-sel-quotechip-x{flex:0 0 auto;width:18px;height:18px;padding:0;border:0;border-radius:9px;cursor:pointer;',
+      'background:transparent;color:var(--dsw-alias-label-secondary,inherit);opacity:.5;font:inherit;font-size:11px;',
+      'line-height:1;display:inline-flex;align-items:center;justify-content:center}',
+      '.dsh-sel-quotechip-x:hover{opacity:1;background:var(--dsw-alias-interactive-bg-hover,rgba(140,140,140,.16))}',
+      // 气泡里的引用块（用户消息）：引用在上、问题在下 —— 和发出去给模型的那份顺序一致
+      '.dsh-sel-bq{display:flex;flex-direction:column;gap:3px;margin-bottom:6px}',
+      '.dsh-sel-bqitem{padding:3px 8px;border-radius:8px;border-left:2px solid color-mix(in srgb,var(--sel-a1,#0d9488) 45%,transparent);',
+      'background:var(--dsw-alias-interactive-bg-hover,rgba(140,140,140,.14));font-size:11.5px;line-height:1.55;',
+      'opacity:.82;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
+      '.dsh-sel-bqitem b{font-weight:600;opacity:.75;margin-right:5px}',
+      // 「引用整条」：贴在助手气泡末尾，**平时不出现**（正文优先），鼠标移到这条消息上才浮出来。
+      // 键盘 Tab 也能到（:focus-visible 同样点亮），触屏上另有浮标那条路。
+      '.dsh-sel-bubquote{margin-top:7px;display:inline-flex;align-items:center;gap:4px;padding:2px 9px;',
+      'border:1px solid transparent;border-radius:9px;background:transparent;cursor:pointer;',
+      'color:var(--dsw-alias-label-secondary,inherit);font:inherit;font-size:11px;line-height:1.6;',
+      'opacity:0;transition:opacity .15s ease}',
+      '.dsh-sel-bubble:hover .dsh-sel-bubquote,.dsh-sel-bubquote:focus-visible{opacity:.66}',
+      '.dsh-sel-bubquote:hover{opacity:1;background:var(--dsw-alias-interactive-bg-hover,rgba(140,140,140,.14))}',
       // 下面那行：左侧网页模式（圆形浅底，和主会话的 + 同款），右侧发送（圆形实心）
-      '.dsh-sel-asktools{display:flex;align-items:center;gap:8px}',
+      // flex-wrap 是给窄屏兜底的：这一行现在有 4 件东西（输出偏好 / 模型 / 麦克风 / 发送），
+      // 窄面板下宁可折成两行，也不能把发送键挤出可视区（挤出去就点不到了）。
+      '.dsh-sel-asktools{display:flex;align-items:center;gap:8px;flex-wrap:wrap;row-gap:6px}',
       '.dsh-sel-askspace{flex:1 1 auto}',
       // 页眉里的撑开占位（标题与右侧按钮之间）
       '.dsh-sel-headspace{flex:1 1 auto;min-width:8px}',
@@ -338,7 +499,44 @@ window.__ModuleLoader__.load({
       // 生成中：发送键变成"停止"（方形图标，点了打断当前输出）
       '.dsh-sel-asksend[data-mode="stop"]{background:var(--dsw-alias-label-secondary,rgba(120,120,120,.9));opacity:1}',
       '.dsh-sel-asksend[data-mode="stop"]:hover{filter:brightness(1.12)}',
-      // 页脚整条删掉了：状态改成**浮在输入框上方的短提示**，2.6 秒后自己淡出（不占版面）
+      // ── 语音输入（麦克风）──
+      // **和主会话同一套交互**（官方 ui-voice-input）：平时是输入框右边的 🎤；
+      // 一旦开始录，工具行整个换成"录音行" ——`✕` | 实时波形 | `■`（识别中则是
+      // 「识别中…」+ 呼吸点），发送键原位不动。尺寸按小窗的 composer 收成 26px
+      // （主会话是 32px），其余结构、图标语义、波形算法都照抄，两处看起来才是同一个东西。
+      '.dsh-sel-mic{transition:background .15s ease,color .15s ease}',
+      '@keyframes dsh-sel-spin{to{transform:rotate(360deg)}}',
+      '.dsh-sel-mic[data-state="requesting"] svg{animation:dsh-sel-spin .9s linear infinite}',
+      '.dsh-sel-mic:disabled{cursor:default;opacity:.35}',
+      // 录音行：flex:1 让它吃掉中间那截（主会话也是 waveform flex:1）
+      '.dsh-sel-capture{display:none;flex:1 1 auto;min-width:0;align-items:center;gap:8px}',
+      '.dsh-sel-capture[data-show="1"]{display:flex}',
+      // 圆键：和发送键同尺寸、同圆度；浅底 + hover 变深（主会话的 roundButton 也是这套）
+      '.dsh-sel-round{flex:0 0 auto;width:26px;height:26px;padding:0;border:0;border-radius:13px;cursor:pointer;',
+      'display:inline-grid;place-items:center;background:var(--dsw-alias-interactive-bg-hover,rgba(140,140,140,.14));',
+      'color:var(--dsw-alias-label-secondary,inherit)}',
+      '.dsh-sel-round:hover{background:var(--dsw-alias-interactive-bg-hover-solid,rgba(140,140,140,.28));',
+      'color:var(--dsw-alias-label-primary,inherit)}',
+      '.dsh-sel-round:disabled{cursor:default;opacity:.35}',
+      '.dsh-sel-round svg{width:14px;height:14px;display:block}',
+      // 停止键：图标是实心方块（主会话的 IconStopFill），颜色取主文字色 —— 一眼是"停"
+      '.dsh-sel-stop{color:var(--dsw-alias-label-primary,inherit)}',
+      // 波形：80 根竖线、中间对齐、静音时是一条虚线（算法与主会话逐行一致，见 paintWave）
+      '.dsh-sel-vwave{flex:1 1 auto;min-width:24px;height:24px;display:block;color:var(--dsw-alias-label-secondary,inherit)}',
+      // 状态文案（请允许使用麦克风… / 识别中… / 没听清…）：12px 次要色 + 可选呼吸点
+      '.dsh-sel-vactivity{flex:1 1 auto;min-width:0;display:flex;align-items:center;gap:8px;font-size:12px;line-height:1.4;',
+      'color:var(--dsw-alias-label-secondary,inherit);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}',
+      '.dsh-sel-vdot{flex:0 0 auto;width:6px;height:6px;border-radius:50%;background:var(--sel-a1,#0d9488);',
+      'animation:dsh-sel-pillpulse 1.4s ease-in-out infinite}',
+      '.dsh-sel-vactivity[data-tone="error"]{color:var(--dsw-alias-state-error-primary,#e5484d)}',
+      '.dsh-sel-vactivity[data-tone="warn"]{color:var(--dsw-alias-state-warn-primary,#b45309)}',
+      '.dsh-sel-vactslot{flex:0 0 auto;display:inline-flex;align-items:center;gap:6px}',
+      '.dsh-sel-vactslot:empty{display:none}',
+      // 行内动作（准备模型 / 重新录音）：主会话是同款的 inlineAction
+      '.dsh-sel-vact{flex:0 0 auto;height:22px;padding:0 9px;border:1px solid currentColor;border-radius:11px;cursor:pointer;',
+      'background:transparent;color:inherit;font:inherit;font-size:11px;line-height:1;opacity:.85;white-space:nowrap}',
+      '.dsh-sel-vact:hover{opacity:1}',
+      '.dsh-sel-vact:disabled{opacity:.4;cursor:default}',
       '.dsh-sel-askbox:focus{border-color:var(--sel-a1,#0d9488)}',
       // 内容区里的「重新生成」：只在没有可用结果（失败 / 已停止 / 空回答）时出现
       '.dsh-sel-retry{margin-top:8px;border:1px solid var(--dsw-alias-border-l3,rgba(140,140,140,.35));background:transparent;',
@@ -1276,6 +1474,359 @@ window.__ModuleLoader__.load({
       return String(text || '').replace(/\s+/g, ' ').trim()
     }
 
+    // ────────────────────── 侧边栏网页：iframe 划词桥 ──────────────────────
+
+    /**
+     * 侧边栏的 HTML 预览是**不透明源**沙箱 iframe（`sandbox="allow-scripts"`，
+     * 刻意不给 `allow-same-origin`）：父页面拿不到 contentDocument，
+     * 顶层 `window.getSelection()` 永远是空的 —— 划词在那里等于瞎的。
+     *
+     * 解法只有一个方向：**让帧内自己上报**。下面这段脚本被注入进被预览的文档，
+     * 在帧内读选区、就地采集上下文（算法与父页面 `collectContext` 完全一致），
+     * 再用 postMessage 报出来；父页面把"帧内坐标 + iframe 的 getBoundingClientRect()"
+     * 换算成视口坐标，复用同一套浮标与面板。
+     *
+     * 安全边界（不能退让）：**不加 `allow-same-origin`**，帧仍是不透明源 ——
+     * 预览页照样读不到 GUI 的 DOM / Cookie / localStorage，也照样不能导航顶层窗口。
+     * 桥只往外报"选中了什么 + 周围那点文本"，别的什么都不给。
+     *
+     * 两处细节不能省：
+     *   ① 监听挂在 **window** 上、并且用轮询兜底 —— 交互式预览的外层文档是 bootstrap，
+     *      它 `document.open()/write()/close()` 会把 document 上的监听全部冲掉，
+     *      只有 window 上的监听能活下来（见宿主 ui-sidebar-documentpreview 的 createHtmlDocument）。
+     *   ② 报的是**帧内视口坐标**（range.getClientRects 的最后一段），父页面再加偏移。
+     */
+    function bridgeBody() {
+      if (window.__dshSelBridge) return
+      window.__dshSelBridge = 1
+      var WINDOW_CHARS = 1500
+      var KEY_CHARS = 300
+      var MAX_SELECTION = 4000
+      /** 鼠标按着超过这么久还没等到 mouseup，就当松手落在帧外了（别永久卡住上报）。 */
+      var STALE_PRESS_MS = 6000
+      /** 轮询连续这么多拍都读不到选区，才认为选区真没了（约 1.5s；瞬时读不到不清）。 */
+      var NULL_TICKS_TO_CLEAR = 6
+      /** 上一次报出去的选区指纹（文字 + 位置），用来去重。 */
+      var last = ''
+      /** 鼠标是不是按着（拖拽划词进行中）。 */
+      var pressed = false
+      var pressedAt = 0
+      /** 上一拍轮询看到的指纹：用于"稳定一拍再报"。 */
+      var pollKey = ''
+      /** 轮询连续读不到选区的拍数。 */
+      var nullTicks = 0
+
+      function norm(text) {
+        return String(text || '').replace(/\s+/g, ' ').trim()
+      }
+
+      function send(kind, sel) {
+        try {
+          parent.postMessage({ __dshSel: 1, kind: kind, sel: sel || null }, '*')
+        } catch (error) {
+          /* 顶层被导航走了之类：报不出去就算了，不能因为报错把预览页搞坏 */
+        }
+      }
+
+      /** 选区所在的语义容器：与父页面 pickContainer 同一套规则（往上找到第一个够长的元素）。 */
+      function containerOf(node) {
+        var element = node && node.nodeType === 1 ? node : node && node.parentElement
+        while (element && element !== document.body) {
+          var length = (element.innerText || '').length
+          if (length >= 120) return element
+          element = element.parentElement
+        }
+        return element || document.body
+      }
+
+      function labelOf(element) {
+        try {
+          if (element && element.closest && element.closest('pre,code')) return '代码块'
+          if (element && element.closest && element.closest('table')) return '表格'
+        } catch (error) {
+          /* 孤立节点上 closest 会抛，忽略 */
+        }
+        return ''
+      }
+
+      /** 这些标签的文本不算正文（脚本源码 / 样式 / 模板 / 文档头）。 */
+      var SKIP_TAGS = { SCRIPT: 1, STYLE: 1, NOSCRIPT: 1, TEMPLATE: 1, HEAD: 1, TITLE: 1, META: 1, LINK: 1 }
+
+      /**
+       * 走 DOM 收集容器的可见文本，并给出 `target`（选区起点）在这段文本里的偏移。
+       * 比 `Range.toString()` 多一步：跳过 script/style 等——否则页面里的 JS 源码会混进上下文。
+       * target 是元素节点（整段选中的情况）时，取"进入该元素那一刻"的长度作为偏移；
+       * 是文本节点时还要加上 `targetOffset`（选区在文本节点内的字符偏移）。
+       */
+      function collectText(root, target, targetOffset) {
+        var text = ''
+        var offset = -1
+        function walk(node) {
+          if (!node) return
+          if (node.nodeType === 3) {
+            if (node === target) offset = text.length + (targetOffset || 0)
+            text += node.nodeValue || ''
+            return
+          }
+          if (node.nodeType !== 1) return
+          if (SKIP_TAGS[node.tagName]) return
+          if (node === target) offset = text.length
+          var kids = node.childNodes || []
+          for (var i = 0; i < kids.length; i += 1) walk(kids[i])
+        }
+        walk(root)
+        return { text: text, offset: offset }
+      }
+
+      /** 读一次选区：文字 + 上下文窗口 + 帧内坐标；没有有效选区返回 null。 */
+      function read() {
+        var selection = window.getSelection && window.getSelection()
+        if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return null
+        var text = String(selection.toString() || '')
+        if (!text.trim() || text.length > MAX_SELECTION) return null
+        var range
+        try {
+          range = selection.getRangeAt(0)
+        } catch (error) {
+          return null
+        }
+        var start = range.startContainer
+        var startElement = start && start.nodeType === 1 ? start : start && start.parentElement
+        try {
+          if (startElement && startElement.closest && startElement.closest('input,textarea')) return null
+        } catch (error) {
+          /* 输入框判断失败不致命 */
+        }
+        var container = containerOf(startElement)
+        var out = { text: text.trim(), context: '', keyContext: '', label: labelOf(container) }
+        try {
+          // 容器正文：**走 DOM 取文本**，跳过 script / style / noscript / template / head。
+          // 不能用 Range.toString()：它把 <script> 里的源码也算进正文——实测（真浏览器冒烟）
+          // 交互式预览里的上下文会带上整段页面 JS，喂给模型纯属噪音。
+          var walked = collectText(container, range.startContainer, range.startOffset)
+          var rawFull = walked.text
+          var offset = walked.offset
+          if (offset < 0) {
+            // 选区起点不在这个容器里（跨容器选区之类）：退回 Range 的算法，至少别丢上下文
+            var prefix = document.createRange()
+            prefix.selectNodeContents(container)
+            prefix.setEnd(range.startContainer, range.startOffset)
+            offset = prefix.toString().length
+          }
+          var from = Math.max(0, offset - WINDOW_CHARS)
+          var to = Math.min(rawFull.length, offset + text.length + WINDOW_CHARS)
+          var windowText = rawFull.slice(from, to)
+          var relative = offset - from
+          var probe = windowText.slice(relative, relative + text.length)
+          var marked
+          if (norm(probe) === norm(text)) {
+            marked = windowText.slice(0, relative) + '【' + probe + '】' + windowText.slice(relative + text.length)
+          } else {
+            var found = rawFull.indexOf(text)
+            if (found >= 0) {
+              var f2 = Math.max(0, found - WINDOW_CHARS)
+              var t2 = Math.min(rawFull.length, found + text.length + WINDOW_CHARS)
+              var w2 = rawFull.slice(f2, t2)
+              var r2 = found - f2
+              marked = w2.slice(0, r2) + '【' + w2.slice(r2, r2 + text.length) + '】' + w2.slice(r2 + text.length)
+            } else {
+              marked = text + '\n---\n' + windowText
+            }
+          }
+          out.context = marked
+            .replace(/\u00a0/g, ' ')
+            .replace(/[ \t]+/g, ' ')
+            .replace(/\n{3,}/g, '\n\n')
+            .trim()
+          out.keyContext = rawFull
+            .slice(Math.max(0, offset - KEY_CHARS), offset)
+            .replace(/\u00a0/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim()
+        } catch (error) {
+          /* 取不到上下文就给空串：父页面照样能开面板，只是少了背景 */
+        }
+        var rect = null
+        try {
+          var rects = range.getClientRects()
+          rect = rects && rects.length > 0 ? rects[rects.length - 1] : null
+        } catch (error) {
+          rect = null
+        }
+        if (!rect) {
+          try {
+            rect = range.getBoundingClientRect()
+          } catch (error) {
+            rect = null
+          }
+        }
+        if (!rect || (!rect.width && !rect.height)) return null
+        out.rect = {
+          x: rect.left,
+          y: rect.top,
+          right: rect.right,
+          bottom: rect.bottom,
+          w: rect.width,
+          h: rect.height,
+        }
+        return out
+      }
+
+      /** 选区指纹：文字 + 帧内位置（位置变了也要重报，父页面据此挪浮标）。 */
+      function fingerprint(now) {
+        if (!now) return ''
+        return now.text + '\u0000' + now.rect.x + ',' + now.rect.y + ',' + now.rect.bottom + ',' + now.rect.right
+      }
+
+      /**
+       * 读一次并上报。
+       *
+       * `allowClear === false` 时**只报选区、不报"选区没了"**：滚动/改尺寸/轮询这些
+       * "顺手重报一下位置"的路径不该有清空权 —— 页面重绘、动画、字体回流时
+       * `getClientRects()` 会短暂拿不到矩形，一抖就 clear 会把浮标误收掉
+       * （用户看到的就是"浮标自己消失了"）。真正的清空信号来自 mouseup / keyup /
+       * selectionchange 这些**用户动作**。
+       */
+      function report(allowClear) {
+        var now = read()
+        if (!now) {
+          if (last && allowClear !== false) {
+            last = ''
+            send('clear', null)
+          }
+          return
+        }
+        var key = fingerprint(now)
+        if (key === last) return
+        last = key
+        send('selection', now)
+      }
+
+      /**
+       * 轮询兜底（250ms）：只负责"没人通知我们"的情况。
+       *
+       * 三道闸门都是为了**时机**跟主会话一致（主会话只在 mouseup / keyup 后弹）：
+       *   ① 鼠标按着（拖拽划词进行中）一律不报 —— 否则拖到一半浮标就冒出来，还跟着手指跑；
+       *   ② 选区还在变（这一拍与上一拍指纹不同）先记账，**稳定一拍**再报；
+       *   ③ 连续 NULL_TICKS_TO_CLEAR 拍都读不到选区才认为它真没了 —— 一次瞬时读不到
+       *      只当页面在重绘，不清浮标（瞬时误清的表现就是"浮标自己消失"）。
+       * 松手落在帧外时不会有 mouseup：超过 STALE_PRESS_MS 就当已经松开，别把上报永久卡死。
+       */
+      function tick() {
+        if (pressed) {
+          if (Date.now() - pressedAt < STALE_PRESS_MS) return
+          pressed = false
+        }
+        var now = read()
+        if (!now) {
+          pollKey = ''
+          nullTicks += 1
+          if (nullTicks >= NULL_TICKS_TO_CLEAR && last) {
+            last = ''
+            send('clear', null)
+          }
+          return
+        }
+        nullTicks = 0
+        var key = fingerprint(now)
+        if (key !== pollKey) {
+          pollKey = key
+          return
+        }
+        if (key === last) return
+        last = key
+        send('selection', now)
+      }
+
+      window.addEventListener('mousedown', function () {
+        pressed = true
+        pressedAt = Date.now()
+        // 帧内按下 = 用户开始新动作 → 让父页面先把浮标收掉。
+        // 主会话那边 document 的 mousedown 就是"点哪都先收起浮标"；帧内的点击父页面收不到，
+        // 不补这一条的话：在网页里点一下（取消选区/点别处）浮标会赖着不走。
+        send('press', null)
+      }, true)
+      // 松手才是"划完了"：与主会话一致（那边也是 mouseup 之后才弹浮标）
+      window.addEventListener('mouseup', function () {
+        pressed = false
+        setTimeout(report, 0)
+      }, true)
+      window.addEventListener('keyup', function () { setTimeout(report, 0) }, true)
+      // 焦点离开这一帧（点去别处）＝ 拖拽状态作废，免得 pressed 卡住
+      window.addEventListener('blur', function () { pressed = false }, true)
+      // 帧内滚动/改尺寸 → 位置变了，重报一次（父页面据此挪浮标）。这两条不许 clear
+      window.addEventListener('scroll', function () {
+        if (pressed) return
+        setTimeout(function () {
+          report(false)
+        }, 60)
+      }, true)
+      window.addEventListener('resize', function () {
+        if (!pressed) report(false)
+      })
+      window.addEventListener('message', function (event) {
+        var data = event && event.data
+        if (!data || data.__dshSel !== 1) return
+        if (data.kind === 'ping') {
+          send('hello', null)
+          report()
+        }
+        if (data.kind === 'rescan') report()
+      })
+      try {
+        document.addEventListener('selectionchange', function () {
+          // 拖拽中不报；键盘扩选（Shift+方向键）没有 mousedown，照旧即时上报
+          if (!pressed) report()
+        })
+      } catch (error) {
+        /* 老环境没有 selectionchange：轮询兜着 */
+      }
+      setInterval(tick, 250)
+      setTimeout(report, 60)
+    }
+
+    /** 注入标记：既用来认"这份 HTML 已经桥过"，也是 iframe 元素上的记号。 */
+    var BRIDGE_MARK = 'data-dsh-sel-bridge'
+
+    /**
+     * 把桥脚本插进一份 HTML（返回新串；没有可插的地方 / 已经插过 → null）。
+     *
+     * 基础预览（srcdoc）那份 HTML 已经过宿主 DOMPurify 清洗：无脚本、无外链，
+     * 且带一条 `script-src 'none'` 的 CSP。我们**只放宽这一条**到 'unsafe-inline'
+     * （好让桥跑起来），`default-src 'none'` / `connect-src 'none'` / `img-src data:`
+     * 等其余限制原样保留 —— 预览页依然联不了网、加载不了外部资源。
+     */
+    function bridgeIntoHtml(html) {
+      var text = String(html || '')
+      if (!text || text.indexOf(BRIDGE_MARK) >= 0) return null
+      text = text.replace(/script-src\s+'none'/i, "script-src 'unsafe-inline'")
+      var tag = '<scr' + 'ipt ' + BRIDGE_MARK + '>(' + String(bridgeBody) + ')();</scr' + 'ipt>'
+      return insertIntoHtml(text, tag)
+    }
+
+    /**
+     * 插入位置按"尽量靠前、但别破坏文档"排序：
+     * charset（中文标签不能变乱码）→ head → html → 第一个 script 之前 → doctype 之后 → 最前。
+     */
+    function insertIntoHtml(html, tag) {
+      var anchors = [/<meta[^>]+charset[^>]*>/i, /<head[^>]*>/i, /<html[^>]*>/i]
+      for (var i = 0; i < anchors.length; i += 1) {
+        var hit = anchors[i].exec(html)
+        if (hit) {
+          var cut = hit.index + hit[0].length
+          return html.slice(0, cut) + tag + html.slice(cut)
+        }
+      }
+      var script = /<script/i.exec(html)
+      if (script) return html.slice(0, script.index) + tag + html.slice(script.index)
+      var doctype = /^\s*<!doctype[^>]*>/i.exec(html)
+      if (doctype) {
+        var end = doctype.index + doctype[0].length
+        return html.slice(0, end) + tag + html.slice(end)
+      }
+      return tag + html
+    }
+
     // ────────────────────── 主逻辑 ──────────────────────
 
     function apply(ctx) {
@@ -1289,6 +1840,11 @@ window.__ModuleLoader__.load({
         raw: '',
         /** 'idle' | 'loading' | 'streaming' | 'done' | 'error'。 */
         phase: 'idle',
+        /**
+         * 当前选区是不是来自**侧边栏网页里的桥**（iframe 帧内上报）。
+         * 为 true 时顶层选区塌掉不算"选区没了"——那种塌陷是我们点浮标造成的。
+         */
+        bridgeActive: false,
         /** 计时与统计。 */
         startedAt: 0,
         elapsed: 0,
@@ -1327,6 +1883,15 @@ window.__ModuleLoader__.load({
         stage: '',
         /** 追问轮次：[{ role: 'user' | 'assistant', text }]，只活在面板/内存里（临时）。 */
         turns: [],
+        /**
+         * 待发送的引用：[{ label: '小窗回答' | '主界面选中' …, text }]。
+         * 只属于**下一条**提问（发送即清空）；关掉面板不清 —— 回来接着写还看得见。
+         */
+        quotes: [],
+        /** 最近一次"可以引用"的选区：[{ text, label, rect, source }]（浮标据此显示）。 */
+        quoteSelection: null,
+        /** 正在取引用的会话上下文（这期间再按 Enter 不能空发一条）。 */
+        resolvingQuotes: false,
         /** 最近一条状态文本（界面上不显示，只给自检用）。 */
         lastStatus: '',
         /** 是不是"跟着最新消息走"（发完消息自动置真；用户自己往上滚就交回给他）。 */
@@ -1379,6 +1944,25 @@ window.__ModuleLoader__.load({
       button.appendChild(el('span', null, '解读'))
       layer.appendChild(button)
 
+      /**
+       * 引用浮标（`❝ 引用`）：**小窗开着**的时候才有它 —— 这时候用户划词多半是想
+       * 接着问，而不是再开一个小窗（再开一个的入口是先把当前小窗收起来）。
+       * 两种来源共用它：
+       *   · 小窗自己正文里的选区（回答 / 翻译 / 详解 / 顶部选中文字条）；
+       *   · 小窗开着时主界面上的选区（含侧边栏网页里那条由桥报上来的）。
+       * 点一下 → 挂进小窗输入框的引用区，不打断输入。
+       */
+      var quoteButton = el('button', 'dsh-sel-btn dsh-sel-quotebtn')
+      quoteButton.type = 'button'
+      quoteButton.title = '引用到小窗输入框（作为下一句提问的材料）'
+      // **必须比面板高**：小窗里划词时，浮标是画在面板上面的那层（同一个浮层里的兄弟节点，
+      // 谁 z-index 大谁在上）。用 Z_BTN 的话浮标会被面板整个盖住 —— 看不见也点不着。
+      quoteButton.style.zIndex = String(Z_PANEL + 1)
+      quoteButton.style.pointerEvents = 'auto'
+      quoteButton.appendChild(quoteIcon())
+      quoteButton.appendChild(el('span', null, '引用'))
+      layer.appendChild(quoteButton)
+
       /**
        * 悬浮状态胶囊：显示"最近一次划词现在处于什么状态"，点一下回到那个小窗。
        * 位置由 placePill() 动态贴到右下角费用胶囊（dsh-spend）上方；老版本没装那个插件时用兜底位置。
@@ -1436,6 +2020,10 @@ window.__ModuleLoader__.load({
       var chatLog = el('div', 'dsh-sel-chatlog')
       body.appendChild(chatLog)
       var askRow = el('div', 'dsh-sel-ask')
+      // 引用区是 composer 的**第一行**：挂在输入框上面（发送时随提问一起带走、发完清空）。
+      // 顺序很重要 —— 先 append 到 askRow 再 append 输入框，否则会排到工具行下面去。
+      var quotesBox = el('div', 'dsh-sel-quotes')
+      askRow.appendChild(quotesBox)
       var askBox = el('textarea', 'dsh-sel-askbox')
       askBox.rows = 1
       askBox.placeholder = '就这段文字继续追问…（Enter 发送，Shift+Enter 换行）'
@@ -1465,6 +2053,14 @@ window.__ModuleLoader__.load({
       askSend.type = 'button'
       askSend.setAttribute('aria-label', '发送')
       askSend.appendChild(sendIcon())
+      // 语音输入：麦克风贴在发送键左边（和主会话 composer 的位置一致）。
+      // 平时就是这枚图标；一旦开始录，工具行整个换成下面的"录音行"（与主会话同一套）。
+      var micButton = el('button', 'dsh-sel-iconbtn dsh-sel-mic')
+      micButton.type = 'button'
+      micButton.setAttribute('data-state', 'idle')
+      micButton.setAttribute('aria-label', '语音输入')
+      micButton.title = '语音输入（点一下开始说，再点一下结束并转成文字）'
+      micButton.appendChild(micIcon())
       // 模型 + 推理等级（追问档）：胶囊在发送键左边，菜单向上弹
       var modelPill = el('button', 'dsh-sel-picker')
       modelPill.type = 'button'
@@ -1478,14 +2074,71 @@ window.__ModuleLoader__.load({
       var modelMenu = el('div', 'dsh-sel-pickermenu')
       modelMenu.setAttribute('role', 'menu')
 
+      // ── 录音行（与主会话 ui-voice-input 同一套结构）──
+      //   [✕ 取消] [实时波形 / 状态文案] [■ 停止 或 行内动作] …… [↑ 发送（原位不动）]
+      // 录音时是「✕ + 波形 + ■」；请求权限与识别中是「✕ + 呼吸点 + 请允许使用麦克风…/识别中…」；
+      // 出错是「✕ + 原因 + 行内动作（准备模型 / 重新录音）」。
+      var captureRow = el('div', 'dsh-sel-capture')
+      captureRow.setAttribute('data-show', '0')
+      var voiceCancel = el('button', 'dsh-sel-round')
+      voiceCancel.type = 'button'
+      voiceCancel.setAttribute('aria-label', '取消')
+      voiceCancel.title = '取消（Esc）'
+      voiceCancel.appendChild(closeIcon())
+      // 波形：80 根竖线，静音时是一条虚线（算法照抄主会话的 Waveform）
+      var waveSvg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+      waveSvg.setAttribute('class', 'dsh-sel-vwave')
+      waveSvg.setAttribute('viewBox', '0 0 640 40')
+      waveSvg.setAttribute('preserveAspectRatio', 'none')
+      waveSvg.setAttribute('role', 'img')
+      waveSvg.setAttribute('aria-label', '正在录音…')
+      var waveBars = []
+      for (var waveIndex = 0; waveIndex < 80; waveIndex += 1) {
+        var waveBar = document.createElementNS('http://www.w3.org/2000/svg', 'line')
+        waveBar.setAttribute('x1', String(waveIndex * 8 + 4))
+        waveBar.setAttribute('x2', String(waveIndex * 8 + 4))
+        waveBar.setAttribute('y1', '19')
+        waveBar.setAttribute('y2', '21')
+        waveBar.setAttribute('stroke', 'currentColor')
+        waveBar.setAttribute('stroke-width', '3')
+        waveBar.setAttribute('stroke-linecap', 'round')
+        waveBar.setAttribute('opacity', String(0.25 + waveIndex / 120))
+        waveSvg.appendChild(waveBar)
+        // 最新的电平在最右边：和主会话一样从右往左推
+        waveBars.unshift({ node: waveBar, level: 0 })
+      }
+      var voiceActivity = el('span', 'dsh-sel-vactivity')
+      voiceActivity.setAttribute('role', 'status')
+      var voiceDot = el('span', 'dsh-sel-vdot')
+      var voiceActivityText = el('span', null, '')
+      voiceActivity.appendChild(voiceDot)
+      voiceActivity.appendChild(voiceActivityText)
+      var voiceStop = el('button', 'dsh-sel-round dsh-sel-stop')
+      voiceStop.type = 'button'
+      voiceStop.setAttribute('aria-label', '停止并识别')
+      voiceStop.title = '停止并识别'
+      voiceStop.appendChild(stopIcon())
+      // 行内动作位：按状态放「准备模型」文字键或「重新录音」🎤圆键（主会话同款 inlineAction）
+      var voiceActionSlot = el('span', 'dsh-sel-vactslot')
+      captureRow.appendChild(voiceCancel)
+      captureRow.appendChild(waveSvg)
+      captureRow.appendChild(voiceActivity)
+      captureRow.appendChild(voiceActionSlot)
+      captureRow.appendChild(voiceStop)
+
       var askTools = el('div', 'dsh-sel-asktools')
+      var askSpacer = el('span', 'dsh-sel-askspace')
       askTools.appendChild(webMode)
-      askTools.appendChild(el('span', 'dsh-sel-askspace'))
+      askTools.appendChild(askSpacer)
       askTools.appendChild(modelPill)
+      askTools.appendChild(micButton)
+      askTools.appendChild(captureRow)
       askTools.appendChild(askSend)
       askRow.appendChild(askBox)
       askRow.appendChild(askTools)
       askRow.appendChild(modelMenu)
+      // 引用区先画一次（空态：data-show="0" 收起），别等第一次 addQuote 才建立初始状态
+      renderQuotes()
       // 「重新生成」不再常驻页脚：只在内容区没有可用结果时出现在正文里
       var retryButton = el('button', 'dsh-sel-retry', '重新生成')
       retryButton.type = 'button'
@@ -1504,6 +2157,8 @@ window.__ModuleLoader__.load({
        * React 组件只负责把 layer 容器挂进浮层；浮标/面板由上面的命令式代码管理，
        * React 不接管它们的子树（容器本身无 children，不会被 diff 清空）。
        */
+      /** 开窗后"还没聚焦过输入框"（见 focusComposerOnce）。 */
+      var askFocusPending = false
       var offSlot = null
       if (ctx.slots && typeof ctx.slots.inject === 'function') {
         try {
@@ -1581,13 +2236,154 @@ window.__ModuleLoader__.load({
         return false
       }
 
+      /**
+       * 这一段选区是不是**小窗正文**里的（可以引用）。
+       *
+       * 往上走到小窗的滚动内容区（body）为止：中途碰到输入框 / 按钮 / 引用卡片本身
+       * 就不算 —— 那些地方的选区要么是输入（textarea），要么引用了也没意义（"✕"这种按钮文字）。
+       * 历史列表、胶囊、模型菜单都在 panel/body 之外，自然被挡掉。
+       * 不用 closest()：无浏览器测试的桩 DOM 没有它，而按祖先链走一遍在两边都一样准。
+       */
+      function insidePanelContent(node) {
+        var current = node && node.nodeType === 3 ? node.parentNode : node
+        for (var depth = 0; current && depth < 32; depth += 1) {
+          if (current === body) return true
+          if (current === panel || current === layer || !panel.contains(current)) return false
+          var tag = String(current.tagName || '').toUpperCase()
+          if (tag === 'TEXTAREA' || tag === 'INPUT' || tag === 'BUTTON' || tag === 'IFRAME') return false
+          var cls = typeof current.className === 'string' ? current.className : ''
+          if (cls.indexOf('dsh-sel-quotes') >= 0) return false
+          current = current.parentNode
+        }
+        return false
+      }
+
+      /**
+       * 「小窗第 N 轮回答 / 提问」。
+       *
+       * 小窗里的引用**不带上下文**（那几轮对话本来就会随历史进模型），所以出处全靠标签说清：
+       * 只写"小窗回答"太笼统 —— 第 1 轮和第 4 轮的回答是两回事。
+       */
+      function turnLabelOf(turn) {
+        if (!turn) return '小窗内容'
+        var index = state.turns.indexOf(turn)
+        var round = 0
+        for (var i = 0; i <= index && i < state.turns.length; i += 1) {
+          if (state.turns[i].role === 'user') round += 1
+        }
+        var role = turn.role === 'user' ? '提问' : '回答'
+        return round > 0 ? '小窗第 ' + round + ' 轮' + role : '小窗' + role
+      }
+
+      /** 小窗正文里这段选区的出处：回答（第 N 轮）/ 某一节 / 顶部选中文字条。 */
+      function panelSourceLabel(node) {
+        var current = node && node.nodeType === 3 ? node.parentNode : node
+        for (var depth = 0; current && depth < 32; depth += 1) {
+          if (current.__turn) return turnLabelOf(current.__turn)
+          // 两节用**它们自己的标题**（标题是「翻译」/「解读」/「注释」，随选中内容变）：
+          // 写死"小窗解读"会在注释节里指错地方
+          if (current === translationSection.root) return '小窗「' + translationSection.title.textContent + '」节'
+          if (current === detailSection.root) return '小窗「' + detailSection.title.textContent + '」节'
+          var cls = typeof current.className === 'string' ? current.className : ''
+          if (cls.indexOf('dsh-sel-quote') === 0) return '小窗顶部的选中文字'
+          if (current === body || current === panel || !current.parentNode) break
+          current = current.parentNode
+        }
+        return '小窗内容'
+      }
+
+      /**
+       * 小窗开着时的选区检查：这时候浮标是「❝ 引用」而不是「✦ 解读」。
+       *
+       * 两种来源都认：
+       *   ① 小窗正文里的选区（回答 / 两节 / 顶部选中文字条）→ 引用的就是小窗自己的内容；
+       *   ② 主界面上的选区 → 引用主界面选中的文字。
+       * 帧内（侧边栏网页）那条不在这里 —— 它由桥的 message 送过来，见 offBridgeMessage。
+       */
+      function checkQuoteSelection() {
+        hideButton() // 小窗开着时不提供「解读」：要解读直接在输入框里问
+        var selection = window.getSelection()
+        if (!selection || selection.rangeCount === 0 || selection.isCollapsed) {
+          // 帧内那条选区还活着（本文档塌陷只是点浮标造成的）→ 留着浮标
+          if (state.bridgeActive && state.selection && state.selection.source === 'iframe') return
+          state.quoteSelection = null
+          hideQuoteButton()
+          return
+        }
+        var range
+        try {
+          range = selection.getRangeAt(0)
+        } catch (error) {
+          return
+        }
+        var text = String(selection.toString() || '')
+        if (!text.trim() || text.length > MAX_QUOTE_SELECTION) {
+          state.quoteSelection = null
+          hideQuoteButton()
+          return
+        }
+        if (insideEditable(range.startContainer)) {
+          state.quoteSelection = null
+          hideQuoteButton()
+          return
+        }
+        var inPanel = insidePanelContent(range.startContainer) || insidePanelContent(range.endContainer)
+        // 小窗里划词：帧内那条让位（两处同时有选区时以本文档为准）
+        state.bridgeActive = false
+        if (!inPanel && (insideOwnUI(range.startContainer) || insideOwnUI(range.endContainer))) {
+          // 历史列表 / 胶囊 / 工具行的选区：引用没有意义，也不该弹浮标
+          state.quoteSelection = null
+          hideQuoteButton()
+          return
+        }
+        var label = inPanel ? panelSourceLabel(range.startContainer) : '主界面选中'
+        var rects = range.getClientRects()
+        var rect = rects && rects.length > 0 ? rects[rects.length - 1] : range.getBoundingClientRect()
+        if (!rect || (rect.width === 0 && rect.height === 0)) {
+          state.quoteSelection = null
+          hideQuoteButton()
+          return
+        }
+        state.quoteSelection = {
+          text: text.trim(),
+          label: label,
+          source: inPanel ? 'panel' : 'document',
+          rect: rect,
+          // 上下文留到**点引用那一刻**才采（每次 selectionchange 都采太贵）：
+          // 这里只记下"在哪一轮上"（小窗）/ 选区本身（主界面，用来采局部窗口）
+          turnIndex: inPanel ? turnIndexOfNode(range.startContainer) : -1,
+          range: inPanel ? null : safeCloneRange(range),
+        }
+        showQuoteButton(rect)
+      }
+
+      /** 克隆选区（桩环境/老浏览器没有 cloneRange 就返回 null，后面走"取不到上下文"那条路）。 */
+      function safeCloneRange(range) {
+        try {
+          return typeof range.cloneRange === 'function' ? range.cloneRange() : null
+        } catch (error) {
+          return null
+        }
+      }
+
       function checkSelection() {
-        if (panelOpen) return
+        if (panelOpen) {
+          checkQuoteSelection()
+          return
+        }
+        hideQuoteButton()
+        state.quoteSelection = null
         var selection = window.getSelection()
         if (!selection || selection.rangeCount === 0 || selection.isCollapsed) {
+          // 侧边栏网页里的选区**不在本文档**：点浮标会让本文档的选区塌掉
+          // （于是每次点浮标都会先跑到这里），所以只要帧内那条选区还活着就别收浮标。
+          // 帧内清空选区时桥会发 clear，那里才是真正的"该收"信号。
+          if (state.bridgeActive && state.selection && state.selection.source === 'iframe') return
           hideButton()
           return
         }
+        // 本文档里出现了真选区：帧内那条让位（两处同时有选区时以本文档为准）
+        state.bridgeActive = false
         // 划到自己界面上（胶囊/面板/历史列表）时什么都不做
         try {
           var ownRange = selection.getRangeAt(0)
@@ -1614,7 +2410,7 @@ window.__ModuleLoader__.load({
           hideButton()
           return
         }
-        state.selection = { text: text.trim(), range: range.cloneRange(), rect: rect }
+        state.selection = { text: text.trim(), range: range.cloneRange(), rect: rect, source: 'document' }
         showButton(rect)
       }
 
@@ -1627,17 +2423,8 @@ window.__ModuleLoader__.load({
       function showButton(rect) {
         // 浮标也在同一套配色下：它的底色是"页面背景"（浮层自身透明），按它判深浅
         if (!panelOpen) layer.setAttribute('data-theme', isDarkSurface(layer) ? 'dark' : 'light')
-        var wasHidden = button.style.display !== 'inline-flex'
-        button.style.display = 'inline-flex'
-        var width = button.offsetWidth || 62
-        var height = button.offsetHeight || 28
-        var left = clamp(rect.right - width, 8, Math.max(8, window.innerWidth - width - 8))
-        var top = rect.top - height - 7
-        if (top < 8) top = Math.min(rect.bottom + 7, window.innerHeight - height - 8)
-        button.style.left = Math.round(left) + 'px'
-        button.style.top = Math.round(top) + 'px'
         // 只在"浮现"那一次播动效；已经可见时（划选范围被拖动、键盘调整）只平移，避免一直闪
-        if (wasHidden) {
+        if (placeFloat(button, rect)) {
           setButtonPop(false)
           void button.offsetWidth // 强制重排，让动画能重播
           setButtonPop(true)
@@ -1649,68 +2436,692 @@ window.__ModuleLoader__.load({
         setButtonPop(false)
       }
 
-      // —— 面板 ——
-
-      /** 当前会话 id（客户端 sessions 快照；取不到就留空，host 会跳过会话背景）。 */
-      function currentSessionId() {
-        try {
-          var sessions = ctx.get('sessions')
-          var store = sessions && sessions.list
-          var snapshot = store && typeof store.getSnapshot === 'function' ? store.getSnapshot() : null
-          var id = snapshot && snapshot.current
-          return id ? String(id) : ''
-        } catch (error) {
-          return ''
-        }
-      }
-
       /**
-       * 缓存 key：选中文字 + 局部上下文片段（空白归一，避免多选/少选一个空格就换 key）。
-       * 注意 key 里**不含**会话背景——本地缓存的作用就是"同一个词再点一次立刻回放"。
+       * 浮标定位（「解读」与「引用」两个浮标共用一套规则）：
+       * 贴选区右下角；上面放不下（贴到视口顶）就翻到选区下方；左右夹回视口内。
+       * 返回"这次是从隐藏变可见" —— 调用方据此决定要不要播浮现动效。
        */
-      function cacheKeyOf(text, context) {
-        return normalizeSpace(text) + '\u0000' + normalizeSpace(context)
+      function placeFloat(node, rect) {
+        var wasHidden = node.style.display !== 'inline-flex'
+        node.style.display = 'inline-flex'
+        var width = node.offsetWidth || 62
+        var height = node.offsetHeight || 28
+        var left = clamp(rect.right - width, 8, Math.max(8, window.innerWidth - width - 8))
+        var top = rect.top - height - 7
+        if (top < 8) top = Math.min(rect.bottom + 7, window.innerHeight - height - 8)
+        node.style.left = Math.round(left) + 'px'
+        node.style.top = Math.round(top) + 'px'
+        return wasHidden
       }
 
-      /** 缓存里有没有"同一个词、但上下文不同"的旧结果（用来解释这次为什么没命中）。 */
-      function hasSameTextElsewhere(text) {
-        var prefix = normalizeSpace(text) + '\u0000'
-        var keys = cache.keys()
-        for (var step = keys.next(); !step.done; step = keys.next()) {
-          if (step.value.indexOf(prefix) === 0) return true
+      function setQuotePop(on) {
+        if (on) quoteButton.setAttribute('data-pop', '1')
+        else quoteButton.removeAttribute('data-pop')
+      }
+
+      function showQuoteButton(rect) {
+        if (placeFloat(quoteButton, rect)) {
+          setQuotePop(false)
+          void quoteButton.offsetWidth
+          setQuotePop(true)
         }
-        return false
       }
 
-      /**
-       * 选中文字是不是**代码**。
-       * 先看容器（<pre>/<code> 直接判代码），容器看不出来再按文本特征打分：
-       * 行首赋值/调用、花括号分号收尾、缩进块、关键字、运算符、注释行……
-       * 阈值刻意偏高——宁可把一段英文当散文，也不要把散文当代码去"逐句注释"。
-       */
-      function looksLikeCode(text) {
-        var t = String(text || '')
-        if (!t.trim()) return false
-        if (t.indexOf('\n') < 0 && t.trim().length < 24) return false // 单个短词几乎不可能是代码块
-        var strong = 0
-        if (/^\s*(?:[\w$.]+\s*[=(]|\}|\{|<[a-zA-Z/!])/m.test(t)) strong += 1
-        if (/\{\s*$|\}\s*$|;\s*$/m.test(t)) strong += 1
-        if (/^\s{2,}\S/m.test(t)) strong += 1
-        if (/\b(function|def|class|import|export|const|let|var|return|async|await|public|private|static|interface|SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|npm|pnpm|yarn|git|docker|curl)\b/.test(t)) strong += 1
-        if (/=>|->|::|!=|===?|\+=|&&|\|\||<\/[a-zA-Z]/.test(t)) strong += 1
-        if (/^\s*(#|\/\/|\/\*|\*|--|<!--)/m.test(t)) strong += 1
-        var lines = t.split('\n').filter(function (line) { return line.trim() })
-        if (strong >= 2) return true
-        return lines.length >= 3 && strong >= 1 && /[{};=()]/.test(t)
+      function hideQuoteButton() {
+        quoteButton.style.display = 'none'
+        setQuotePop(false)
       }
 
-      /** 'code' | 'text'：代码走「注释」，文本走「翻译 / 解读」。 */
-      function selectionKind(text, label) {
-        if (label === '代码块') return 'code'
-        return looksLikeCode(text) ? 'code' : 'text'
+      // ────────────────────── 引用（❝）：把别处的文字挂进输入框 ──────────────────────
+      //
+      // 两个入口，同一份数据（state.quotes）：
+      //   ① 划词浮标「❝ 引用」—— 小窗开着时，小窗正文里的选区 或 主界面上的选区；
+      //   ② 助手气泡末尾的「❝ 引用整条」（鼠标移上去才出现）—— 整条回答，网页回答先折成 Markdown。
+      // 引用只属于**下一条**提问：发送时拼进这条消息，发完清空。
+
+      /** 引用卡片的 id 计数（内容可能重复，DOM 与删除都靠 id 认人）。 */
+      var quoteSeq = 0
+
+      /** 卡片/气泡上的来源小字。 */
+      function quoteLabelOf(quote) {
+        return quote && quote.label ? String(quote.label) : '引用'
       }
 
-      /**
+      /** 卡片/气泡里的单行摘要（完整文本进 title 与发给模型的那份）。 */
+      function quoteBrief(text, max) {
+        var one = String(text || '').replace(/\s+/g, ' ').trim()
+        return one.length > max ? one.slice(0, max) + '…' : one
+      }
+
+      /**
+       * 加一段引用。加不进去也给一句状态 —— 点了浮标"什么都没发生"是最难查的那种观感。
+       * 同一段划两次不再加（引用区是材料清单，不是记事本）；超过 MAX_QUOTES 段也不再加。
+       *
+       * `extra` = { context, session }：引用**当时所在**的上下文（见 quoteContextFor），
+       * session=true 表示"这段文字来自主界面会话"，发送前会再问 host 要一份按轮取整的干净上下文。
+       */
+      function addQuote(text, label, extra) {
+        var clean = String(text || '').replace(/\u00a0/g, ' ').trim()
+        if (!clean) return false
+        var truncated = clean.length > MAX_QUOTE_CHARS
+        if (truncated) clean = clean.slice(0, MAX_QUOTE_CHARS) + '…'
+        for (var i = 0; i < state.quotes.length; i += 1) {
+          if (state.quotes[i].text === clean) {
+            setStatus('这段已经在引用里了')
+            return false
+          }
+        }
+        if (state.quotes.length >= MAX_QUOTES) {
+          setStatus('引用最多 ' + MAX_QUOTES + ' 段，先删掉一条再加')
+          return false
+        }
+        quoteSeq += 1
+        var context = extra && typeof extra.context === 'string' ? extra.context.trim() : ''
+        state.quotes.push({
+          id: quoteSeq,
+          label: label || '引用',
+          text: clean,
+          context: context,
+          session: !!(extra && extra.session === true),
+        })
+        renderQuotes()
+        refreshAskState()
+        // 输入框按阶段本来可能是藏着的（首轮还在跑）：引用一进来就得看得见，顺手聚焦。
+        // 聚焦走**同一个** focusAskBox（preventScroll）：这里是用户主动点引用，
+        // 与"开窗自动聚焦"是两回事，不需要走 askFocusPending 那套"别抢人家打字"的判定。
+        askRow.style.display = ''
+        if (composerVisible()) focusAskBox()
+        setStatus(
+          '已加入引用（' +
+            quoteLabelOf(state.quotes[state.quotes.length - 1]) +
+            ' · ' +
+            clean.length +
+            ' 字' +
+            (truncated ? '（原文更长，已截断）' : '') +
+            (context ? ' · 带上下文 ' + context.length + ' 字' : '') +
+            '）',
+        )
+        return true
+      }
+
+      function removeQuote(id) {
+        var next = []
+        for (var i = 0; i < state.quotes.length; i += 1) {
+          if (state.quotes[i].id !== id) next.push(state.quotes[i])
+        }
+        state.quotes = next
+        renderQuotes()
+        refreshAskState()
+      }
+
+      /** 清空待发送的引用（换了一段选中文字 / 回放了另一条历史 —— 那些引用已经不属于这段对话）。 */
+      function clearQuotes() {
+        if (state.quotes.length === 0) return
+        state.quotes = []
+        renderQuotes()
+        refreshAskState()
+      }
+
+      /** 重画引用区（空的时候整块收起来，不占版面）。 */
+      function renderQuotes() {
+        quotesBox.textContent = ''
+        quotesBox.setAttribute('data-show', state.quotes.length > 0 ? '1' : '0')
+        for (var i = 0; i < state.quotes.length; i += 1) {
+          var quote = state.quotes[i]
+          var chip = el('div', 'dsh-sel-quotechip')
+          chip.setAttribute('data-quote', String(quote.id))
+          chip.appendChild(el('span', 'dsh-sel-quotechip-src', '❝ ' + quoteLabelOf(quote)))
+          var brief = el('span', 'dsh-sel-quotechip-text', quoteBrief(quote.text, 42))
+          brief.title = quote.text
+          chip.appendChild(brief)
+          var remove = el('button', 'dsh-sel-quotechip-x', '✕')
+          remove.type = 'button'
+          remove.title = '移除这条引用'
+          remove.setAttribute('aria-label', '移除这条引用')
+          wireQuoteRemove(remove, quote.id)
+          chip.appendChild(remove)
+          quotesBox.appendChild(chip)
+        }
+      }
+
+      /** 卡片上的 ✕（卡片每次重画，监听跟着节点一起走，不需要单独回收）。 */
+      function wireQuoteRemove(node, id) {
+        listen(node, 'click', function (event) {
+          event.stopPropagation()
+          removeQuote(id)
+        })
+      }
+
+      // ── 引用的上下文：只有"模型看不到的东西"才需要带 ──
+      //
+      //   · 小窗自己的正文（回答 / 两节 / 顶部原文条）：**不带上下文** —— 小窗这几轮对话
+      //     本来就会随 history 进模型，再贴一遍是重复；出处交给标签说清
+      //     （「小窗第 2 轮回答」「小窗「翻译」节」）。
+      //   · 主界面（会话）：带上"引用所在那一组对话 ± 一组"（host 从会话记录里取干净文本）。
+      //   · 侧边栏网页：带上帧内桥采的局部窗口。
+      // 后两条都是模型看不到的材料，所以必须带。
+
+      /** 上下文里有没有引用原文（归一化后包含即可：【】是套在外面的，不影响包含关系）。 */
+      function contextHasQuote(context, text) {
+        var haystack = normalizeSpace(context)
+        var needle = normalizeSpace(text)
+        return needle.length > 0 && haystack.indexOf(needle) >= 0
+      }
+
+      /** 选区落在小窗的哪一轮上（往上找带 __turn 的气泡）；不在气泡里返回 -1。 */
+      function turnIndexOfNode(node) {
+        var current = node && node.nodeType === 3 ? node.parentNode : node
+        for (var depth = 0; current && depth < 32; depth += 1) {
+          if (current.__turn) {
+            var index = state.turns.indexOf(current.__turn)
+            if (index >= 0) return index
+          }
+          if (current === body || !panel.contains(current)) break
+          current = current.parentNode
+        }
+        return -1
+      }
+
+      /**
+       * 点「❝ 引用」那一刻才采上下文（划选过程中每次 selectionchange 都采太贵）。
+       * 会话里的引用（主界面）先用**局部窗口**兜底，发送前再问 host 要按轮取整的干净上下文。
+       */
+      function quoteContextFor(selection) {
+        if (!selection) return { context: '', session: false }
+        if (selection.source === 'panel') {
+          // 小窗正文：不带上文，只靠标签说清"出自哪里"（见 panelSourceLabel）
+          return { context: '', session: false }
+        }
+        if (selection.source === 'iframe') {
+          // 侧边栏网页：帧内的桥已经把上下文采好了（±1500 字窗口，选中部分用【】标出）
+          return { context: String(selection.context || ''), session: false }
+        }
+        var context = String(selection.context || '')
+        if (!context && selection.range) {
+          try {
+            context = collectContext(rangeSelection(selection.range)).context || ''
+          } catch (error) {
+            context = ''
+          }
+        }
+        return { context: context, session: true }
+      }
+
+      /**
+       * 会话里的引用：向 host 要"引用所在那一组对话 ± 一组"（干净文本只有 host 那边有：
+       * 工具调用/结果、系统提示、harness 注入在 `transcriptOf` 那套规则里已经滤掉了）。
+       * 拿不到（引用不在会话里 / host 不认 / 超时）就保留客户端自己采的那份，不阻塞发送。
+       */
+      function resolveQuoteContexts(quotes) {
+        var jobs = []
+        for (var i = 0; i < quotes.length; i += 1) {
+          if (quotes[i].session === true) jobs.push(quotes[i])
+        }
+        var sessionId = currentSessionId()
+        if (jobs.length === 0 || !sessionId) return Promise.resolve(quotes)
+        return Promise.all(
+          jobs.map(function (quote) {
+            return fetchQuoteContext(sessionId, quote.text).then(function (context) {
+              if (context) quote.context = context
+              return quote
+            })
+          }),
+        ).then(function () {
+          return quotes
+        })
+      }
+
+      /** 取一次会话版引用上下文（带超时；失败一律返回空串走兜底）。 */
+      function fetchQuoteContext(sessionId, text) {
+        var controller = typeof AbortController === 'function' ? new AbortController() : null
+        var timer = setTimeout(function () {
+          if (controller) {
+            try {
+              controller.abort()
+            } catch (error) {
+              /* noop */
+            }
+          }
+        }, QUOTE_CONTEXT_TIMEOUT)
+        timers.push(timer)
+        return fetch(QUOTE_CONTEXT_API, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ sessionId: sessionId, text: text }),
+          ...(controller ? { signal: controller.signal } : {}),
+        })
+          .then(function (response) {
+            return response.ok ? response.json() : null
+          })
+          .then(function (data) {
+            clearTimeout(timer)
+            if (data && data.ok === true && data.matched === true && typeof data.context === 'string') return data.context
+            return ''
+          })
+          .catch(function () {
+            clearTimeout(timer)
+            return ''
+          })
+      }
+
+      /**
+       * 引用 + 提问 → **真正发给模型**的那条消息。
+       *
+       * 拼在客户端而不是 host：引用本来就是"用户这条消息的一部分"，拼好之后
+       * 追问上下文、历史回放、升格全都天然带着它，host 只负责**给上下文**（那条路由）。
+       * 没有引用时**原样返回提问** —— 老路径一个字都不变。
+       *
+       * 每段引用固定给：来源 + 【引用处上下文】（被引用的部分用【】标出）。
+       * 上下文里没带上原文时（被截断、或标记失败）再补一段【引用原文】——
+       * 绝不让模型去猜"引的是哪句"。
+       */
+      function composeQuestion(quotes, question) {
+        var ask = String(question || '').trim()
+        var list = quotes || []
+        if (list.length === 0) return ask
+        var lines = []
+        for (var i = 0; i < list.length; i += 1) {
+          var quote = list[i]
+          var context = String(quote.context || '').trim()
+          lines.push('【引用 ' + (i + 1) + '】（来自' + quoteLabelOf(quote) + '）')
+          if (context) {
+            lines.push('【引用处上下文】（被引用的部分用【】标出）')
+            lines.push(context)
+            if (!contextHasQuote(context, quote.text)) {
+              lines.push('')
+              lines.push('【引用原文】')
+              lines.push(quote.text)
+            }
+          } else {
+            lines.push(quote.text)
+          }
+          lines.push('')
+        }
+        lines.push('【我的问题】')
+        lines.push(ask || QUOTE_ONLY_QUESTION)
+        return lines.join('\n')
+      }
+
+      /** 某一轮"实际发出去"的文本：用户那轮带引用块，助手轮就是正文。 */
+      function sentTextOf(turn) {
+        if (!turn) return ''
+        if (turn.role === 'user') return turn.sent || turn.text || ''
+        return turn.text || ''
+      }
+
+      /** 导出给 host 的轮次（历史落盘 / 升格）：用户那轮把引用块一起带走。 */
+      function exportTurns() {
+        var out = []
+        for (var i = 0; i < state.turns.length; i += 1) {
+          out.push({ role: state.turns[i].role, text: sentTextOf(state.turns[i]) })
+        }
+        return out
+      }
+
+      // —— 侧边栏网页（iframe）划词桥的父侧接线 ——
+
+      /**
+       * 我们桥过的帧：frame → 自己建的 blob url（'' = srcdoc 帧，没有 blob 要回收）。
+       * 用 Map 而不是数组：既要按帧查自己的 url，也要遍历找回消息来源对应的帧。
+       */
+      var bridged = new Map()
+      /** 总开关：host 的 bridgeSidebarPreview 说关就关（见下面 ping 分支）。 */
+      var bridgeOn = true
+      /** 扫描节流用的定时器 id。 */
+      var bridgeScanId = 0
+      var bridgeObserver = null
+
+      function ownedUrl(frame) {
+        var url = bridged.get(frame)
+        return url === undefined ? '' : url
+      }
+
+      /** 消息来源 → 帧（只认我们桥过的帧，别的窗口发来的消息一概不理）。 */
+      function frameBySource(source) {
+        var found = null
+        bridged.forEach(function (url, frame) {
+          if (found) return
+          try {
+            if (frame.contentWindow && frame.contentWindow === source) found = frame
+          } catch (error) {
+            /* 跨源取 contentWindow 可能抛，忽略 */
+          }
+        })
+        return found
+      }
+
+      /** 沙箱补一个 allow-scripts（**绝不补 allow-same-origin**）：桥要跑起来。 */
+      function ensureScriptsAllowed(frame) {
+        var sandbox = frame.getAttribute('sandbox')
+        if (sandbox === null) return // 没有 sandbox 属性 = 同源帧，不归这条路管
+        if (!/(^|\s)allow-scripts(\s|$)/.test(sandbox)) {
+          frame.setAttribute('sandbox', (sandbox + ' allow-scripts').trim())
+        }
+      }
+
+      /** 帧内坐标 → 视口坐标；选区滚出帧的可视区就返回 null（免得浮标飘到主会话上）。 */
+      function mapFrameRect(frame, reported) {
+        if (!reported) return null
+        var box
+        try {
+          box = frame.getBoundingClientRect()
+        } catch (error) {
+          return null
+        }
+        if (!box || (!box.width && !box.height)) return null
+        var left = box.left + Number(reported.x || 0)
+        var top = box.top + Number(reported.y || 0)
+        var right = box.left + Number(reported.right || 0)
+        var bottom = box.top + Number(reported.bottom || 0)
+        if (!(right > left)) right = left + Number(reported.w || 0)
+        if (!(bottom > top)) bottom = top + Number(reported.h || 0)
+        if (bottom < box.top + 2 || top > box.bottom - 2) return null
+        top = clamp(top, box.top, box.bottom)
+        bottom = clamp(bottom, box.top, box.bottom)
+        left = clamp(left, box.left, box.right)
+        right = clamp(right, box.left, box.right)
+        return {
+          left: left,
+          top: top,
+          right: right,
+          bottom: bottom,
+          width: Math.max(0, right - left),
+          height: Math.max(0, bottom - top),
+        }
+      }
+
+      /** 面板里的位置标签：帧内认出来的（代码块/表格）优先，否则按帧的来源给。 */
+      function labelForFrame(frame, frameLabel) {
+        if (frameLabel === '代码块' || frameLabel === '表格') return frameLabel
+        if (frame.getAttribute('data-html-preview') !== null) return '侧边栏网页'
+        // 其他插件的网页（例如「图解」）：用帧自己的 title 当位置标签，比笼统的"网页内容"有用
+        var title = String(frame.getAttribute('title') || '')
+          .replace(/\s+/g, ' ')
+          .trim()
+        return title ? title.slice(0, 24) : '网页内容'
+      }
+
+      /**
+       * 这一帧能不能桥。
+       *
+       * 只认"文档确实是我们能改写的那两种"：`srcdoc` 或 `blob:` —— 远端站点 iframe 与
+       * 路由 URL 的预览器（如 better-sidebar 的 HTML 预览）一概不动，它们的资源改写
+       * 与生命周期归它们自己。
+       *
+       * 沙箱上分两档，因为"补 allow-scripts"是有代价的：
+       *   · 宿主自己的 HTML 预览（`data-html-preview`）：内容已由宿主 DOMPurify 清洗成
+       *     "无脚本、无外链"，补 allow-scripts 之后真正会跑的只有桥自己，可以补；
+       *   · 其他插件的网页（如「图解」的 `blob:` 帧）：**只桥本来就允许脚本的**——
+       *     不给别人的沙箱加权限，免得把一份刻意不跑脚本的文档变成会跑脚本。
+       */
+      function bridgeableFrame(frame) {
+        if (!frame || frame.nodeType !== 1 || !frame.isConnected) return false
+        if (panel.contains(frame)) return false // 我们自己的小窗（含网页答案预览）不桥
+        var hasSrcdoc = frame.getAttribute('srcdoc') !== null
+        var src = frame.getAttribute('src') || ''
+        if (!hasSrcdoc && !/^blob:/i.test(src)) return false
+        var sandbox = frame.getAttribute('sandbox')
+        if (sandbox === null) return false
+        if (frame.getAttribute('data-html-preview') !== null) return true
+        return /(^|\s)allow-scripts(\s|$)/.test(sandbox)
+      }
+
+      function bridgeFrame(frame) {
+        if (!bridgeOn || !bridgeableFrame(frame)) return
+        var srcdoc = frame.getAttribute('srcdoc')
+        if (srcdoc !== null && srcdoc !== undefined) {
+          if (srcdoc.indexOf(BRIDGE_MARK) >= 0) return // 已经桥过（我们自己写回去的那份）
+          var next = bridgeIntoHtml(srcdoc)
+          if (!next) return
+          // 顺序有讲究（Chrome 153 实测）：**先补沙箱、再改 srcdoc，且必须在同一个任务里**。
+          // 先改 srcdoc 再补沙箱、或者分两个任务改，帧都不会带着 allow-scripts 重新加载
+          // （脚本静默不跑，表现为"注入了但没反应"）。
+          ensureScriptsAllowed(frame)
+          frame.setAttribute('data-dsh-sel-bridged', '1')
+          frame.setAttribute('srcdoc', next)
+          bridged.set(frame, '')
+          return
+        }
+        var src = frame.getAttribute('src') || ''
+        // 只动 blob:（宿主与「图解」这类插件都是用它装生成页的）。
+        // 路由 URL / 远端地址一概不碰：那些的资源改写与生命周期归宿主，插手只会弄坏预览。
+        if (!/^blob:/i.test(src)) return
+        if (src === ownedUrl(frame)) return // 已经是我们换上去的那份
+        fetch(src)
+          .then(function (response) {
+            // 原 blob 的 MIME **要跟着搬**：blob: 文档没有"父文档编码"可继承，
+            // 编码只来自这个 content-type（或页面里的 meta）。「图解」建 blob 时写的是
+            // `text/html;charset=utf-8`，我们若退回裸 `text/html`，页面又没写 meta charset 的话，
+            // 整页中文会变成乱码（实测过：`鍥捐В椤?`）。
+            var type = 'text/html'
+            try {
+              var header = response.headers && response.headers.get && response.headers.get('content-type')
+              if (header) type = header
+            } catch (error) {
+              /* 取不到就退回 text/html：与原行为一致 */
+            }
+            return response.text().then(function (text) {
+              return { text: text, type: type }
+            })
+          })
+          .then(function (loaded) {
+            if (!bridgeOn || !frame.isConnected) return
+            var bridgedHtml = bridgeIntoHtml(loaded.text)
+            if (!bridgedHtml) return
+            var url = URL.createObjectURL(new Blob([bridgedHtml], { type: loaded.type }))
+            var previous = ownedUrl(frame)
+            bridged.set(frame, url)
+            ensureScriptsAllowed(frame)
+            frame.setAttribute('data-dsh-sel-bridged', '1')
+            frame.setAttribute('src', url)
+            if (previous) {
+              try {
+                URL.revokeObjectURL(previous)
+              } catch (error) {
+                /* 回收失败不致命 */
+              }
+            }
+          })
+          .catch(function () {
+            /* 读不到就放着：原预览照常显示，只是这一帧没有划词桥 */
+          })
+      }
+
+      /** 帧没了（关标签页/切源码视图）就顺手回收我们自己建的 blob，别漏。 */
+      function pruneBridged() {
+        var dead = []
+        bridged.forEach(function (url, frame) {
+          if (!frame.isConnected) dead.push(frame)
+        })
+        for (var i = 0; i < dead.length; i += 1) {
+          var url = bridged.get(dead[i])
+          if (url) {
+            try {
+              URL.revokeObjectURL(url)
+            } catch (error) {
+              /* 回收失败不致命 */
+            }
+          }
+          // 帧没了就不会再有 clear 消息了：把它占着的那条选区一起清掉，
+          // 否则 `bridgeActive` 会一直挂着（表现为顶层选区塌掉也不收浮标）。
+          if (state.selection && state.selection.frame === dead[i]) {
+            state.selection = null
+            state.bridgeActive = false
+            hideButton()
+          }
+          bridged.delete(dead[i])
+        }
+      }
+
+      function scanPreviewFrames() {
+        if (!bridgeOn) return
+        // 无浏览器测试的桩 DOM 没有 querySelectorAll：桥整体静默跳过
+        if (typeof document.querySelectorAll !== 'function') return
+        pruneBridged()
+        // 扫全部 iframe 再按 bridgeableFrame 过滤：宿主的 HTML 预览、以及别的插件
+        // 在侧边栏渲染的生成网页（「图解」那种 blob: 帧）都在这条路上，
+        // 不能只看宿主的 data-html-preview 标记。
+        var frames = document.querySelectorAll('iframe')
+        for (var i = 0; i < frames.length; i += 1) bridgeFrame(frames[i])
+      }
+
+      function scheduleBridgeScan() {
+        if (bridgeScanId) return
+        bridgeScanId = later(function () {
+          bridgeScanId = 0
+          scanPreviewFrames()
+        }, 120)
+      }
+
+      /**
+       * 帧内桥报过来的选区：换算坐标 → 复用同一套浮标与面板。
+       *
+       * 只认"我们桥过的帧"发来的消息（`frameBySource`）。
+       * 小窗开着时它走**引用**那条路（划侧边栏网页里的文字，同样能挂进输入框）；
+       * 小窗关着时才是「✦ 解读」（要划新词开新窗，先按 Esc 收起当前这扇）。
+       */
+      var offBridgeMessage = listen(window, 'message', function (event) {
+        var data = event && event.data
+        if (!data || data.__dshSel !== 1) return
+        var frame = frameBySource(event.source)
+        if (!frame) return
+        if (data.kind === 'press') {
+          // 帧内按下：与主会话一致——先收浮标。父页面收不到帧内的 mousedown，
+          // 少了这一条，在网页里点一下（取消选区、点别处、点另一个网页）浮标就赖着不走。
+          if (state.selection && state.selection.source === 'iframe' && state.selection.frame !== frame) {
+            // 点的是**另一个**帧：那条选区已经不是用户此刻在看的了，连状态一起清
+            state.selection = null
+            state.bridgeActive = false
+          }
+          hideButton()
+          hideQuoteButton()
+          return
+        }
+        if (data.kind === 'clear') {
+          if (state.selection && state.selection.frame === frame) {
+            state.selection = null
+            state.bridgeActive = false
+            hideButton()
+            hideQuoteButton()
+          }
+          return
+        }
+        if (data.kind !== 'selection' || !data.sel) return
+        if (!frame.isConnected) return
+        var text = String(data.sel.text || '')
+        if (!text.trim() || text.length > MAX_SELECTION) return
+        var rect = mapFrameRect(frame, data.sel.rect)
+        if (!rect) {
+          // 选区滚出帧的可视区：把浮标收掉（帧内再滚回来会重新报）
+          if (state.selection && state.selection.frame === frame) {
+            hideButton()
+            hideQuoteButton()
+          }
+          return
+        }
+        state.selection = {
+          text: text.trim(),
+          /** 'document'（顶层选区，缺省）| 'iframe'（侧边栏网页，上下文由帧内桥给）。 */
+          source: 'iframe',
+          frame: frame,
+          rect: rect,
+          frameRect: data.sel.rect,
+          context: String(data.sel.context || ''),
+          keyContext: String(data.sel.keyContext || ''),
+          label: labelForFrame(frame, data.sel.label),
+        }
+        state.bridgeActive = true
+        if (panelOpen) {
+          // 小窗开着：帧内这条选区也只是"一段可以引用的文字"（上下文由帧内的桥给）
+          state.quoteSelection = {
+            text: text.trim(),
+            label: state.selection.label || '侧边栏网页',
+            source: 'iframe',
+            rect: rect,
+            context: String(state.selection.context || ''),
+            turnIndex: -1,
+          }
+          showQuoteButton(rect)
+          return
+        }
+        showButton(rect)
+      })
+
+      // 侧边栏里的预览帧是宿主 React 渲染的：新开标签、切预览/源码、文件变了都会换帧，
+      // 所以既要初始扫一遍，也要盯着 DOM（只盯 srcdoc/src 两个属性 + 子节点增删）。
+      if (typeof MutationObserver === 'function') {
+        bridgeObserver = new MutationObserver(scheduleBridgeScan)
+        bridgeObserver.observe(document.body || document.documentElement, {
+          childList: true,
+          subtree: true,
+          attributes: true,
+          attributeFilter: ['srcdoc', 'src'],
+        })
+      }
+      scheduleBridgeScan()
+
+      // —— 面板 ——
+
+      /** 当前会话 id（客户端 sessions 快照；取不到就留空，host 会跳过会话背景）。 */
+      function currentSessionId() {
+        try {
+          var sessions = ctx.get('sessions')
+          var store = sessions && sessions.list
+          var snapshot = store && typeof store.getSnapshot === 'function' ? store.getSnapshot() : null
+          var id = snapshot && snapshot.current
+          return id ? String(id) : ''
+        } catch (error) {
+          return ''
+        }
+      }
+
+      /**
+       * 缓存 key：选中文字 + 局部上下文片段（空白归一，避免多选/少选一个空格就换 key）。
+       * 注意 key 里**不含**会话背景——本地缓存的作用就是"同一个词再点一次立刻回放"。
+       */
+      function cacheKeyOf(text, context) {
+        return normalizeSpace(text) + '\u0000' + normalizeSpace(context)
+      }
+
+      /** 缓存里有没有"同一个词、但上下文不同"的旧结果（用来解释这次为什么没命中）。 */
+      function hasSameTextElsewhere(text) {
+        var prefix = normalizeSpace(text) + '\u0000'
+        var keys = cache.keys()
+        for (var step = keys.next(); !step.done; step = keys.next()) {
+          if (step.value.indexOf(prefix) === 0) return true
+        }
+        return false
+      }
+
+      /**
+       * 选中文字是不是**代码**。
+       * 先看容器（<pre>/<code> 直接判代码），容器看不出来再按文本特征打分：
+       * 行首赋值/调用、花括号分号收尾、缩进块、关键字、运算符、注释行……
+       * 阈值刻意偏高——宁可把一段英文当散文，也不要把散文当代码去"逐句注释"。
+       */
+      function looksLikeCode(text) {
+        var t = String(text || '')
+        if (!t.trim()) return false
+        if (t.indexOf('\n') < 0 && t.trim().length < 24) return false // 单个短词几乎不可能是代码块
+        var strong = 0
+        if (/^\s*(?:[\w$.]+\s*[=(]|\}|\{|<[a-zA-Z/!])/m.test(t)) strong += 1
+        if (/\{\s*$|\}\s*$|;\s*$/m.test(t)) strong += 1
+        if (/^\s{2,}\S/m.test(t)) strong += 1
+        if (/\b(function|def|class|import|export|const|let|var|return|async|await|public|private|static|interface|SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|npm|pnpm|yarn|git|docker|curl)\b/.test(t)) strong += 1
+        if (/=>|->|::|!=|===?|\+=|&&|\|\||<\/[a-zA-Z]/.test(t)) strong += 1
+        if (/^\s*(#|\/\/|\/\*|\*|--|<!--)/m.test(t)) strong += 1
+        var lines = t.split('\n').filter(function (line) { return line.trim() })
+        if (strong >= 2) return true
+        return lines.length >= 3 && strong >= 1 && /[{};=()]/.test(t)
+      }
+
+      /** 'code' | 'text'：代码走「注释」，文本走「翻译 / 解读」。 */
+      function selectionKind(text, label) {
+        if (label === '代码块') return 'code'
+        return looksLikeCode(text) ? 'code' : 'text'
+      }
+
+      /**
        * 选中文字里有没有"需要翻译的英文"（拉丁字母组成的词/句）。
        * 决定了第一节的标题：有英文 → 「翻译」，纯中文 → 「解读」（纯汉字不翻译）。
        * 规则要和 host 侧提示词一致：至少两个连续拉丁字母才算。
@@ -1745,6 +3156,11 @@ window.__ModuleLoader__.load({
       }
 
       function openForSelection(selection) {
+        // 侧边栏网页里的选区：父页面读不到那个文档，上下文只能由帧内桥就地采好带过来
+        if (selection.source === 'iframe') {
+          openPanelWith(selection.text, selection.context || '', selection.label, selection.rect, selection.keyContext)
+          return
+        }
         var contextInfo = collectContext(selection.range ? rangeSelection(selection.range) : window.getSelection())
         openPanelWith(selection.text, contextInfo.context, contextInfo.label, selection.rect, contextInfo.keyContext)
       }
@@ -1765,6 +3181,8 @@ window.__ModuleLoader__.load({
         var cached = cache.get(cacheKey)
         state.cacheKey = cacheKey
         state.turns = []
+        // 换了一段选中文字 = 换了一次对话：上一段攒的引用不该跟过来
+        clearQuotes()
         state.parts = (cached && cached.parts) || { translation: '', detail: '' }
         state.stage = ''
         state.raw = ''
@@ -2036,9 +3454,17 @@ window.__ModuleLoader__.load({
 
       function showPanel(anchor) {
         panelOpen = true
+        // 键盘用户开窗即可打字：这一轮的输入框一旦可见就聚焦一次（见 focusComposerOnce）
+        askFocusPending = true
+        // 小窗一开，浮标就换成「❝ 引用」那一套（解读浮标收掉，引用浮标等新选区）
+        hideButton()
+        hideQuoteButton()
+        state.quoteSelection = null
         panel.style.display = 'flex'
         panel.style.left = '0px'
         panel.style.top = '0px'
+        // 面板刚显示出来才量得到 scrollHeight：草稿里原来的几行要立刻撑开
+        autoGrowAskBox()
         var width = panel.offsetWidth
         var height = panel.offsetHeight
         var left = anchor ? anchor.left : window.innerWidth / 2 - width / 2
@@ -2057,6 +3483,12 @@ window.__ModuleLoader__.load({
         panelOpen = false
         panel.style.display = 'none'
         hideHistoryList()
+        // 小窗收起来了：引用浮标跟着走（它只在"小窗开着"时有意义）
+        hideQuoteButton()
+        state.quoteSelection = null
+        // 正在录音/识别就到此为止：麦**一定要松开**（不能让标签页一直显示"正在使用麦克风"），
+        // 识别出来的文字也没地方放了 —— 连同提示一起静默收掉。
+        cancelVoice()
         // 收起小窗不该被记成"失败"：打个标记，让 fail() 走「已停止」而不是「解读失败」
         if (state.request) state.aborted = true
         if (state.request) state.request.abort()
@@ -2190,7 +3622,7 @@ window.__ModuleLoader__.load({
         // 配色按**面板实际底色**选（不看系统偏好）：主题实现方式怎么变都不影响
         layer.setAttribute('data-theme', isDarkSurface(panel) ? 'dark' : 'light')
         panel.setAttribute('data-theme', isDarkSurface(panel) ? 'dark' : 'light')
-        askRow.style.display = wide || translationReady ? '' : 'none'
+        askRow.style.display = wide || translationReady || state.quotes.length > 0 ? '' : 'none'
         // 展开 CTA：翻译还在跑（含思考期）时先不出现——那时候该看的是等待特效，
         // 摆在下面只会是个灰着的按钮，反而像"没反应"；发过追问之后也收起（见 syncExpandCta）。
         syncExpandCta()
@@ -2238,36 +3670,115 @@ window.__ModuleLoader__.load({
         refreshAskState()
         paintPill()
         keepInsideViewport()
-      }
-
-      /** 内容变高后把面板拉回视口内。 */
-      function keepInsideViewport() {
-        if (!panelOpen) return
-        var rect = panel.getBoundingClientRect()
-        var width = Math.min(rect.width, window.innerWidth - 12)
-        var left = clamp(rect.left, 6, Math.max(6, window.innerWidth - width - 6))
-        var top = clamp(rect.top, 6, Math.max(6, window.innerHeight - 64))
-        panel.style.left = Math.round(left) + 'px'
-        panel.style.top = Math.round(top) + 'px'
+        focusComposerOnce()
       }
 
       /**
-       * 剥掉模型伪造的工具调用残渣。
+       * 开窗后**只聚焦一次**输入框（键盘用户不用先 Tab 两下）。
        *
-       * 没有工具可用时，模型会照着自己的习惯把调用"写"成正文（实测见过
-       * `<ds_safety_tool_call><tool_name>web_search</tool_name>…` 整段喷出来）。
-       * 这里在**渲染时**清理（不改 state.raw，流式期间半截标签也不会丢内容）。
+       * 三个克制的地方：
+       *   · 等输入框真的可见才聚焦（首轮翻译还在跑时它是藏着的，聚焦藏着的元素没意义）；
+       *   · 用户已经在别处打字（主会话输入框、侧边栏…）就**不抢**焦点，并就此作罢；
+       *   · preventScroll：别因为聚焦把页面滚一下（划完词页面跳走最难受）。
        */
-      /**
-       * ── 历史折叠 ──────────────────────────────────────────────────────────
-       * 追问时历史是"原文逐字带上"，于是整页 HTML（实测 8k 字 ≈ 2,150 tokens）
-       * 会在之后**每一轮**重发一次，还占掉 20 条窗口里的位置。
-       *
-       * 这里把它折叠成**结构化 Markdown**（标题/表格行列/列表/强调/代码都保留，
-       * 只丢 <style>、class、内联 style、SVG 路径这些"渲染实现细节"），
-       * 实测：8,021 字 → 1,146 字，可见文本覆盖率 100.0%，≈2,150 → ≈860 tokens。
-       *
-       * 三条边界：
+      function focusComposerOnce() {
+        if (!askFocusPending || !panelOpen) return
+        if (!composerVisible()) return
+        // 小窗里正有一段选中文字（用户正在划词、准备点「❝ 引用」）：**这一下聚焦会把选区清掉**。
+        // 让位给用户，并且不再补焦 —— 引用浮标是这个功能的主入口，不能因为抢焦点而让它消失。
+        //（实测：开窗后那一帧恰好落在"首轮刚出完"的自动聚焦上，划好的词会瞬间没了。）
+        if (hasPanelSelection()) {
+          askFocusPending = false
+          return
+        }
+        var active = document.activeElement
+        var inside = active && (active === panel || active === askBox || (panel.contains && panel.contains(active)))
+        // 只有"人家正在别处打字"才值得让路。
+        // 注意别把普通的按钮焦点也算进去：点浮标时焦点正好落在浮标那个 <button> 上
+        //（Chrome 点按钮会给它焦点），照"非 body 就不抢"的老写法会把我们自己挡在门外 ——
+        // 这正是"开窗后没有自动聚焦"的原因。
+        if (!inside && isTypingTarget(active)) {
+          askFocusPending = false // 人家真的在别处打字，这次开窗就不再抢
+          return
+        }
+        askFocusPending = false
+        focusAskBox()
+      }
+
+      /** 小窗正文里这会儿有没有一段活选区（划词中/选好了还没点引用）。 */
+      function hasPanelSelection() {
+        try {
+          var selection = window.getSelection && window.getSelection()
+          if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return false
+          var range = selection.getRangeAt(0)
+          return insidePanelContent(range.startContainer) || insidePanelContent(range.endContainer)
+        } catch (error) {
+          return false
+        }
+      }
+
+      /** 正在打字的地方（input / textarea / 可编辑区）—— 只有这种焦点值得让路。 */
+      function isTypingTarget(node) {
+        if (!node || node === askBox) return false
+        var tag = String(node.tagName || '').toLowerCase()
+        if (tag === 'input' || tag === 'textarea' || tag === 'select') return true
+        return node.isContentEditable === true
+      }
+
+      /** 把光标交给输入框（preventScroll：别因为聚焦把页面滚一下）。 */
+      function focusAskBox() {
+        try {
+          askBox.focus({ preventScroll: true })
+        } catch (error) {
+          try {
+            askBox.focus()
+          } catch (ignored) {
+            /* 桩环境 */
+          }
+        }
+      }
+
+      /** 输入框这会儿真的看得见吗（藏着的元素聚焦没有意义）。 */
+      function composerVisible() {
+        if (!askRow || askRow.style.display === 'none') return false
+        if (typeof askBox.getBoundingClientRect !== 'function') return true
+        try {
+          var rect = askBox.getBoundingClientRect()
+          if (rect && rect.width === 0 && rect.height === 0) return false
+        } catch (error) {
+          /* noop */
+        }
+        return true
+      }
+
+      /** 内容变高后把面板拉回视口内。 */
+      function keepInsideViewport() {
+        if (!panelOpen) return
+        var rect = panel.getBoundingClientRect()
+        var width = Math.min(rect.width, window.innerWidth - 12)
+        var left = clamp(rect.left, 6, Math.max(6, window.innerWidth - width - 6))
+        var top = clamp(rect.top, 6, Math.max(6, window.innerHeight - 64))
+        panel.style.left = Math.round(left) + 'px'
+        panel.style.top = Math.round(top) + 'px'
+      }
+
+      /**
+       * 剥掉模型伪造的工具调用残渣。
+       *
+       * 没有工具可用时，模型会照着自己的习惯把调用"写"成正文（实测见过
+       * `<ds_safety_tool_call><tool_name>web_search</tool_name>…` 整段喷出来）。
+       * 这里在**渲染时**清理（不改 state.raw，流式期间半截标签也不会丢内容）。
+       */
+      /**
+       * ── 历史折叠 ──────────────────────────────────────────────────────────
+       * 追问时历史是"原文逐字带上"，于是整页 HTML（实测 8k 字 ≈ 2,150 tokens）
+       * 会在之后**每一轮**重发一次，还占掉 20 条窗口里的位置。
+       *
+       * 这里把它折叠成**结构化 Markdown**（标题/表格行列/列表/强调/代码都保留，
+       * 只丢 <style>、class、内联 style、SVG 路径这些"渲染实现细节"），
+       * 实测：8,021 字 → 1,146 字，可见文本覆盖率 100.0%，≈2,150 → ≈860 tokens。
+       *
+       * 三条边界：
        *   ① 只作用于**发历史**这一步 —— 面板里渲染的、代码视图复制的永远是原文；
        *   ② 折一次就缓存在那一轮（`turn.foldedCache`），之后每轮直接复用，不重折；
        *   ③ **最近一轮保持原样** —— 用户说"把上一页的高亮改成蓝色"时仍能改到版式。
@@ -2596,6 +4107,9 @@ window.__ModuleLoader__.load({
        */
       function historyTextOf(turn, keepRaw) {
         if (!turn) return ''
+        // 用户那轮：发出去的是什么就带回什么（带引用时是拼好的那份，见 composeQuestion）。
+        // 引用块必须进历史 —— 否则下一轮模型只看到"上面那段呢？"，而"那段"已经在上下文里消失了。
+        if (turn.role === 'user') return sentTextOf(turn)
         if (keepRaw) return turn.text
         if (typeof turn.foldedCache === 'string') return turn.foldedCache
         if (turn.streaming === true) return turn.text
@@ -2658,10 +4172,12 @@ window.__ModuleLoader__.load({
         var payload = state.payload
         if (!payload || !state.cacheKey) return
         var turns = []
+        var exported = exportTurns()
         for (var i = 0; i < state.turns.length; i += 1) {
           var turn = state.turns[i]
           if (turn.hidden === true) continue
-          turns.push({ role: turn.role, text: turn.text || '' })
+          // 落盘的是"实际发出去的那份"（用户那轮带引用块）：回放出来时这轮对话是自洽的
+          turns.push(exported[i])
         }
         try {
           fetch(HISTORY, {
@@ -2690,6 +4206,8 @@ window.__ModuleLoader__.load({
         var parts = entry.parts || {}
         state.parts = { translation: parts.translation || '', detail: parts.detail || '' }
         state.turns = Array.isArray(entry.turns) ? entry.turns.slice() : []
+        // 回放的是**另一段**对话：输入框里攒的引用跟着清掉
+        clearQuotes()
         state.toolDigest = typeof entry.toolDigest === 'string' ? entry.toolDigest : ''
         state.cacheKey = entry.key
         state.payload = buildPayload(entry.text, entry.context, entry.label)
@@ -3114,7 +4632,12 @@ window.__ModuleLoader__.load({
         if (chatLog.children.length !== visible.length) {
           clearWaiting(chatLog)
           chatLog.textContent = ''
-          for (var j = 0; j < visible.length; j++) chatLog.appendChild(bubbleFor(visible[j]))
+          for (var j = 0; j < visible.length; j++) {
+            var bubble = bubbleFor(visible[j])
+            // 气泡记下自己属于哪一轮：引用时要据此取"这一轮 ± 一轮"的上下文
+            bubble.__turn = visible[j]
+            chatLog.appendChild(bubble)
+          }
           // 刚入列的"待答"气泡：此时才挂进 DOM，可以画等待特效了
           var fresh = visible[visible.length - 1]
           if (fresh && fresh.role === 'assistant' && fresh.asking === true && !fresh.text) {
@@ -3130,7 +4653,14 @@ window.__ModuleLoader__.load({
           var turn = visible[visible.length - 1]
           var painted = false
           node.className = 'dsh-sel-bubble ' + (turn.role === 'user' ? 'dsh-sel-bubble-user' : 'dsh-sel-bubble-bot') + (turn.error ? ' dsh-sel-bubble-err' : '')
-          if (turn.role === 'user' || turn.error) {
+          if (turn.role === 'user') {
+            // 用户气泡可能带引用块：签名包含引用，别每次重绘都白重建一遍
+            var usig = (turn.text || '') + '|' + (turn.quotes || []).map(function (item) { return item.text }).join('\u0000')
+            if (node.__sig !== usig) {
+              node.__sig = usig
+              fillUserBubble(node, turn)
+            }
+          } else if (turn.error) {
             node.textContent = turn.text
           } else if (turn.asking === true && !turn.text) {
             // 追问等待期：和首轮同一套等待特效（呼吸点 + 实时秒数 + 💭 思考尾巴）
@@ -3150,9 +4680,11 @@ window.__ModuleLoader__.load({
               renderRich(node, sanitizeToolResidue(turn.text) || '…', { settled: turn.streaming !== true })
             }
             paintNotice(node, turn)
+            paintQuoteAll(node, turn)
             painted = true
           }
           if (!painted && turn.role !== 'user') paintNotice(node, turn)
+          if (!painted && turn.role !== 'user') paintQuoteAll(node, turn)
         }
         // 可见性必须在这里定：追问路径只调 renderTurns()，不会触发 paint()，
         // 之前把它挪进 paint() 导致"发送后气泡画进了 display:none 的容器里，小窗没反应"
@@ -3178,20 +4710,83 @@ window.__ModuleLoader__.load({
         existing.textContent = text
       }
 
+      /**
+       * 用户气泡：有引用时**先画引用块、再画问题**（和发给模型的那份顺序一致）。
+       * 只写 textContent 的话引用就看不见了 —— 模型答的是"上面那段"，
+       * 而"上面那段"在气泡里根本不存在，回头看会一头雾水。
+       */
+      function fillUserBubble(node, turn) {
+        node.textContent = ''
+        var quotes = turn.quotes || []
+        if (quotes.length > 0) {
+          var box = el('div', 'dsh-sel-bq')
+          for (var i = 0; i < quotes.length; i += 1) {
+            var item = el('div', 'dsh-sel-bqitem')
+            item.appendChild(el('b', null, '❝ ' + quoteLabelOf(quotes[i])))
+            item.appendChild(document.createTextNode(quoteBrief(quotes[i].text, 60)))
+            item.title = quotes[i].text
+            box.appendChild(item)
+          }
+          node.appendChild(box)
+        }
+        if (turn.text) node.appendChild(el('div', null, turn.text))
+      }
+
       function bubbleFor(turn) {
         var bubble = el('div', 'dsh-sel-bubble ' + (turn.role === 'user' ? 'dsh-sel-bubble-user' : 'dsh-sel-bubble-bot'))
         if (turn.role === 'user') {
-          bubble.textContent = turn.text
+          fillUserBubble(bubble, turn)
         } else if (turn.error) {
           bubble.className += ' dsh-sel-bubble-err'
           bubble.textContent = turn.text
         } else {
           renderRich(bubble, sanitizeToolResidue(turn.text) || '…', { settled: turn.streaming !== true })
         }
-        if (turn.role !== 'user') paintNotice(bubble, turn)
+        if (turn.role !== 'user') {
+          paintNotice(bubble, turn)
+          paintQuoteAll(bubble, turn)
+        }
         return bubble
       }
 
+      /**
+       * 助手气泡末尾的「❝ 引用整条」（鼠标移到这条消息上才浮出来）。
+       *
+       * 每次重画都要补一遍：renderRich() 会先清空气泡，按钮跟着一起没了。
+       * 点的时候现读 `source.text`（一轮还在流式时文本一直在长），并折掉网页回答里的 HTML
+       * —— 引用一整页 HTML 源码既长又没有提问价值，历史里本来也是折成 Markdown 的。
+       */
+      function paintQuoteAll(node, turn) {
+        var existing = null
+        for (var i = 0; i < node.children.length; i += 1) {
+          if (String(node.children[i].className).indexOf('dsh-sel-bubquote') >= 0) existing = node.children[i]
+        }
+        var ready = turn && turn.error !== true && turn.streaming !== true && String(turn.text || '').trim()
+        if (!ready) {
+          if (existing) node.removeChild(existing)
+          return
+        }
+        if (!existing) {
+          existing = el('button', 'dsh-sel-bubquote')
+          existing.type = 'button'
+          existing.appendChild(el('span', null, '❝ 引用整条'))
+          node.appendChild(existing)
+        }
+        existing.title = '把这一整条回答加进追问的引用'
+        existing.__turn = turn
+        if (existing.__wired !== true) {
+          existing.__wired = true
+          listen(existing, 'click', function (event) {
+            event.stopPropagation()
+            var source = existing.__turn
+            if (!source) return
+            var body = foldForHistory(sanitizeToolResidue(source.text))
+            // 整条引用同样不带上下文：出处写进标签（「小窗第 N 轮回答」），对话本身在历史里
+            addQuote(body, turnLabelOf(source), { context: '', session: false })
+          })
+        }
+      }
+
       /** 把首轮解读结果作为追问的第一条助手上下文（截断，避免过长）。 */
       function seedHistoryFromExplanation() {
         var fallback = splitSections(sanitizeToolResidue(state.raw))
@@ -3218,7 +4813,39 @@ window.__ModuleLoader__.load({
        * 发送键 = 「发送」还是「停止」：生成中变成方形停止键（点了打断这次输出），
        * 空闲时是上箭头发送键（空输入才禁用）。
        */
+      /**
+       * 输入框跟着内容长高（到 132px 为止，再高就内部滚动）。
+       *
+       * textarea 的**高度由 rows 决定**，内容换行它不会自己长 —— 不补这一步，第二行起
+       * 下面的字就被裁掉了。语音输入的实时字幕最吃亏：字是边说边自己长出来的，
+       * 用户根本没在敲键盘，也就不会想到去拖那个框。
+       * 超过上限时把最新那几行滚进视野（实时落字时光标一直在末尾）。
+       */
+      function autoGrowAskBox() {
+        if (!askBox || !askBox.style) return
+        var cap = 132
+        // 先松开高度再量，否则量到的是上一次的高度（经典递归式变高）
+        askBox.style.height = 'auto'
+        var content = typeof askBox.scrollHeight === 'number' ? askBox.scrollHeight : 0
+        if (content > 0) {
+          askBox.style.height = Math.min(content, cap) + 'px'
+          askBox.style.overflowY = content > cap ? 'auto' : 'hidden'
+        } else {
+          // 量不到内容（面板收着 / DOM 桩）：交回 CSS 的 min-height
+          askBox.style.height = ''
+          askBox.style.overflowY = ''
+        }
+        try {
+          if (content > cap) askBox.scrollTop = askBox.scrollHeight
+        } catch (error) {
+          /* 桩环境没有 scrollTop 语义 */
+        }
+        // 长高之后面板可能顶出视口：拉回来（面板没开时它自己会早退）
+        keepInsideViewport()
+      }
+
       function refreshAskState() {
+        autoGrowAskBox()
         var generating = isGenerating()
         var mode = generating ? 'stop' : 'send'
         if (askSend.getAttribute('data-mode') !== mode) {
@@ -3228,7 +4855,7 @@ window.__ModuleLoader__.load({
           askSend.setAttribute('aria-label', generating ? '停止' : '发送')
           askSend.title = generating ? '停止生成（点一下打断这次输出）' : '发送（Enter）'
         }
-        askSend.disabled = generating ? false : !String(askBox.value || '').trim()
+        askSend.disabled = generating ? false : !String(askBox.value || '').trim() && state.quotes.length === 0
       }
 
       /** 停止当前这一轮：追问走自己的 abort；首轮/详解复用"用户中止"那条路径。 */
@@ -3255,7 +4882,13 @@ window.__ModuleLoader__.load({
         return false
       }
 
-      /** 发送一个追问（多轮，带历史；走 host 的 chat 模式）。 */
+      /**
+       * 发送一个追问（多轮，带历史；走 host 的 chat 模式）。
+       *
+       * 两段式：先**取引用的上下文**（会话里那几段要问 host 要，见 resolveQuoteContexts），
+       * 再真正发。取上下文期间用 state.resolvingQuotes 挡住重复发送 ——
+       * 那一刻输入框和引用区都已经清空了，再按一次 Enter 会变成"空发一条"。
+       */
       function ask(question) {
         var generating = state.asking || state.phase === 'loading' || state.phase === 'streaming'
         if (generating) {
@@ -3263,12 +4896,47 @@ window.__ModuleLoader__.load({
           setStatus('还在生成，请稍候…（生成完就能追问）')
           return
         }
-        if (!question.trim() || !state.payload) return
+        // 这条消息发出去了，正在录的那一段就不再是"下一条提问"了：
+        // 收掉它可以避免"发送后麦克风还红着"（用户会以为还在录）。
+        // 已经识别出来的文字在输入框里，不受影响。
+        if (voice.phase === 'recording' || voice.phase === 'requesting' || voice.phase === 'transcribing') {
+          cancelVoice({ note: '已停止录音（这条先发出去）' })
+        }
+        var asked = String(question || '').trim()
+        // 引用先取出来：只挂引用、没写问题也允许发（这时用一句兜底提问）
+        var quotes = state.quotes.slice()
+        if ((!asked && quotes.length === 0) || !state.payload) return
+        if (state.resolvingQuotes) {
+          setStatus('正在取引用的上下文…')
+          return
+        }
+        // 引用是"下一条提问"的：立刻清空（提问已经在手上，别让下一轮又带上）
+        if (quotes.length > 0) {
+          state.quotes = []
+          renderQuotes()
+          refreshAskState()
+        }
+        if (quotes.length === 0) {
+          sendAsk(asked, quotes)
+          return
+        }
+        state.resolvingQuotes = true
+        resolveQuoteContexts(quotes).then(function (resolved) {
+          state.resolvingQuotes = false
+          sendAsk(asked, resolved)
+        })
+      }
+
+      /** 真正把这一轮发出去（引用已经带上上下文了）。 */
+      function sendAsk(asked, quotes) {
         var payload = state.payload
+        if (!payload) return
+        // 引用拼进**这一条**消息：发给模型、进历史、升格用的都是拼好的那份
+        var sent = composeQuestion(quotes, asked)
         if (state.turns.length === 0 && (state.raw.trim() || state.parts.translation || state.parts.detail)) {
           state.turns.push({ role: 'assistant', text: seedHistoryFromExplanation(), seed: true, hidden: true })
         }
-        state.turns.push({ role: 'user', text: question })
+        state.turns.push({ role: 'user', text: asked || QUOTE_ONLY_QUESTION, quotes: quotes, sent: sent })
         // asking 只管"等待特效要不要显示"（首字一到就置 false），
         // streaming 才是"这一轮还没写完"。两者必须分开：以前拿 asking 当定稿判据，
         // 结果是首字一到就认定"定稿了"→ 每个 delta 都重建一个 iframe（实测一条回答建了 24 个），
@@ -3365,7 +5033,7 @@ window.__ModuleLoader__.load({
             context: payload.context,
             label: payload.label,
             sessionId: currentSessionId(),
-            question: question,
+            question: sent,
             history: history,
             ...(state.webAnswer ? { webAnswer: true } : {}),
             ...(state.modelChoice ? { provider: state.modelChoice.provider, model: state.modelChoice.model } : {}),
@@ -3857,7 +5525,8 @@ window.__ModuleLoader__.load({
             label: payload.label,
             translation: (sections.translation || '').trim(),
             detail: (sections.detail || '').trim(),
-            turns: state.turns,
+            // 带引用块的轮次：升格出来的会话里，用户当时发的就是拼好的那份
+            turns: exportTurns(),
           }),
         })
           .then(function (response) {
@@ -3934,8 +5603,15 @@ window.__ModuleLoader__.load({
         setButtonPop(false)
       })
 
+      var offQuotePopEnd = listen(quoteButton, 'animationend', function () {
+        setQuotePop(false)
+      })
+
       var offMouseUp = listen(document, 'mouseup', function (event) {
-        if (panel.contains(event.target) || button.contains(event.target)) return
+        // 面板里的 mouseup **也要走一次检查**：小窗开着时"划小窗正文"正是「引用」的主入口
+        // （早先这里对面板直接 return —— 那是"面板里划词一律不管"年代的写法，
+        //  结果就是小窗里划词毫无反应，只有气泡末尾的「引用整条」能用）。
+        if (button.contains(event.target) || quoteButton.contains(event.target)) return
         scheduleCheck()
       }, true)
 
@@ -3956,6 +5632,7 @@ window.__ModuleLoader__.load({
         if (historyList.contains(target)) return // 列表内部：行自己处理
         if (historyButton.contains(target)) return // 「最近」开关自己 toggle
         if (button.contains(target)) return // 浮标
+        if (quoteButton.contains(target)) return // 引用浮标：点它不能先把自己收掉
         // 状态胶囊：它自己就是开关，点它的 mousedown 不能被当成"点了外面"（否则先关后开，看着像没反应）
         if (pill.contains(target)) return
         // 到这里说明点的不是侧边栏本身：**含面板正文**（消息区/输入框/选中文字）在内，
@@ -3963,6 +5640,7 @@ window.__ModuleLoader__.load({
         hideHistoryList()
         if (panel.contains(target)) return // 面板内的点击只收侧边栏，不关面板
         hideButton()
+        hideQuoteButton()
         // 点面板外**不关小窗**（无论有没有追问过）：答案留在原地，只有 ✕ / Esc / 胶囊能收。
         // 曾经的规则是"没追问过才关"，但那会让用户在读第一屏翻译时被误关（点一下别处就没了）。
       }, true)
@@ -3980,8 +5658,26 @@ window.__ModuleLoader__.load({
         if (selection) openForSelection(selection)
       })
 
+      // 引用浮标：吞掉 mousedown（点了不能把选区打散、也不能让面板失焦），
+      // 点一下 = 把这段文字挂进输入框的引用区，然后自己收起来（"已经进去了"的信号）
+      var offQuoteDown = listen(quoteButton, 'mousedown', function (event) {
+        event.preventDefault()
+        event.stopPropagation()
+      })
+
+      var offQuoteClick = listen(quoteButton, 'click', function (event) {
+        event.preventDefault()
+        event.stopPropagation()
+        var selection = state.quoteSelection
+        if (!selection) return
+        // 上下文在这里才采：引用**当时**在哪一段对话里，是这条引用最有用的信息
+        addQuote(selection.text, selection.label, quoteContextFor(selection))
+        hideQuoteButton()
+      })
+
       var offScroll = listen(window, 'scroll', function (event) {
         hideButton()
+        hideQuoteButton()
         // 页面/面板滚动也收回侧边栏；滚动列表自身不算（它有自己的滚动条）。
         // event.target 不一定是 Node（合成事件可能是 window），contains 会抛，得自己挡一道
         var target = event && event.target
@@ -4312,6 +6008,8 @@ window.__ModuleLoader__.load({
         .then(function (data) {
           modelCatalog.current = (data && data.route) || null
           modelCatalog.stages = { chat: (data && data.reasoningEffortByStage && data.reasoningEffortByStage.chat) || '' }
+          // 侧边栏网页划词桥的总开关（host 配置 bridgeSidebarPreview，默认开）
+          if (data && data.bridgeSidebarPreview === false) bridgeOn = false
           paintModelPill()
           return null
         })
@@ -4389,6 +6087,9 @@ window.__ModuleLoader__.load({
 
       var offResize = listen(window, 'resize', function () {
         hideButton()
+        hideQuoteButton()
+        // 宽度变了 → 换行位置变了 → 输入框高度要重量（否则会是按旧宽度算出来的高度）
+        autoGrowAskBox()
         // 拖窗口变小后，面板本身也要拉回视口内（否则历史列表会跟着算到屏幕外）
         keepInsideViewport()
         if (historyList.style.display === 'flex') placeHistoryList()
@@ -4398,13 +6099,20 @@ window.__ModuleLoader__.load({
       })
 
       var offKeyDown = listen(document, 'keydown', function (event) {
-        // Esc：**任何时候、一次到位**关掉小窗（不受"有没有追问过"限制）。
-        // closePanel() 内部会顺带收起模型菜单与「最近」侧边栏，所以不再需要"第一下只收侧边栏"那一级。
-        if (event.key === 'Escape' && panelOpen) {
+        if (event.key !== 'Escape' || !panelOpen) return
+        // Esc 分两级，和主会话一致：**先退出正在进行的事，再关窗**。
+        //   ① 语音进行中（录音行还在）→ 只取消这一次语音（等价于点 ✕，已经说出来的字留着），面板留着；
+        //   ② 其余情况 → 关掉小窗（一次到位，不受"有没有追问过"限制）。
+        // 以前是一律关窗：正在说一句话时按 Esc 想放弃这句话，结果整个小窗没了。
+        if (captureRow.getAttribute('data-show') === '1') {
           event.preventDefault()
           event.stopPropagation()
-          closePanel()
+          cancelVoice()
+          return
         }
+        event.preventDefault()
+        event.stopPropagation()
+        closePanel()
       }, true)
 
       var offHistory = listen(historyButton, 'click', function (event) {
@@ -4435,7 +6143,8 @@ window.__ModuleLoader__.load({
         event.preventDefault()
         event.stopPropagation()
         var question = askBox.value
-        if (!question.trim()) return
+        // 空输入框照发**只在挂了引用时**成立（引用本身就是用户要送出去的内容）
+        if (!question.trim() && state.quotes.length === 0) return
         askBox.value = ''
         refreshAskState()
         ask(question)
@@ -4452,108 +6161,1481 @@ window.__ModuleLoader__.load({
           return
         }
         var question = askBox.value
-        if (!question.trim()) return
+        if (!question.trim() && state.quotes.length === 0) return
         askBox.value = ''
         refreshAskState()
         ask(question)
       })
 
-      // 用户自己滚消息区（滚轮/触摸）→ 不再强行把他拉回底部
-      var offBodyWheel = listen(body, 'wheel', noteUserScroll)
-      var offBodyTouch = listen(body, 'touchmove', noteUserScroll)
-      var offBodyScroll = listen(body, 'scroll', noteBodyScroll)
+      // ══════════════════════════ 语音输入（麦克风） ══════════════════════════
+      //
+      // 要解决的问题：追问往往只有一两句话（"这词在这里是不是贬义？"），
+      // 但**打字**这件事本身就要把手从鼠标挪到键盘——和"划词"这个动作是矛盾的。
+      //
+      // **UI 与主会话同一套**（官方 @deepseek-ai/dsh-experimental-client-ui-voice-input）：
+      // 平时是输入框右边的 🎤；开始录之后工具行换成录音行 ——`✕` | 实时波形 | `■`，
+      // 请求权限/识别中是「呼吸点 + 请允许使用麦克风…/识别中…」，出错是「原因 + 行内动作」。
+      // 波形算法（80 根线 / 50ms 采样 / 1+min(1,amp*5)*17 / 右侧最新）逐行照抄，
+      // 只有尺寸按小窗的 composer 收成 26px（主会话 32px）——两处看起来才是同一个东西。
+      //
+      // 识别出来的文字**插进输入框**（不是直接发送：识别有错字，插进去还能改，
+      // 也能在同一条里接着说第二段）。录音中切走/收起小窗/这条消息发出去/停用插件
+      // 都会立刻松开麦克风（不留下一直亮着的录音标识）。
 
-      var offClose = listen(closeButton, 'click', function (event) {
-        event.stopPropagation()
-        closePanel()
-      })
+      /** 状态机：idle → requesting → recording → transcribing →（feedback | idle）→ idle。 */
+      var voice = {
+        phase: 'idle',
+        /**
+         * 第几轮。停/取消/关面板都会 +1 —— 晚到的回调据此丢弃自己。
+         * 没有它就会出现"明明取消了，过两秒却冒出一段文字"（异步的权限、识别都可能晚到）。
+         */
+        generation: 0,
+        capture: null,
+        abort: null,
+        ticker: 0,
+        waveFrame: 0,
+        waveAt: 0,
+        startedAt: 0,
+        maxSeconds: VOICE_FALLBACK_SECONDS,
+        catalog: null,
+        catalogAt: 0,
+        idleTimer: 0,
+        pollTimer: 0,
+        lastClock: -1,
+        level: 0,
+        lastText: '',
+        /** feedback 阶段的行内动作（null = 只显示原因，不给按钮）。 */
+        action: null,
+        /**
+         * 实时字幕（半句预览 + 停顿定稿）的运行时状态。
+         * text/committed/preview 都是输入框里那一段的一部分，start 是它在 value 里的起点。
+         */
+        live: {
+          active: false,
+          disabled: false,
+          reason: '',
+          separator: '',
+          start: -1,
+          text: '',
+          committed: '',
+          preview: '',
+          boundary: 0,
+          phraseStart: 0,
+          inflight: false,
+          controller: null,
+          timer: 0,
+          tickAt: 0,
+          startedAt: 0,
+          previewFails: 0,
+          passes: { preview: 0, commit: 0 },
+          rewritten: false,
+        },
+      }
 
-      var offDrag = listen(head, 'mousedown', function (event) {
-        if (promoteButton.contains(event.target) || closeButton.contains(event.target)) return
-        event.preventDefault()
-        var rect = panel.getBoundingClientRect()
-        var offsetX = event.clientX - rect.left
-        var offsetY = event.clientY - rect.top
-        var move = function (moveEvent) {
-          panel.style.left = clamp(moveEvent.clientX - offsetX, 4, window.innerWidth - rect.width - 4) + 'px'
-          panel.style.top = clamp(moveEvent.clientY - offsetY, 4, window.innerHeight - 40) + 'px'
-          if (historyList.style.display === 'flex') placeHistoryList()
+      /** 录音失败的统一话术（浏览器抛的是 DOMException，用户看不懂）。 */
+      var VOICE_ERRORS = {
+        unavailable: '当前浏览器不支持录音，请使用支持麦克风的浏览器。',
+        permission: '麦克风权限未开启，请在浏览器和系统设置中允许访问。',
+        missing: '没有找到麦克风设备。',
+        interrupted: '录音中断，请重试。',
+        empty: '未识别到语音',
+        cancelled: '已取消语音输入。',
+      }
+
+      function voiceError(kind, extra) {
+        var error = new Error(VOICE_ERRORS[kind] || '录音失败')
+        error.voiceKind = kind
+        if (extra) error.cause = extra
+        return error
+      }
+
+      /** 出错信息 → 一句人话。 */
+      function voiceMessageOf(error) {
+        if (!error) return '未知错误'
+        if (error.voiceKind) return VOICE_ERRORS[error.voiceKind] || '录音失败'
+        return String(error.message || error)
+      }
+
+      /**
+       * 状态行文案：
+       * @param text 文案
+       * @param options { dot: 显示呼吸点, tone: '' | 'warn' | 'error' }
+       */
+      function setVoiceActivity(text, options) {
+        var opts = options || {}
+        voiceActivityText.textContent = String(text || '')
+        voiceActivity.setAttribute('data-tone', opts.tone || '')
+        voiceDot.style.display = opts.dot ? '' : 'none'
+      }
+
+      /** 行内动作位：'prepare'（准备模型文字键）/ null（用 🎤 重录）/ 'none'（什么都不要）。 */
+      function setVoiceAction(kind) {
+        while (voiceActionSlot.firstChild) voiceActionSlot.removeChild(voiceActionSlot.firstChild)
+        voice.action = kind || null
+        if (kind === 'prepare') {
+          var prepareBtn = el('button', 'dsh-sel-vact', '准备模型')
+          prepareBtn.type = 'button'
+          prepareBtn.title = '在本机下载并准备识别模型（首次要下载，之后一直可用）'
+          listen(prepareBtn, 'click', function (event) {
+            event.stopPropagation()
+            prepareVoice()
+          })
+          voiceActionSlot.appendChild(prepareBtn)
+          return prepareBtn
+        }
+        if (kind === 'retry') {
+          var retryMic = el('button', 'dsh-sel-round')
+          retryMic.type = 'button'
+          retryMic.setAttribute('aria-label', '重新录音')
+          retryMic.title = '重新录音'
+          retryMic.appendChild(micIcon())
+          listen(retryMic, 'click', function (event) {
+            event.stopPropagation()
+            startVoice()
+          })
+          voiceActionSlot.appendChild(retryMic)
+          return retryMic
         }
-        var up = function () {
-          window.removeEventListener('mousemove', move, true)
-          window.removeEventListener('mouseup', up, true)
+        return null
+      }
+
+      /**
+       * 出错/提示：录音行里给一句原因 +（有救的）一个动作。`retryable` 为真时给 🎤 重录键。
+       * 这是主会话的 feedback 阶段：它就一直停在那儿，直到用户点 ✕（或行内动作）。
+       */
+      function voiceFeedback(text, tone, action) {
+        voice.phase = 'feedback'
+        setVoiceActivity(text, { tone: tone || '' })
+        setVoiceAction(action)
+        paintVoice()
+      }
+
+      /** 按状态摆好录音行：idle 显 🎤，其余显录音行（✕ / 波形或文案 / ■ 或行内动作）。 */
+      function paintVoice() {
+        var phase = voice.phase
+        var capturing = phase !== 'idle'
+        captureRow.setAttribute('data-show', capturing ? '1' : '0')
+        captureRow.style.display = capturing ? 'flex' : 'none'
+        // 录音行出现时，工具行左边那三样（输出偏好 / 模型 / 🎤）让位——和主会话一样，
+        // 录音时那行只讲一件事：怎么结束、结束之后会得到什么。
+        webMode.style.display = capturing ? 'none' : ''
+        askSpacer.style.display = capturing ? 'none' : ''
+        modelPill.style.display = capturing ? 'none' : ''
+        micButton.style.display = capturing ? 'none' : ''
+        // 中间那格：录音时是波形，其余是文案；■ 只在录音时出现
+        var recording = phase === 'recording'
+        waveSvg.style.display = recording ? '' : 'none'
+        voiceActivity.style.display = recording ? 'none' : 'flex'
+        voiceStop.style.display = recording ? 'inline-grid' : 'none'
+        voiceCancel.title = phase === 'feedback' ? '关闭（Esc）' : '取消这次语音（Esc，已经说出来的字留着）'
+        voiceCancel.setAttribute('aria-label', voiceCancel.title)
+        // 🎤 触发键的状态：只在"请求权限"时转圈（其余都是普通图标 —— 和主会话一致）
+        micButton.setAttribute('data-state', phase === 'requesting' ? 'requesting' : 'idle')
+        micButton.setAttribute('aria-pressed', capturing ? 'true' : 'false')
+        micButton.title = '语音输入（点一下开始说，再点一下结束并转成文字）'
+      }
+
+      /** 识别器：目录里默认那个（没有就第一个）。 */
+      function voiceProvider(catalog) {
+        if (!catalog || !catalog.providers || !catalog.providers.length) return null
+        var id = catalog.selection && catalog.selection.providerId
+        for (var i = 0; i < catalog.providers.length; i += 1) {
+          if (catalog.providers[i].id === id) return catalog.providers[i]
+        }
+        return catalog.providers[0]
+      }
+
+      /** 目录（有哪些识别器、能不能录、能录多久）：短暂缓存，别每点一次都问一遍 host。 */
+      function fetchSpeechCatalog(force) {
+        var now = Date.now()
+        if (!force && voice.catalog && now - voice.catalogAt < VOICE_CATALOG_TTL) {
+          return Promise.resolve(voice.catalog)
+        }
+        return fetch(SPEECH_API)
+          .then(function (response) {
+            return response.json()
+          })
+          .then(function (data) {
+            voice.catalog = data
+            voice.catalogAt = Date.now()
+            return data
+          })
+      }
+
+      /**
+       * 波形推进一帧（算法照抄主会话的 Waveform）：
+       * 新的电平从右边挤进来，整排往左推；静音时每条线只有 2px 高 —— 就是那条虚线。
+       * @param level 本帧电平（0 = 不采样，只把尺寸摆正）
+       */
+      function repaintWave(level) {
+        var next = level
+        for (var i = 0; i < waveBars.length; i += 1) {
+          var bar = waveBars[i]
+          var previous = bar.level
+          bar.level = next
+          next = previous
+          var height = 1 + Math.min(1, bar.level * 5) * 17
+          bar.node.setAttribute('y1', String(20 - height))
+          bar.node.setAttribute('y2', String(20 + height))
+        }
+      }
+
+      /** 把波形清回静音基线（新一次录音从头开始画；主会话是重建 SVG，效果一样）。 */
+      function resetWave() {
+        for (var i = 0; i < waveBars.length; i += 1) {
+          waveBars[i].level = 0
+          waveBars[i].node.setAttribute('y1', '19')
+          waveBars[i].node.setAttribute('y2', '21')
+        }
+      }
+
+      function stopWaveLoop() {
+        if (voice.waveFrame && typeof cancelAnimationFrame === 'function') cancelAnimationFrame(voice.waveFrame)
+        voice.waveFrame = 0
+        voice.waveAt = 0
+      }
+
+      /** 录音时的波形循环：50ms 采一次音量（和主会话同一个节拍）。 */
+      function startWaveLoop() {
+        stopWaveLoop()
+        if (typeof requestAnimationFrame !== 'function') return
+        var draw = function (now) {
+          if (voice.phase !== 'recording') return
+          // rAF 会给时间戳，但不是所有环境都给（桩、老实现）——缺了就用当前时间，别让波形卡住
+          var at = typeof now === 'number' ? now : Date.now()
+          if (at - voice.waveAt >= 50) {
+            voice.waveAt = at
+            var level = 0
+            try {
+              level = voice.capture ? voice.capture.level() : 0
+            } catch (error) {
+              level = 0
+            }
+            voice.level = level
+            repaintWave(level)
+          }
+          voice.waveFrame = requestAnimationFrame(draw)
         }
-        window.addEventListener('mousemove', move, true)
-        window.addEventListener('mouseup', up, true)
-      })
+        voice.waveFrame = requestAnimationFrame(draw)
+      }
 
-      // —— 调试钩子（自动化验证用） ——
-      window.__dshSelectionExplain = {
-        open: function (text, context, label, keyContext) {
-          state.selection = { text: text, range: null, rect: null }
-          // 和真实划词完全同一条路径（含本地缓存命中）；keyContext 省略时与 context 相同
-          openPanelWith(text, context || '', label || '调试', null, keyContext)
-          return true
-        },
-        expand: function () {
-          expandDetail()
-          return true
-        },
-        parts: function () {
-          return { ...state.parts, stage: state.stage }
-        },
-        promote: function () {
-          promote()
-          return true
-        },
-        ask: function (question) {
-          ask(question)
-          return true
-        },
-        turns: function () {
-          return state.turns.slice()
-        },
-        close: closePanel,
-        /** 自检用：清掉本地缓存，模拟"刷新页面后重开"（验证历史回放路径）。 */
-        forget: function () {
-          cache.clear()
-          return true
-        },
-        state: function () {
-          return {
-            phase: state.phase,
-            cache: state.cacheState,
-            cacheKey: state.cacheKey.slice(0, 24),
-            sameTextSeen: state.sameTextHint,
-            chars: state.chars,
-            /** host 回报的本次请求实际档位（等待提示用）；和用户选的 effort 是两码事 */
-            stageEffort: state.stageEffort,
-            raw: state.raw,
-            model: state.model,
-            sections: splitSections(sanitizeToolResidue(state.raw)),
-            toolResidue: state.toolResidue,
-            tools: state.tools.length,
-            toolBusy: state.toolBusy,
-            toolDigest: state.toolDigest,
-            /** 自检用：有没有在飞的请求 / 是不是"收起小窗中止"的那一轮。 */
-            thought: state.thought,
-            status: state.lastStatus,
-            follow: state.follow,
-            hasRequest: !!state.request,
-            aborted: !!state.aborted,
-            asking: !!state.asking,
+      function stopVoiceTicker() {
+        if (voice.ticker) clearInterval(voice.ticker)
+        voice.ticker = 0
+        voice.lastClock = -1
+        stopWaveLoop()
+      }
+
+      /**
+       * 一次录音的全部资源：麦克风流、MediaRecorder、AudioContext、分析器。
+       *
+       * 这几个东西**必须一起释放**：只停 MediaRecorder 的话，标签页上会一直挂着
+       * "正在使用麦克风"的标识（用户会以为在偷听），AudioContext 也会一直占着音频线程。
+       */
+      function createCapture(onError) {
+        var stream = null
+        var recorder = null
+        var context = null
+        var analyser = null
+        var samples = new Float32Array(256)
+        var chunks = []
+        var lifetime = new AbortController()
+        var disposal = null
+        // ── 采样水龙头（实时字幕用）──
+        var tap = null
+        var tapGain = null
+        /** 16k 采样的分片表（按时序），tapLength 是总采样数。 */
+        var tapChunks = []
+        var tapLength = 0
+        /** 线性重采样的分数位置：跨回调连续，接缝处才不会每 93ms 丢一个点。 */
+        var tapPos = 0
+        /** 最近一次"有声"的采样位置与墙钟时间（停顿定稿靠它切边界）。 */
+        var tapLoudIndex = -1
+        var tapLoudAt = 0
+
+        /** 把一块原始采样（context 采样率）重采样到 16k 攒起来，同时判"有声/静音"。 */
+        function acceptChunk(input) {
+          var rate = context && context.sampleRate ? context.sampleRate : 48000
+          var step = rate / 16000
+          var out = []
+          var pos = tapPos
+          while (pos + 1 < input.length) {
+            var index = Math.floor(pos)
+            var frac = pos - index
+            out.push(input[index] * (1 - frac) + input[index + 1] * frac)
+            pos += step
           }
-        },
-        panel: function () {
-          return panel
-        },
-        pill: function () {
-          return pill
-        },
-        /** 自检用：残渣清理（供单测直接打表）。 */
-        stripResidue: function (text) {
-          return sanitizeToolResidue(text)
-        },
+          tapPos = pos - input.length
+          if (out.length) {
+            var piece = Float32Array.from(out)
+            tapChunks.push(piece)
+            tapLength += piece.length
+          }
+          var sum = 0
+          for (var i = 0; i < input.length; i += 1) sum += input[i] * input[i]
+          if (Math.sqrt(sum / input.length) >= VOICE_SILENCE_RMS) {
+            tapLoudIndex = tapLength
+            tapLoudAt = Date.now()
+          }
+        }
+
+        /** 取 [from, to) 的 16k 采样（越界自动夹住）。 */
+        function readSamples(from, to) {
+          var a = Math.max(0, Math.floor(from))
+          var b = Math.min(tapLength, Math.ceil(to))
+          if (b <= a) return new Float32Array(0)
+          var out = new Float32Array(b - a)
+          var cursor = 0
+          for (var i = 0; i < tapChunks.length; i += 1) {
+            var piece = tapChunks[i]
+            var end = cursor + piece.length
+            if (end > a && cursor < b) {
+              var s = Math.max(0, a - cursor)
+              var e = Math.min(piece.length, b - cursor)
+              out.set(piece.subarray(s, e), cursor + s - a)
+            }
+            cursor = end
+            if (cursor >= b) break
+          }
+          return out
+        }
+
+        function release() {
+          try {
+            lifetime.abort()
+          } catch (error) {
+            /* noop */
+          }
+          if (tap) {
+            try {
+              tap.onaudioprocess = null
+              tap.disconnect()
+            } catch (error) {
+              /* noop */
+            }
+          }
+          if (tapGain) {
+            try {
+              tapGain.disconnect()
+            } catch (error) {
+              /* noop */
+            }
+          }
+          try {
+            if (recorder && recorder.state === 'recording') recorder.stop()
+          } catch (error) {
+            /* noop */
+          }
+          if (stream) {
+            var tracks = stream.getTracks ? stream.getTracks() : []
+            for (var i = 0; i < tracks.length; i += 1) {
+              try {
+                tracks[i].stop()
+              } catch (error) {
+                /* noop */
+              }
+            }
+          }
+          if (context && typeof context.close === 'function') {
+            try {
+              context.close()
+            } catch (error) {
+              /* noop */
+            }
+          }
+          return Promise.resolve()
+        }
+
+        function dispose() {
+          if (!disposal) disposal = release()
+          return disposal
+        }
+
+        /** decodeAudioData：新浏览器返回 Promise，老 Safari 只认回调 —— 两种都接住。 */
+        function decode(buffer) {
+          return new Promise(function (resolve, reject) {
+            var pending = context.decodeAudioData(buffer, resolve, reject)
+            if (pending && typeof pending.then === 'function') pending.then(resolve, reject)
+          })
+        }
+
+        return {
+          /** 拿麦克风并开始录（权限弹窗可能很久，晚到的授权要能作废）。 */
+          start: function () {
+            var devices = navigator.mediaDevices
+            if (!devices || typeof devices.getUserMedia !== 'function' || typeof window.MediaRecorder === 'undefined') {
+              return Promise.reject(voiceError('unavailable'))
+            }
+            return devices
+              .getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true }, video: false })
+              .then(
+                function (got) {
+                  stream = got
+                  if (lifetime.signal.aborted) {
+                    var granted = got.getTracks ? got.getTracks() : []
+                    for (var i = 0; i < granted.length; i += 1) granted[i].stop()
+                    throw voiceError('cancelled')
+                  }
+                  var Ctx = window.AudioContext || window.webkitAudioContext
+                  try {
+                    context = new Ctx()
+                    // 没有用户手势时浏览器会把 AudioContext 挂起：波形要动就得唤醒它
+                    if (context.state === 'suspended' && typeof context.resume === 'function') {
+                      var resumed = context.resume()
+                      if (resumed && typeof resumed.catch === 'function') resumed.catch(function () {})
+                    }
+                    analyser = context.createAnalyser()
+                    analyser.fftSize = samples.length
+                    var source = context.createMediaStreamSource(stream)
+                    source.connect(analyser)
+                    // 原始采样水龙头（只服务于实时字幕）：
+                    // MediaRecorder 那条路不变，最终那份规范 WAV 还是它出的；这里多接一路，
+                    // 直接把麦克风的采样按 16k 攒起来 —— 切窗口时不用每个 tick 去 decode 整个 blob。
+                    // ScriptProcessorNode 已废弃但仍在（实测 Chrome 153 可用）；没有就关掉实时层。
+                    try {
+                      if (typeof context.createScriptProcessor === 'function') {
+                        tap = context.createScriptProcessor(4096, 1, 1)
+                        tapGain = context.createGain()
+                        tapGain.gain.value = 0 // 静音：别把麦克风回灌到扬声器（会啸叫）
+                        tap.onaudioprocess = function (event) {
+                          var input = event && event.inputBuffer ? event.inputBuffer.getChannelData(0) : null
+                          if (input) acceptChunk(input)
+                        }
+                        source.connect(tap)
+                        tap.connect(tapGain)
+                        tapGain.connect(context.destination)
+                      }
+                    } catch (error) {
+                      tap = null
+                    }
+                    recorder = new window.MediaRecorder(stream)
+                    recorder.ondataavailable = function (event) {
+                      if (!lifetime.signal.aborted && event.data && event.data.size > 0) chunks.push(event.data)
+                    }
+                    recorder.onerror = function () {
+                      if (lifetime.signal.aborted) return
+                      dispose()
+                      if (onError) onError(voiceError('interrupted'))
+                    }
+                    recorder.start()
+                    return true
+                  } catch (error) {
+                    return dispose().then(function () {
+                      throw error
+                    })
+                  }
+                },
+                function (error) {
+                  if (error && error.name === 'NotAllowedError') throw voiceError('permission')
+                  if (error && error.name === 'NotFoundError') throw voiceError('missing')
+                  throw error
+                },
+              )
+          },
+
+          /** 实时音量（0..1 左右）：只用来驱动波形。 */
+          level: function () {
+            if (!analyser) return 0
+            try {
+              analyser.getFloatTimeDomainData(samples)
+            } catch (error) {
+              return 0
+            }
+            var sum = 0
+            for (var i = 0; i < samples.length; i += 1) sum += samples[i] * samples[i]
+            return Math.sqrt(sum / samples.length)
+          },
+
+          /**
+           * 结束录音 → 规范 WAV。
+           * 重采样交给 OfflineAudioContext（浏览器自带的重采样质量比自己写的线性插值好得多），
+           * 采样率固定 16kHz —— host 只收这一种（见 host 的 validateWave）。
+           */
+          stop: function (maxSeconds) {
+            return new Promise(function (resolve, reject) {
+              if (!recorder || !context || recorder.state !== 'recording') {
+                dispose().then(function () {
+                  reject(voiceError('empty'))
+                })
+                return
+              }
+              var settled = false
+              function giveUp(error) {
+                if (settled) return
+                settled = true
+                dispose().then(function () {
+                  reject(error)
+                })
+              }
+              recorder.onstop = function () {
+                if (settled) return
+                settled = true
+                var blob
+                try {
+                  var tracks = stream && stream.getTracks ? stream.getTracks() : []
+                  for (var i = 0; i < tracks.length; i += 1) tracks[i].stop()
+                  blob = new Blob(chunks, { type: recorder.mimeType || 'audio/webm' })
+                  if (!blob.size) throw voiceError('empty')
+                } catch (error) {
+                  dispose().then(function () {
+                    reject(error)
+                  })
+                  return
+                }
+                blob
+                  .arrayBuffer()
+                  .then(function (buffer) {
+                    return decode(buffer)
+                  })
+                  .then(function (decoded) {
+                    if (lifetime.signal.aborted) throw voiceError('cancelled')
+                    var rate = 16000
+                    var seconds = Math.min(decoded.duration || 0, maxSeconds)
+                    var frames = Math.max(1, Math.floor(seconds * rate))
+                    var Offline = window.OfflineAudioContext || window.webkitOfflineAudioContext
+                    var offline = new Offline(1, frames, rate)
+                    var source = offline.createBufferSource()
+                    source.buffer = decoded
+                    source.connect(offline.destination)
+                    source.start()
+                    return offline.startRendering()
+                  })
+                  .then(function (rendered) {
+                    return encodeWave(rendered.getChannelData(0))
+                  })
+                  .then(resolve, function (error) {
+                    reject(error)
+                  })
+              }
+              recorder.onerror = function () {
+                giveUp(voiceError('empty'))
+              }
+              try {
+                recorder.stop()
+              } catch (error) {
+                giveUp(error)
+              }
+            }).then(
+              function (bytes) {
+                return dispose().then(function () {
+                  return bytes
+                })
+              },
+              function (error) {
+                return dispose().then(function () {
+                  throw error
+                })
+              },
+            )
+          },
+
+          dispose: dispose,
+          /** 实时字幕的水龙头：没接上（浏览器没有 ScriptProcessor）时为 null。 */
+          tap: {
+            supported: function () {
+              return !!tap
+            },
+            length: function () {
+              return tapLength
+            },
+            loudIndex: function () {
+              return tapLoudIndex
+            },
+            loudAt: function () {
+              return tapLoudAt
+            },
+            read: readSamples,
+            /** 自检/单测用：直接喂一块原始采样（真浏览器里由 onaudioprocess 调）。 */
+            accept: acceptChunk,
+          },
+        }
+      }
+
+      /** 录音中的心跳：到点自动收尾 + 记一次电平（波形另有自己的 50ms 循环）。 */
+      /** 录音开始时把光标交给输入框：预览落字时光标要在末尾跳（textarea 没焦点就不显示光标）。 */
+      function focusAskForRecording() {
+        focusAskBox()
+      }
+
+      function startVoiceTicker() {
+        stopVoiceTicker()
+        voice.ticker = setInterval(function () {
+          if (voice.phase !== 'recording') return
+          var elapsed = Date.now() - voice.startedAt
+          var limit = voice.maxSeconds || VOICE_FALLBACK_SECONDS
+          if (elapsed >= limit * 1000) {
+            finishVoice()
+            return
+          }
+          voice.lastClock = Math.floor(elapsed / 1000)
+        }, 200)
+        startWaveLoop()
+      }
+
+      /** 识别出来的文字 → 输入框（插在光标处，前后补空格，光标落在末尾，接着还能打字）。 */
+      function insertTranscript(text) {
+        var current = String(askBox.value || '')
+        var start = typeof askBox.selectionStart === 'number' && askBox.selectionStart >= 0 ? askBox.selectionStart : current.length
+        var end = typeof askBox.selectionEnd === 'number' && askBox.selectionEnd >= start ? askBox.selectionEnd : start
+        var before = current.slice(0, start)
+        var after = current.slice(end)
+        var prefix = before && !/\s$/.test(before) ? ' ' : ''
+        var suffix = after && !/^\s/.test(after) ? ' ' : ''
+        askBox.value = before + prefix + text + suffix + after
+        var caret = (before + prefix + text).length
+        try {
+          askBox.setSelectionRange(caret, caret)
+        } catch (error) {
+          /* 桩环境没有这个方法 */
+        }
+        try {
+          askBox.focus()
+        } catch (error) {
+          /* noop */
+        }
+        voice.lastText = text
+        refreshAskState()
+        return askBox.value
+      }
+
+      function failVoice(generation, error) {
+        if (generation !== voice.generation) return
+        voice.generation += 1
+        var capture = voice.capture
+        voice.capture = null
+        stopVoiceTicker()
+        if (capture) capture.dispose()
+        // "用户取消"不是错（点了 ✕、收了小窗、插件停用都走这里），不给错误提示
+        var kind = error && error.voiceKind
+        if (kind === 'cancelled') {
+          resetVoiceRow()
+          return
+        }
+        // 没听清 / 中断 / 失败：留在 feedback 里给原因 + 🎤 重录（和主会话一致）
+        voiceFeedback(voiceMessageOf(error), kind === 'empty' || kind === 'interrupted' ? 'warn' : 'error', 'retry')
+      }
+
+      /** 回到 idle：工具行原样还回去。 */
+      function resetVoiceRow() {
+        stopVoiceTicker()
+        stopLive()
+        if (voice.idleTimer) clearTimeout(voice.idleTimer)
+        voice.idleTimer = 0
+        voice.phase = 'idle'
+        voice.action = null
+        while (voiceActionSlot.firstChild) voiceActionSlot.removeChild(voiceActionSlot.firstChild)
+        setVoiceActivity('', {})
+        paintVoice()
+      }
+
+      // ── 实时字幕（半句预览 + 停顿定稿）──────────────────────────────────────
+      //
+      // 说话时字就往输入框里长：每 ~1.3s 把"还没定稿的这半句"送去识别一次，整段替换上一拍
+      // 的预览；检测到 ~0.6s 静音（这句说完了）就把这句送去识别并**定稿**，之后不再变。
+      // 停止（■）时仍然走原来那条"整段规范 WAV"的路，回来的结果给这一整段收口：
+      //   · 整段识别**以已定稿的文字开头**（正常情况）→ 只补后半句，定稿的字一个不动；
+      //   · 对不上（整段上下文让引擎改了前面）→ 以整段为准整块替换，并在自检里记一笔。
+      // ✕ 取消 = 把这次插进去的文字整块撤掉（对应主会话那个 aria-label「丢弃识别文字」）。
+      //
+      // 为什么预览用**采样水龙头**而不是 MediaRecorder 的 blob：切窗口只要一段连续采样，
+      // 而每个 tick 去 decode 整个 blob 是 O(总时长) 的白活（说到 60 秒就是每秒 decode 60 秒音频）。
+
+      /** 定稿与预览拼起来时的连接处（中文直接接，英文补一个空格）。 */
+      function liveJoin(left, right) {
+        if (!left) return right
+        if (!right) return left
+        if (/[\s]$/.test(left) || /^[\s，。；：！？、,.!?;:]/.test(right)) return left + right
+        return left + ' ' + right
+      }
+
+      /** 光标位置（拿不到就当作末尾）。 */
+      function caretIndex() {
+        var value = String(askBox.value || '')
+        return typeof askBox.selectionStart === 'number' && askBox.selectionStart >= 0
+          ? Math.min(askBox.selectionStart, value.length)
+          : value.length
+      }
+
+      /** 这一段（分隔空格 + 定稿 + 预览）在输入框里该长什么样。 */
+      function liveCompose() {
+        var live = voice.live
+        var body = liveJoin(live.committed, live.preview)
+        live.text = body ? live.separator + body : ''
+        return live.text
+      }
+
+      /**
+       * 把这一段落到输入框里（原位替换）。
+       * 用户在我们这段**里面**改过字就不抢他的编辑：停掉实时层，以后按"停止后再出字"走。
+       */
+      function liveWrite() {
+        var live = voice.live
+        var value = String(askBox.value || '')
+        var previous = live.text
+        var start = live.start
+        if (previous) {
+          if (value.indexOf(previous) >= 0) start = value.indexOf(previous)
+          else if (start >= 0 && value.slice(start, start + previous.length) === previous) {
+            /* 位置没变 */
+          } else {
+            live.disabled = true
+            live.reason = 'edited'
+            stopLive()
+            return false
+          }
+        }
+        if (start < 0) start = caretIndex()
+        var end = previous ? start + previous.length : start
+        var caret = typeof askBox.selectionStart === 'number' ? askBox.selectionStart : end
+        // 光标原本就贴在这段文字的末尾（= 用户没在改这段，只是在看）→ 跟着最新文字走，
+        // 这样光标一直在新冒出来的字后面跳；用户把光标挪到别处（或在后面打字）就原位保留。
+        var atBlockEnd = previous ? caret === end : caret === start
+        var next = liveCompose()
+        askBox.value = value.slice(0, start) + next + value.slice(end)
+        live.start = next ? start : -1
+        live.text = next
+        var moved = next.length - previous.length
+        var nextCaret = atBlockEnd ? start + next.length : caret > end ? caret + moved : caret
+        if (nextCaret < 0) nextCaret = 0
+        if (nextCaret > askBox.value.length) nextCaret = askBox.value.length
+        try {
+          askBox.setSelectionRange(nextCaret, nextCaret)
+        } catch (error) {
+          /* 桩环境没有这个方法 */
+        }
+        refreshAskState()
+        return true
+      }
+
+      
+      function stopLive() {
+        var live = voice.live
+        live.active = false
+        live.inflight = false
+        if (live.timer) clearInterval(live.timer)
+        live.timer = 0
+        if (live.controller) {
+          try {
+            live.controller.abort()
+          } catch (error) {
+            /* noop */
+          }
+        }
+        live.controller = null
+      }
+
+      /** 开实时层（拿不到采样水龙头就不开：功能退回"说完点 ■ 再出字"）。 */
+      function startLive(capture) {
+        var live = voice.live
+        stopLive()
+        live.committed = ''
+        live.preview = ''
+        live.text = ''
+        live.start = -1
+        live.inflight = false
+        live.passes = { preview: 0, commit: 0 }
+        live.rewritten = false
+        live.disabled = false
+        live.reason = ''
+        if (!capture || !capture.tap || !capture.tap.supported()) {
+          live.disabled = true
+          live.reason = 'no-tap'
+          return false
+        }
+        // 云端识别器：每一拍都是一次**付费**调用（1.3 秒一拍 ≈ 46 次/分钟），不做预览。
+        // 本机模型不花钱、只占点 CPU，才是实时字幕该待的地方。
+        var provider = voiceProvider(voice.catalog)
+        if (provider && provider.location === 'cloud') {
+          live.disabled = true
+          live.reason = 'cloud'
+          return false
+        }
+        // 我们这段文字从**当前光标处**开始长；前面不是空白就补一个分隔空格
+        var value = String(askBox.value || '')
+        var caret = caretIndex()
+        live.separator = caret > 0 && !/\s$/.test(value.slice(0, caret)) ? ' ' : ''
+        live.start = -1
+        live.boundary = capture.tap.length()
+        live.phraseStart = live.boundary
+        live.startedAt = Date.now()
+        live.tickAt = 0
+        live.active = true
+        live.timer = setInterval(liveTick, 200)
+        return true
+      }
+
+      /**
+       * 送一段（16k 采样，[from,to)）去识别。
+       * **"没听清"不是故障**：停顿那几秒里窗口是纯静音，识别本来就该返回空
+       *（曾经把空结果当失败计数，连挂 3 次就把整个实时层关了 —— 表现是"只跟第一句，后面不吐字"）。
+       * @returns 识别到的文字（可能是 ''）
+       */
+      function liveSend(from, to) {
+        var live = voice.live
+        var capture = voice.capture
+        if (!capture || !capture.tap) return Promise.reject(new Error('没有采样水龙头'))
+        var samples = capture.tap.read(from, to)
+        if (samples.length < 1600) return Promise.reject(new Error('这段太短了'))
+        var controller = typeof AbortController === 'function' ? new AbortController() : null
+        live.controller = controller
+        return fetch(SPEECH_TRANSCRIBE, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ audioBase64: bytesToBase64(encodeWave(samples)), partial: true }),
+          signal: controller ? controller.signal : undefined,
+        })
+          .then(function (response) {
+            return response.json()
+          })
+          .then(function (data) {
+            if (data && data.ok === true) return String(data.text || '').trim()
+            if (data && data.code === 'empty-transcript') return ''
+            throw new Error(String((data && data.error) || '识别失败'))
+          })
+      }
+
+      /** 一句话说完了（静音够久）：把它送去识别并定稿。 */
+      function liveCommit(boundary) {
+        var live = voice.live
+        var from = live.phraseStart
+        var to = Math.min(boundary, from + 16000 * VOICE_COMMIT_MAX_SECONDS)
+        if (to - from < 1600) return
+        live.inflight = true
+        live.passes.commit += 1
+        liveSend(from, to)
+          .then(function (text) {
+            if (!live.active) return
+            live.previewFails = 0
+            if (text) {
+              live.committed = liveJoin(live.committed, text)
+              live.preview = ''
+              liveWrite()
+            }
+            live.boundary = to
+            live.phraseStart = to
+          })
+          .catch(function () {
+            /* 这一句没转出来：不打断录音，等停止时整段再试一次 */
+          })
+          .then(function () {
+            live.inflight = false
+            live.controller = null
+          })
+      }
+
+      /**
+       * 半句预览：把"最后 10 秒还没定稿的那半句"送去识别，整段替换上一拍的预览。
+       * @returns 这一拍真的发出去了没有（没发就不该吃掉节流窗口 —— 否则录到 0.2 秒时那次空转
+       *          会把第一拍预览推到 1.5 秒之后，用户会觉得"怎么半天不出字"）。
+       */
+      function livePreview() {
+        var live = voice.live
+        var capture = voice.capture
+        if (!capture || !capture.tap) return false
+        // 上次定稿之后还没开口（一直是静音）→ 不浪费调用，也别把上一拍预览抹掉
+        var loudIndex = capture.tap.loudIndex()
+        if (loudIndex < 0 || loudIndex <= live.phraseStart) return false
+        var length = capture.tap.length()
+        var from = Math.max(live.phraseStart, length - 16000 * VOICE_PREVIEW_WINDOW)
+        if (length - from < 16000 * 0.5) return false
+        live.inflight = true
+        live.passes.preview += 1
+        liveSend(from, length)
+          .then(function (text) {
+            if (!live.active) return
+            live.previewFails = 0
+            if (text === live.preview) return
+            // 这一拍没识别到内容（窗口里正好都是静音）：留着上一拍的预览，别闪没
+            if (!text) return
+            live.preview = text
+            liveWrite()
+          })
+          .catch(function (error) {
+            if (!live.active) return
+            // 预览连续失败就不再打扰用户（停止时那条路仍然会出字）；
+            // 阈值给宽一点：偶发一次超时不该把实时字幕整个关掉
+            if (error && error.name === 'AbortError') return
+            live.previewFails = (live.previewFails || 0) + 1
+            if (live.previewFails >= 5) {
+              live.disabled = true
+              live.reason = 'preview-failed'
+              stopLive()
+            }
+          })
+          .then(function () {
+            live.inflight = false
+            live.controller = null
+          })
+        return true
+      }
+
+      /** 实时层的节拍：先看有没有"一句话说完了"，再看要不要刷半句预览。 */
+      function liveTick() {
+        var live = voice.live
+        if (!live.active || live.disabled || voice.phase !== 'recording') return
+        var capture = voice.capture
+        if (!capture || !capture.tap || !capture.tap.supported()) return
+        if (live.inflight) return
+        var now = Date.now()
+        var length = capture.tap.length()
+        var loudIndex = capture.tap.loudIndex()
+        var loudAt = capture.tap.loudAt()
+        // ① 停顿定稿：最近一次有声已经过去 600ms 以上，且这句够长
+        if (loudIndex >= 0 && now - loudAt >= VOICE_PAUSE_MS && now - loudAt < 5000) {
+          var boundary = Math.min(length, loudIndex + Math.round(16000 * 0.25))
+          if (boundary - live.phraseStart >= (16000 * VOICE_PAUSE_MIN_MS) / 1000) {
+            live.pendingReady = true
+            liveCommit(boundary)
+            return
+          }
+        }
+        // ② 半句预览：每 1.3 秒刷一次（只有真发出去才算用掉这一拍）
+        if (now - live.tickAt < VOICE_PREVIEW_EVERY) return
+        if (livePreview()) live.tickAt = now
+      }
+
+      /**
+       * ■ 停止后的收口：整段识别已经拿到 fullText，把它和已经插进去的那段对齐。
+       * 正常情况（整段以定稿开头）只补后半句；对不上就整块替换（以整段为准）。
+       */
+      function liveFinalize(fullText) {
+        var live = voice.live
+        var committed = live.committed
+        var text = String(fullText || '').trim()
+        stopLive()
+        if (!text) {
+          // 整段一个都没识别出来：已经定稿的部分留着（用户看得见），预览丢掉
+          live.preview = ''
+          liveWrite()
+          return live.committed
+        }
+        var merged = text
+        if (committed) {
+          var rest = liveTailAfterCommitted(committed, text)
+          if (rest === null) {
+            live.rewritten = true
+            merged = text
+          } else {
+            merged = liveJoin(committed, rest)
+          }
+        }
+        live.committed = merged
+        live.preview = ''
+        liveWrite()
+        return merged
+      }
+
+      /**
+       * 整段识别里"已定稿那部分"之后还剩什么。
+       * 归一化（去空白与标点）之后比前缀：对得上 → 返回剩余原文；对不上 → null。
+       */
+      function liveTailAfterCommitted(committed, full) {
+        var norm = function (text) {
+          var out = []
+          for (var i = 0; i < text.length; i += 1) {
+            var ch = text[i]
+            if (/[\s，。；：！？、,.!?;:'"（）()\[\]【】…—-]/.test(ch)) continue
+            out.push({ ch: ch, at: i })
+          }
+          return out
+        }
+        var want = norm(committed)
+        var got = norm(full)
+        if (!want.length || got.length < want.length) return null
+        for (var i = 0; i < want.length; i += 1) {
+          if (want[i].ch !== got[i].ch) return null
+        }
+        return full.slice(got[want.length - 1].at + 1).trim()
+      }
+
+      /** 开始一段录音（先问 host 要目录：能不能录、最长多久）。 */
+      function startVoice() {
+        if (!recordingSupported()) {
+          voiceFeedback(VOICE_ERRORS.unavailable, 'error', null)
+          return
+        }
+        var generation = ++voice.generation
+        voice.phase = 'requesting'
+        setVoiceActivity('请允许使用麦克风…', { dot: true })
+        setVoiceAction(null)
+        paintVoice()
+        fetchSpeechCatalog(true)
+          .then(function (catalog) {
+            if (generation !== voice.generation) return null
+            if (!catalog || catalog.available !== true) {
+              var provider = voiceProvider(catalog)
+              var reason = catalog ? catalog.reason : ''
+              var text =
+                reason === 'unprepared' || (provider && provider.phase !== 'ready' && provider.phase !== 'standby')
+                  ? '语音模型还没准备好' + (provider && provider.name ? '（' + provider.name + '）' : '')
+                  : catalog && catalog.error
+                    ? catalog.error
+                    : '这个部署没有可用的语音识别服务'
+              // 有救的（模型没装）给一个「准备模型」按钮：下载在 host 上跑，几百 MB 到 1G，得用户自己点
+              voiceFeedback(text, 'warn', provider ? 'prepare' : 'retry')
+              return null
+            }
+            var limits = catalog.limits || {}
+            voice.maxSeconds = clamp(Number(limits.maxSeconds) || VOICE_FALLBACK_SECONDS, 5, 600)
+            var capture = createCapture(function (error) {
+              failVoice(generation, error)
+            })
+            voice.capture = capture
+            return capture.start().then(function () {
+              if (generation !== voice.generation) {
+                capture.dispose()
+                return null
+              }
+              voice.phase = 'recording'
+              voice.startedAt = Date.now()
+              resetWave()
+              setVoiceActivity('', {})
+              paintVoice()
+              // 光标交给输入框：实时字幕落字时要看见光标在末尾跳（textarea 没焦点就不画光标）
+              focusAskForRecording()
+              startVoiceTicker()
+              // 实时字幕：说话时字就往输入框里长（拿不到采样水龙头就自动退回"停止后出字"）
+              startLive(capture)
+              return true
+            })
+          })
+          .catch(function (error) {
+            failVoice(generation, error)
+          })
+      }
+
+      /** 结束录音 → 送去识别 → 文字插进输入框。 */
+      function finishVoice() {
+        if (voice.phase !== 'recording') return
+        var generation = voice.generation
+        var capture = voice.capture
+        var maxSeconds = voice.maxSeconds || VOICE_FALLBACK_SECONDS
+        stopVoiceTicker()
+        voice.phase = 'transcribing'
+        setVoiceActivity('识别中…', { dot: true })
+        setVoiceAction(null)
+        paintVoice()
+        var abort = typeof AbortController === 'function' ? new AbortController() : null
+        voice.abort = abort
+        capture
+          .stop(maxSeconds)
+          .then(function (bytes) {
+            if (generation !== voice.generation) return null
+            if (!bytes || !bytes.length) throw voiceError('empty')
+            if (bytes.length > VOICE_MAX_BYTES) throw new Error('录音超过服务限制，请缩短录音后重试。')
+            return fetch(SPEECH_TRANSCRIBE, {
+              method: 'POST',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ audioBase64: bytesToBase64(bytes) }),
+              signal: abort ? abort.signal : undefined,
+            })
+          })
+          .then(function (response) {
+            if (generation !== voice.generation || !response) return null
+            return response.json().then(function (data) {
+              if (generation !== voice.generation) return null
+              if (!data || data.ok !== true) {
+                var error = String((data && data.error) || '识别失败')
+                if (data && data.code === 'unprepared') {
+                  voiceFeedback(error, 'warn', 'prepare')
+                } else if (data && data.code === 'empty-transcript') {
+                  voiceFeedback(VOICE_ERRORS.empty, 'warn', 'retry')
+                } else {
+                  voiceFeedback('语音识别失败：' + error, 'error', 'retry')
+                }
+                return null
+              }
+              var text = String(data.text || '').trim()
+              var liveHasText = voice.live.active && !!(voice.live.committed || voice.live.preview || voice.live.text)
+              if (!text) {
+                if (liveHasText) {
+                  // 整段没转出来，但实时那几段已经落进输入框了：留着他看得见的那份
+                  voice.lastText = liveFinalize('')
+                  voice.capture = null
+                  voice.abort = null
+                  resetVoiceRow()
+                  return null
+                }
+                voiceFeedback(VOICE_ERRORS.empty, 'warn', 'retry')
+                return null
+              }
+              if (liveHasText) {
+                // 实时字幕已经在输入框里写了字：用它给整段收口（定稿部分尽量不动）
+                voice.lastText = liveFinalize(text)
+              } else {
+                insertTranscript(text)
+              }
+              // 插入成功 = **直接回 idle**：文字就摆在上面那行，不必再报一次
+              //（主会话也是这样：成功不额外说话，录音行收起、🎤 回位）。
+              voice.capture = null
+              voice.abort = null
+              resetVoiceRow()
+              return text
+            })
+          })
+          .catch(function (error) {
+            if (generation !== voice.generation) return
+            // 用户点了 ✕ / 收起小窗：静默（这不是失败，是他自己不要了）
+            if (error && error.name === 'AbortError') return
+            var kind = error && error.voiceKind
+            if (kind === 'cancelled') return
+            if (kind === 'empty') {
+              voiceFeedback(VOICE_ERRORS.empty, 'warn', 'retry')
+              return
+            }
+            voiceFeedback('语音识别失败：' + voiceMessageOf(error), 'error', 'retry')
+          })
+          .then(function () {
+            if (generation !== voice.generation) return
+            voice.capture = null
+            voice.abort = null
+          })
+      }
+
+      /**
+       * 取消当前这一轮（录音或识别）→ 回到 idle。✕ / Esc / 关面板 / 停用插件都走它。
+       * 一定会松开麦克风、并且让晚到的回调全部作废（generation + 1）。
+       */
+      function cancelVoice(options) {
+        if (!voice) return
+        var opts = typeof options === 'string' ? { note: options } : options || {}
+        var capture = voice.capture
+        voice.generation += 1
+        voice.capture = null
+        if (voice.abort) {
+          try {
+            voice.abort.abort()
+          } catch (error) {
+            /* noop */
+          }
+        }
+        voice.abort = null
+        if (voice.pollTimer) clearTimeout(voice.pollTimer)
+        voice.pollTimer = 0
+        // 取消 = 只停（不再更新那段实时文字），**已经说出来的字一律留着**。
+        // 早先跟着主会话的 ✕ 做过"丢弃识别文字"，实际用起来是"我按了取消，字没了" ——
+        // 录到一半反悔时更常见的诉求是"留着我已经说出来的"，所以统一成都留。
+        stopLive()
+        if (capture) capture.dispose()
+        resetVoiceRow()
+        // 少数情况下要交代一句（例如"这条消息先发出去了"）：留在 feedback 里，2 秒后自己回 idle
+        if (opts.note) {
+          voiceFeedback(opts.note, '', null)
+          voice.idleTimer = setTimeout(function () {
+            if (voice.phase !== 'feedback') return
+            resetVoiceRow()
+          }, 2200)
+        }
+      }
+
+      /** 让 host 去准备识别模型（首次要下载）；下载在 host 上跑，关掉面板也继续。 */
+      function prepareVoice() {
+        voice.phase = 'transcribing' // 复用"进行中"的形态：✕ + 呼吸点 + 文案
+        setVoiceActivity('正在准备语音模型…', { dot: true })
+        setVoiceAction(null)
+        paintVoice()
+        fetch(SPEECH_PREPARE, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({}),
+        })
+          .then(function (response) {
+            return response.json()
+          })
+          .then(function (data) {
+            if (!data || data.ok !== true) {
+              voiceFeedback('准备失败：' + ((data && data.error) || '未知原因'), 'error', 'prepare')
+              return
+            }
+            voice.catalog = data.catalog || null
+            voice.catalogAt = 0 // 状态变了，下一次点击重新问 host
+            pollPrepare(0)
+          })
+          .catch(function (error) {
+            voiceFeedback('准备失败：' + voiceMessageOf(error), 'error', 'prepare')
+          })
+      }
+
+      /** 轮询准备进度（下载在 host 上，这里只是播报）。 */
+      function pollPrepare(round) {
+        if (round > 480) return // 最多看 ~12 分钟，之后交给用户自己再来
+        if (voice.pollTimer) clearTimeout(voice.pollTimer)
+        voice.pollTimer = setTimeout(function () {
+          fetchSpeechCatalog(true)
+            .then(function (catalog) {
+              if (catalog && catalog.available) {
+                voiceFeedback('语音模型已就绪，可以开始说话', '', 'retry')
+                return
+              }
+              var provider = voiceProvider(catalog)
+              if (provider && provider.phase === 'failed') {
+                voiceFeedback('准备失败：' + (provider.message || '模型下载出错'), 'error', 'prepare')
+                return
+              }
+              var total = provider && provider.totalBytes ? provider.totalBytes : 0
+              var done = provider && provider.completedBytes ? provider.completedBytes : 0
+              var progress = total > 0 ? '（' + Math.round((done / total) * 100) + '%）' : ''
+              setVoiceActivity('正在准备语音模型' + progress + '…（可以先去忙别的，下载在后台继续）', { dot: true })
+              voice.phase = 'transcribing'
+              paintVoice()
+              pollPrepare(round + 1)
+            })
+            .catch(function () {
+              pollPrepare(round + 1)
+            })
+        }, 1500)
+      }
+
+      var offMic = listen(micButton, 'click', function (event) {
+        event.stopPropagation()
+        startVoice()
+      })
+      // 切走这个窗口（换到别的 App）就停止录音 —— 主会话也是这么做的：
+      // 人已经不在说话了，继续占着麦克风只会录一串环境噪音。识别**不打断**（那时音频已经拿到了）。
+      var offVoiceBlur = listen(window, 'blur', function () {
+        if (voice.phase === 'recording') cancelVoice()
+      })
+      var offVoiceCancel = listen(voiceCancel, 'click', function (event) {
+        event.stopPropagation()
+        // feedback 阶段点 ✕ 只是"关掉这条提示"，其余阶段是取消这次录音/识别。
+        // 取消**不删字**：已经说出来的（含半句预览）一律留在输入框里。
+        cancelVoice()
+      })
+      var offVoiceStop = listen(voiceStop, 'click', function (event) {
+        event.stopPropagation()
+        finishVoice()
+      })
+      paintVoice()
+      // ═════════════════════════ 语音输入（结束） ═════════════════════════
+
+      // 用户自己滚消息区（滚轮/触摸）→ 不再强行把他拉回底部
+      var offBodyWheel = listen(body, 'wheel', noteUserScroll)
+      var offBodyTouch = listen(body, 'touchmove', noteUserScroll)
+      var offBodyScroll = listen(body, 'scroll', noteBodyScroll)
+
+      var offClose = listen(closeButton, 'click', function (event) {
+        event.stopPropagation()
+        closePanel()
+      })
+
+      var offDrag = listen(head, 'mousedown', function (event) {
+        if (promoteButton.contains(event.target) || closeButton.contains(event.target)) return
+        event.preventDefault()
+        var rect = panel.getBoundingClientRect()
+        var offsetX = event.clientX - rect.left
+        var offsetY = event.clientY - rect.top
+        var move = function (moveEvent) {
+          panel.style.left = clamp(moveEvent.clientX - offsetX, 4, window.innerWidth - rect.width - 4) + 'px'
+          panel.style.top = clamp(moveEvent.clientY - offsetY, 4, window.innerHeight - 40) + 'px'
+          if (historyList.style.display === 'flex') placeHistoryList()
+        }
+        var up = function () {
+          window.removeEventListener('mousemove', move, true)
+          window.removeEventListener('mouseup', up, true)
+        }
+        window.addEventListener('mousemove', move, true)
+        window.addEventListener('mouseup', up, true)
+      })
+
+      // —— 调试钩子（自动化验证用） ——
+      window.__dshSelectionExplain = {
+        open: function (text, context, label, keyContext) {
+          state.selection = { text: text, range: null, rect: null }
+          // 和真实划词完全同一条路径（含本地缓存命中）；keyContext 省略时与 context 相同
+          openPanelWith(text, context || '', label || '调试', null, keyContext)
+          return true
+        },
+        expand: function () {
+          expandDetail()
+          return true
+        },
+        parts: function () {
+          return { ...state.parts, stage: state.stage }
+        },
+        promote: function () {
+          promote()
+          return true
+        },
+        ask: function (question) {
+          ask(question)
+          return true
+        },
+        turns: function () {
+          return state.turns.slice()
+        },
+        /** 自检用：当前待发送的引用（引用区里那几张卡片）。 */
+        quotes: function () {
+          return state.quotes.map(function (quote) {
+            return {
+              id: quote.id,
+              label: quote.label,
+              text: quote.text,
+              context: quote.context || '',
+              contextChars: (quote.context || '').length,
+              session: quote.session === true,
+            }
+          })
+        },
+        /** 自检用：手工加一段引用（等价于点了「❝ 引用」/「引用整条」）。 */
+        quote: function (text, label, extra) {
+          return addQuote(text, label || '调试', extra || {})
+        },
+        /** 自检用：某个节点上的选区会被标成什么出处（等价于点引用那一刻算出来的那个）。 */
+        quoteLabel: function (node) {
+          return node ? panelSourceLabel(node) : '（需要传节点）'
+        },
+        /** 自检用：引用 + 提问拼出来的那条消息原文（发给模型的就是它）。 */
+        compose: function (quotes, question) {
+          return composeQuestion(quotes || state.quotes, question)
+        },
+        /** 自检用：引用浮标与最近一次可引用选区的状态。 */
+        quoteState: function () {
+          return {
+            visible: quoteButton.style.display === 'inline-flex',
+            selection: state.quoteSelection
+              ? {
+                  text: state.quoteSelection.text,
+                  label: state.quoteSelection.label,
+                  source: state.quoteSelection.source,
+                  turnIndex: state.quoteSelection.turnIndex === undefined ? -1 : state.quoteSelection.turnIndex,
+                  hasRange: !!state.quoteSelection.range,
+                }
+              : null,
+            panelOpen: panelOpen,
+            resolving: state.resolvingQuotes === true,
+          }
+        },
+        /** 自检用：引用浮标的节点（无头环境里页面可能挂了两棵树，用这个拿真正带监听的那个）。 */
+        quoteNode: function () {
+          return quoteButton
+        },
+        close: closePanel,
+        /**
+         * 自检用：语音输入的状态（阶段 / 提示 / 目录 / 最近一次转写）。
+         * phase：idle / requesting / recording / transcribing / done
+         */
+        voice: function () {
+          return {
+            phase: voice.phase,
+            supported: recordingSupported(),
+            /** 录音行出来了没有（出来了 = 工具行换成了 ✕ / 波形 / ■ 那一套）。 */
+            capture: captureRow.getAttribute('data-show') === '1',
+            /** 状态文案（请允许使用麦克风… / 识别中… / 出错原因）。 */
+            activity: voiceActivityText.textContent,
+            activityTone: voiceActivity.getAttribute('data-tone') || '',
+            dot: voiceDot.style.display !== 'none',
+            waveform: waveSvg.style.display !== 'none',
+            stop: voiceStop.style.display !== 'none',
+            /** 行内动作：'prepare'（准备模型）/ 'retry'（🎤 重录）/ ''。 */
+            action: voice.action || '',
+            maxSeconds: voice.maxSeconds || VOICE_FALLBACK_SECONDS,
+            level: Number(voice.level.toFixed(3)),
+            lastText: voice.lastText,
+            /** 波形 80 根线的高度（自检/冒烟用：静音时全是 2px 的基线）。 */
+            bars: waveBars.map(function (bar) {
+              return Number(bar.node.getAttribute('y2')) - Number(bar.node.getAttribute('y1'))
+            }),
+            /** 实时字幕：定稿 / 半句预览 / 拍数 / 有没有被整段识别改写过。 */
+            live: {
+              active: voice.live.active,
+              disabled: voice.live.disabled,
+              reason: voice.live.reason,
+              committed: voice.live.committed,
+              preview: voice.live.preview,
+              text: voice.live.text,
+              passes: { preview: voice.live.passes.preview, commit: voice.live.passes.commit },
+              rewritten: voice.live.rewritten,
+              boundary: voice.live.boundary,
+              phraseStart: voice.live.phraseStart,
+              tap: voice.capture && voice.capture.tap && voice.capture.tap.supported()
+                ? {
+                    length: voice.capture.tap.length(),
+                    loudIndex: voice.capture.tap.loudIndex(),
+                    loudAt: voice.capture.tap.loudAt(),
+                  }
+                : null,
+            },
+            catalog: voice.catalog
+              ? {
+                  available: voice.catalog.available === true,
+                  reason: voice.catalog.reason || '',
+                  error: voice.catalog.error || '',
+                  providers: (voice.catalog.providers || []).map(function (provider) {
+                    return { id: provider.id, name: provider.name, phase: provider.phase }
+                  }),
+                }
+              : null,
+          }
+        },
+        /** 自检用：麦克风按钮节点（无头环境里页面可能挂了两棵树，用这个拿真正带监听的那个）。 */
+        voiceNode: function () {
+          return micButton
+        },
+        /** 自检用：手动催一拍实时字幕（测试里不用干等 1.3s 的节流）。 */
+        voiceTick: function () {
+          voice.live.tickAt = 0
+          liveTick()
+          return true
+        },
+        /** 自检用：录音行的各部件（✕ / 波形 / 状态 / 动作位 / ■）。 */
+        voiceNodes: function () {
+          return {
+            row: captureRow,
+            cancel: voiceCancel,
+            wave: waveSvg,
+            activity: voiceActivity,
+            action: voiceActionSlot,
+            stop: voiceStop,
+          }
+        },
+        /** 自检用：读/写追问输入框（验证"转写文字插进输入框"）。 */
+        askValue: function (text) {
+          if (text !== undefined) {
+            askBox.value = String(text)
+            refreshAskState()
+          }
+          return askBox.value
+        },
+        /** 自检用：清掉本地缓存，模拟"刷新页面后重开"（验证历史回放路径）。 */
+        forget: function () {
+          cache.clear()
+          return true
+        },
+        state: function () {
+          return {
+            phase: state.phase,
+            cache: state.cacheState,
+            cacheKey: state.cacheKey.slice(0, 24),
+            sameTextSeen: state.sameTextHint,
+            chars: state.chars,
+            /** host 回报的本次请求实际档位（等待提示用）；和用户选的 effort 是两码事 */
+            stageEffort: state.stageEffort,
+            raw: state.raw,
+            model: state.model,
+            sections: splitSections(sanitizeToolResidue(state.raw)),
+            toolResidue: state.toolResidue,
+            tools: state.tools.length,
+            toolBusy: state.toolBusy,
+            toolDigest: state.toolDigest,
+            /** 自检用：有没有在飞的请求 / 是不是"收起小窗中止"的那一轮。 */
+            thought: state.thought,
+            status: state.lastStatus,
+            follow: state.follow,
+            hasRequest: !!state.request,
+            aborted: !!state.aborted,
+            asking: !!state.asking,
+          }
+        },
+        panel: function () {
+          return panel
+        },
+        pill: function () {
+          return pill
+        },
+        /** 自检用：残渣清理（供单测直接打表）。 */
+        stripResidue: function (text) {
+          return sanitizeToolResidue(text)
+        },
         /** 自检用：模型/档位当前值 + 已加载的目录规模。 */
         modelState: function () {
           return {
@@ -4632,13 +7714,64 @@ window.__ModuleLoader__.load({
         resizing: function () {
           return !!pillObserver
         },
+        /**
+         * 自检用：侧边栏网页划词桥的状态。
+         * frames 里的每一项对应一个"桥过的预览帧"；own=true 表示那一帧的文档
+         * 是我们自己重发过的 blob（交互式预览走这条）。
+         */
+        bridge: function () {
+          var frames = []
+          bridged.forEach(function (url, frame) {
+            frames.push({
+              connected: frame.isConnected === true,
+              own: !!url,
+              srcdoc: frame.getAttribute('srcdoc') !== null,
+              sandbox: frame.getAttribute('sandbox'),
+            })
+          })
+          return {
+            on: bridgeOn,
+            frames: frames,
+            active: !!state.bridgeActive,
+            selection: state.selection && state.selection.source === 'iframe' ? state.selection.text : '',
+          }
+        },
+        /** 自检用：扫一遍预览帧（等价于 DOM 变动后的那次自动扫描）。 */
+        bridgeScan: function () {
+          scanPreviewFrames()
+          return window.__dshSelectionExplain.bridge()
+        },
+        /** 自检用：当前选区的来源与标签（source=iframe 表示来自侧边栏网页里的桥）。 */
+        selection: function () {
+          if (!state.selection) return null
+          return {
+            text: state.selection.text,
+            source: state.selection.source || 'document',
+            label: state.selection.label || '',
+            context: state.selection.context || '',
+            keyContext: state.selection.keyContext || '',
+          }
+        },
+        /** 自检用：最近一次请求载荷的关键字段（标签 / 上下文 / 选中文字）。 */
+        payload: function () {
+          if (!state.payload) return null
+          return {
+            text: state.payload.text,
+            label: state.payload.label,
+            context: state.payload.context,
+            kind: state.payload.kind,
+            stage: state.payload.stage,
+          }
+        },
         /** 模拟"刷新页面后"：内存里那段小窗没了，只剩 host 上的历史。 */
         reset: function () {
           closePanel()
           state.payload = null
           state.selection = null
+          state.bridgeActive = false
           state.parts = { translation: '', detail: '' }
           state.turns = []
+          clearQuotes()
           state.raw = ''
           state.phase = 'idle'
           state.error = ''
@@ -4668,11 +7801,14 @@ window.__ModuleLoader__.load({
         }
         return function () {
            offPopEnd()
+          offQuotePopEnd()
           offMouseUp()
           offKeyUp()
           offMouseDown()
           offButtonDown()
           offButtonClick()
+          offQuoteDown()
+          offQuoteClick()
           offScroll()
           offResize()
           offKeyDown()
@@ -4682,12 +7818,19 @@ window.__ModuleLoader__.load({
           offAskKey()
           offAskInput()
           offAskSend()
+          // 语音输入：摘掉麦克风监听，并把正在录/正在识别的这一轮彻底作废（松开麦克风）
+          offMic()
+          offVoiceCancel()
+          offVoiceStop()
+          offVoiceBlur()
+          cancelVoice()
           offClose()
           offDrag()
           offPillDown()
           offPillClick()
           offPillKey()
           offPreviewHeight()
+          offBridgeMessage()
           offCellMd()
           offCellWeb()
           offPrefKeys()
@@ -4708,12 +7851,34 @@ window.__ModuleLoader__.load({
             pillObserver = null
           }
           if (typeof offSlot === 'function') offSlot()
+          // 划词桥：摘观察者与消息监听，并把我们自己建的预览 blob 全部回收
+          if (bridgeScanId) clearTimeout(bridgeScanId)
+          bridgeScanId = 0
+          if (bridgeObserver) {
+            try {
+              bridgeObserver.disconnect()
+            } catch (error) {
+              /* noop */
+            }
+            bridgeObserver = null
+          }
+          bridged.forEach(function (url) {
+            if (!url) return
+            try {
+              URL.revokeObjectURL(url)
+            } catch (error) {
+              /* noop */
+            }
+          })
+          bridged.clear()
           state.turns = []
+          state.quotes = []
           if (state.request) state.request.abort()
           for (var i = 0; i < timers.length; i++) clearTimeout(timers[i])
           cache.clear()
           if (layer.parentNode) layer.parentNode.removeChild(layer)
           if (button.parentNode) button.parentNode.removeChild(button)
+          if (quoteButton.parentNode) quoteButton.parentNode.removeChild(quoteButton)
           if (panel.parentNode) panel.parentNode.removeChild(panel)
           if (pill.parentNode) pill.parentNode.removeChild(pill)
           if (styleEl.parentNode) styleEl.parentNode.removeChild(styleEl)
@@ -4871,6 +8036,66 @@ window.__ModuleLoader__.load({
       return svg
     }
 
+    /** 取消图标（✕）：两条斜线，和主会话录音行的取消键同形。 */
+    function closeIcon() {
+      var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+      svg.setAttribute('viewBox', '0 0 16 16')
+      svg.setAttribute('fill', 'none')
+      svg.setAttribute('stroke', 'currentColor')
+      svg.setAttribute('stroke-width', '1.8')
+      svg.setAttribute('stroke-linecap', 'round')
+      svg.setAttribute('aria-hidden', 'true')
+      var path = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+      path.setAttribute('d', 'M4.2 4.2l7.6 7.6M11.8 4.2l-7.6 7.6')
+      svg.appendChild(path)
+      return svg
+    }
+
+    /**
+     * 麦克风图标：话筒头（圆角矩形）+ 底座弧 + 支架。
+     * 用描边而不是实心：录音时这个位置要换成"红色实心停止键"，
+     * 平时轻一点，红起来的那一刻对比才够强。
+     */
+    function micIcon() {
+      var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+      svg.setAttribute('viewBox', '0 0 16 16')
+      svg.setAttribute('width', '14')
+      svg.setAttribute('height', '14')
+      svg.setAttribute('fill', 'none')
+      svg.setAttribute('stroke', 'currentColor')
+      svg.setAttribute('stroke-width', '1.5')
+      svg.setAttribute('stroke-linecap', 'round')
+      svg.setAttribute('aria-hidden', 'true')
+      var cap = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+      cap.setAttribute('d', 'M8 1.9a2.1 2.1 0 0 1 2.1 2.1v3.4a2.1 2.1 0 0 1-4.2 0V4A2.1 2.1 0 0 1 8 1.9z')
+      svg.appendChild(cap)
+      var arc = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+      arc.setAttribute('d', 'M3.6 7.2v.5a4.4 4.4 0 0 0 8.8 0v-.5')
+      svg.appendChild(arc)
+      var stem = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+      stem.setAttribute('d', 'M8 12.1v2')
+      svg.appendChild(stem)
+      return svg
+    }
+
+    /** 转圈图标（权限请求中 / 识别中）：CSS 让它转起来。 */
+    function spinnerIcon() {
+      var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+      svg.setAttribute('viewBox', '0 0 16 16')
+      svg.setAttribute('width', '14')
+      svg.setAttribute('height', '14')
+      svg.setAttribute('fill', 'none')
+      svg.setAttribute('stroke', 'currentColor')
+      svg.setAttribute('stroke-width', '1.7')
+      svg.setAttribute('stroke-linecap', 'round')
+      svg.setAttribute('aria-hidden', 'true')
+      var arc = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+      // 缺一个口的圆：转起来才看得出在动
+      arc.setAttribute('d', 'M8 1.8a6.2 6.2 0 1 1-4.4 1.8')
+      svg.appendChild(arc)
+      return svg
+    }
+
     /** 发送图标（上箭头，和主会话 composer 一致）。 */
     function sendIcon() {
       var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
@@ -4903,8 +8128,33 @@ window.__ModuleLoader__.load({
       return svg
     }
 
+    /**
+     * 引用浮标上的图标：两个引号块（❝ 的简化画法）。
+     * 用圆 + 左下角甩出的小尾巴拼 —— 13px 下也认得出，不依赖系统有没有那个字形。
+     */
+    function quoteIcon() {
+      var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+      svg.setAttribute('viewBox', '0 0 16 16')
+      svg.setAttribute('fill', 'currentColor')
+      svg.setAttribute('aria-hidden', 'true')
+      var marks = [
+        { cx: 5.4, cy: 6.1, tail: 'M3.9 7.4 2.1 12.2 6.1 10.2z' },
+        { cx: 11.6, cy: 6.1, tail: 'M10.1 7.4 8.3 12.2 12.3 10.2z' },
+      ]
+      for (var i = 0; i < marks.length; i += 1) {
+        var dot = document.createElementNS('http://www.w3.org/2000/svg', 'circle')
+        dot.setAttribute('cx', String(marks[i].cx))
+        dot.setAttribute('cy', String(marks[i].cy))
+        dot.setAttribute('r', '2.3')
+        svg.appendChild(dot)
+        var tail = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+        tail.setAttribute('d', marks[i].tail)
+        svg.appendChild(tail)
+      }
+      return svg
+    }
+
     exports.apply = apply
     exports.inject = ['slots']
     return module.exports
-  },
-})
+  },})