@yfwu2020/dsh-selection-explain 0.9.1 → 0.10.0

package/src/client/index.js

@@ -51,6 +51,99 @@ window.__ModuleLoader__.load({
     var SPEECH_API = '/selection-explain/api/speech'
     var SPEECH_TRANSCRIBE = SPEECH_API + '/transcribe'
     var SPEECH_PREPARE = SPEECH_API + '/prepare'
+    /**
+     * 麦克风占用（"输入法正在语音输入"）：host 读 CoreAudio 的进程对象列表，
+     * 见 src/index.ts 的 micPresence 与 native/mic-probe.c。
+     *   → { ok, available, capturing, processes:[{pid,bundleId,name}], reason }
+     * 读它不需要麦克风授权 —— 插件不该为了一个"指示灯"去要用户的麦克风权限。
+     */
+    var MIC_API = '/selection-explain/api/mic'
+    /**
+     * 认哪些输入法（bundleId 前缀）。豆包输入法。
+     * 加新输入法就往这里加一行：特性只对"已知输入法"生效，不去猜别的 App 在录什么。
+     */
+    var IME_BUNDLES = ['com.bytedance.inputmethod.doubaoime']
+    /**
+     * 轮询间隔：只在"有选区"时问（浮标亮着的那几拍）。
+     *
+     * 200ms：它是"按 Fn → 卡片弹出"延迟里的两项之一（另一项是宿主探针的采样间隔，
+     * 见 src/index.ts 的 MIC_WATCH_MS）。原来 400ms 是保守估的，实测本机一次 GET
+     * 的开销可忽略，所以调快一倍、把感知延迟压下来。
+     * 注意：即使调快，也不能靠"检测到文字再弹框" —— 上屏发生在松手那一刻，
+     * 那时才抢焦点就晚了（字会落到别处）；我们要的是"它开麦时就抢"。
+     */
+    var MIC_POLL_MS = 200
+    /** 语音卡几何：右缘贴浮标右缘，左缘展开到正文列左边 —— 宽度由这两条边界算出来。 */
+    /**
+     * 卡片宽度：**固定 360**。
+     *
+     * 原来按"正文列左边 → 选区右缘"算，再夹在 [360, 560] 之间 —— 想法是"让卡片看起来属于
+     * 这一段正文"，但实测**经常偏宽**（选区在第一行靠右结束时能顶到 560），读起来笨重。
+     * 现在统一 360：右缘仍然钉在选区右缘（和浮标同侧，形变时右缘不动、左缘展开），
+     * 宽度不再随选区位置变化。
+     */
+    var VCARD_W = 360
+    /**
+     * **兜底**：松手之后等文字"静默"多久才认定定稿（毫秒）。
+     *
+     * 主信号是 compositionend（见 VOICE_SETTLE_COMPOSE_MS），实测豆包的智能整理都走它，
+     * 所以这条兜底实际上很少被用到 —— 它管两种情况：
+     *   1. 输入法直接改 value、没走合成 API；
+     *   2. 整理提交发生在客户端察觉松手之前（轮询有最多一个间隔的滞后，那时 compositionend 已经过去了）。
+     *
+     * 取 500（用户指定，原为 700）：实测"松手 → 整理提交"是 71/257/328/393/515/600ms，
+     * 但那些**都带 compositionend**、走的是主信号，所以兜底提前到 500 不影响它们；
+     * 真要担心的是"没有合成信号"的场合 —— 那种情况没有实测数据，500 是个折中。
+     */
+    var VOICE_SETTLE_MS = 500
+    /**
+     * 收到 compositionend 之后，再等多久才决定（毫秒）。
+     *
+     * 实测结论（8 次真实录音）：豆包的智能整理**走合成 API 提交** —— 6 次里都有
+     * `inputType=insertCompositionText` + `compositionend`。所以它是**准确信号**，
+     * 不必再靠"猜静默窗口"。
+     *
+     * 留这 200ms 是因为可能连着提交两次（标点一次、改词一次）：每收到一次就重新计时。
+     * 实测"松手 → 整理提交"= 71 / 257 / 328 / 393 / 515 / 600 ms；整理内容包含补标点、
+     * 去重复词、以及**改听错的词**（"设置没法大概的话" → "设置没法打开的话"）——
+     * 正因为会改词，绝不能一松手就发送。
+     */
+    var VOICE_SETTLE_COMPOSE_MS = 200
+    /** 等定稿的**最长时间**（毫秒）：整理一直不停的话，到点就按当前内容决定，不能无限等。 */
+    var VOICE_SETTLE_MAX_MS = 4000
+    /** 观察文字有没有变的间隔（毫秒）。用轮询而不是 input 事件：智能整理可能是直接改 value，不一定发事件。 */
+    var VOICE_SETTLE_POLL_MS = 200
+    /**
+     * 卡片 → 小窗的交接（用户选定的方案：**缩放长出**）。
+     *
+     * 以前这两步是"瞬切"：卡片 `display:none`、小窗 `display:flex`，中间零过渡；
+     * 而且几何本身也换了 —— 卡片 360 宽、**右缘**贴选区右缘，小窗 540 宽、**左缘**贴选区左缘，
+     * 所以看起来是"跳"。现在让小窗**从卡片那一格开始**：起手用 transform 把面板压到卡片的矩形上，
+     * 260ms 回到自身（曲线与插件既有的"浮标 → 卡片"形变同一族）。
+     *
+     * 为什么只动 transform（不动 width/left/top）：那四个是布局属性，每帧都会重排整个面板
+     * （面板里有富文本、代码块，网页模式下还有 iframe）—— 形变期间会掉帧。transform 只走合成器。
+     * 代价是起手那几帧内容被压扁（缩放态），这正是"长出来"这个观感的来源。
+     */
+    var PANEL_GROW_MS = 260
+    var PANEL_GROW_EASE = 'cubic-bezier(.2,.8,.2,1)'
+    /** 正文最多 4 行（约 93px），再多内部滚动并停在最新一行（与追问框同一套）。 */
+    var VCARD_TEXT_MAX = 96
+    /**
+     * 卡片高度 = 正文高度 + 这个（border-box 下的纵向内边距 8+8 与边框 1+1）。
+     * 单行卡因此是 24 + 18 = 42px —— 而不是漏掉 box-sizing 时渲染出来的 70px。
+     */
+    var VCARD_PAD_Y = 18
+    /**
+     * "这一帧刚被动过"算多久以内有效（毫秒）。
+     *
+     * 只给侧边栏网页那条路用：焦点落在**不透明源子框架**里时，父文档的 `document.hasFocus()`
+     * 是否返回 true 由浏览器实现决定（跨引擎没有统一答案，headless 里也验不出来），
+     * 所以对帧内选区改用"这一帧刚刚报过动作（划词 / 按下）"当焦点证据 ——
+     * 桥报上来的那一刻，用户确实正在那个网页里操作。窗口取 5 秒：麦克风探针 125ms +
+     * 页面轮询 200ms，开麦检测最慢也就几百毫秒后才用到它。
+     */
+    var FRAME_FOCUS_EVIDENCE_MS = 5000
     /** 兜底限制（host 的 limits 优先；拿不到目录时按这套走）。 */
     var VOICE_FALLBACK_SECONDS = 60
     var VOICE_MAX_BYTES = 4 * 1024 * 1024
@@ -950,6 +1043,125 @@ window.__ModuleLoader__.load({
       '.dsh-sel-sbtn[data-danger="1"]{color:var(--dsw-alias-state-error-primary,#e5484d);',
       'border-color:color-mix(in srgb,var(--dsw-alias-state-error-primary,#e5484d) 45%,transparent)}',
       '.dsh-sel-sempty{font-size:12px;opacity:.55;padding:14px 2px}',
+      // ── 语音卡：选中文字 + 输入法正在语音输入时，就地弹出的临时输入框 ──
+      // 它由浮标**形变**而来（同一格 → 下移展开），所以几何全部由 JS 给，这里只管长相。
+      // box-sizing 必须显式写：插件是按组件设的（panel/history/pill 各自写），没有全局重置。
+      // 漏了它时 style.height 只是"内容高"，加上内边距与边框真实高度会多出 24px ——
+      // 单行卡于是渲染成 70px（用户报的"heard 阶段框太大"就是这个）。
+      '.dsh-sel-vcard{position:fixed;z-index:2147483000;display:none;align-items:stretch;gap:11px;',
+      'box-sizing:border-box;padding:8px 12px 8px 13px;background:var(--dsw-alias-bg-base,#fff);color:inherit;',
+      'border:1px solid var(--dsw-alias-border-l2,rgba(140,140,140,.28));border-radius:20px;',
+      'box-shadow:0 10px 28px rgba(0,0,0,.18);overflow:hidden;',
+      'transition:width .3s cubic-bezier(.2,.8,.2,1),height .3s cubic-bezier(.2,.8,.2,1),',
+      'left .3s cubic-bezier(.2,.8,.2,1),top .32s cubic-bezier(.2,.8,.2,1),',
+      'border-radius .3s cubic-bezier(.2,.8,.2,1),border-color .2s ease}',
+      // 「在听」= 卡片左缘那根 3px 竖条（B1）+ 高度呼吸（动1）。
+      // 当年否掉竖条的理由是"太像输入光标"—— 但那次是**通高 + 紧贴文字**；
+      // 现在保留同一形态，靠"伸缩"把它从"光标"读成"电平在动"（用户选定 B1+动1）。
+      // 描边仍然泛青（静态的"这一段在用"），但**光晕呼吸撤掉**：指示器只留一个，别两个一起动。
+      // 竖条在非"在听"时压暗到 .35（录音结束后不再假装在听，且不隐藏 —— 隐藏会让正文跳一下）。
+      '.dsh-sel-vcard[data-voiced="1"]{border-color:var(--sel-a2)}',
+      '.dsh-sel-vbar{flex:0 0 3px;width:3px;align-self:stretch;border-radius:3px;',
+      'background:var(--sel-a1);margin-right:9px;opacity:.35}',
+      '.dsh-sel-vcard[data-voiced="1"] .dsh-sel-vbar{opacity:1;',
+      'animation:dsh-sel-vbar-pulse 1.05s ease-in-out infinite}',
+      '@keyframes dsh-sel-vbar-pulse{50%{transform:scaleY(.55)}}',
+      // 正文右侧留 40px 给发送键（它是绝对定位的，不参与行高 —— 否则 30px 的按钮会把
+      // 单行卡片顶到 52px，用户看到的就是"临时框太高"）
+      '.dsh-sel-vcard-box{flex:1;min-width:0;align-self:center;display:block;margin:0;',
+      // min-height:0 是防御：宿主 App 的样式表若给 textarea 设了 min-height（我们管不到别人的全局规则），
+      // 高度就会由它说了算 —— 单行卡会因此变高
+      'box-sizing:border-box;min-height:0;padding:0 40px 0 0;border:0;outline:0;background:transparent;color:inherit;',
+      'resize:none;overflow-y:hidden;font:400 15.5px/1.5 ' + FONT + ';max-height:96px}',
+      '.dsh-sel-vcard-box::placeholder{color:var(--dsw-alias-label-tertiary,rgba(140,140,140,.9))}',
+      // 尺寸≈一行行高（23.25px）：单行卡里它和文字同一条中线；多行时贴底=跟着最后一行走。
+      // 比一行高太多（比如 30px）会让它在单行卡里"看起来掉到文字下面去了"。
+      '.dsh-sel-vcard-send{position:absolute;right:12px;bottom:8px;width:26px;height:26px;border:0;',
+      'border-radius:50%;background:var(--sel-a1);color:#fff;font:400 14px/1 ' + FONT + ';',
+      'cursor:pointer;opacity:0;pointer-events:none;transition:opacity .16s ease}',
+      // 还什么都没说时不摆出发送键（先只显示"正在听…"）
+      '.dsh-sel-vcard[data-text="1"] .dsh-sel-vcard-send{opacity:1;pointer-events:auto}',
+      // ── 选中提示：下划线 + 从选区牵引到卡片的虚线（E 方案）──────────────
+      // 抢焦点会让原生选区底纹消失，所以用这两样接手"指认这段文字"。
+      // 两者都在我们自己的层里，**不碰选区 / 焦点语义**，对输入法上屏零影响。
+      // 颜色直接用 --sel-a1 —— 它本来就按明暗换（浅色 #0d9488 / 深色 #4ecdc4）。
+      '.dsh-sel-umark{position:fixed;left:0;top:0;right:0;bottom:0;pointer-events:none;',
+      'z-index:2147482998;transition:opacity .14s ease}',
+      '.dsh-sel-uline{position:fixed;height:2px;border-radius:1px;pointer-events:none}',
+      // 牵引线是 **SVG 贝塞尔**（原来是一根 2px 竖条 → 控制点和端点同 x，退化成直线，
+      // 用户一眼看出"这不是贝塞尔"）。现在两端各给一个反向的横向控制量，做出可见的 S 形。
+      '.dsh-sel-thread{position:fixed;left:0;top:0;width:100%;height:100%;pointer-events:none;',
+      'z-index:2147482998;overflow:visible;display:none;opacity:0;transition:opacity .14s ease}',
+      '.dsh-sel-thread path{fill:none;stroke-width:1.6;stroke-dasharray:4 4;',
+      'animation:dsh-sel-thread-flow 1.1s linear infinite}',
+      // 出现时"向卡片生长"：用 clip 从上往下揭开（display:none → block 时动画自动重放，
+      // 不需要 JS 去重置；连续开关卡片也不会第二次不动）
+      '.dsh-sel-thread[data-grow="1"]{animation:dsh-sel-thread-grow .26s ease-out}',
+      '@keyframes dsh-sel-thread-grow{from{clip-path:inset(0 0 100% 0)}to{clip-path:inset(0 0 0 0)}}',
+      // 虚线朝卡片流动：SVG 直接动 stroke-dashoffset（比动 background-position 更省、也更准）
+      '@keyframes dsh-sel-thread-flow{to{stroke-dashoffset:-16}}',
+      // ── 消失：老式电视机关机（A 方案）────────────────────────────────
+      // 卡片塌成一条线，亮线再横缩成一个点；最后一段做成"像素故障"：
+      // 亮线拆成 5 段，各自闪、各自抖、各自死；**收缩原点统一在整条线的中心**
+      // （百分比是相对每段自己的宽度算的，所以外圈是 200% / -200% 这种值），
+      // 于是"往中间收"和"错位露缝"同时发生 —— 那点电子损坏就是这么来的。
+      // 为什么不用 mask 做虚线：mask-image 不是可动画属性，写在关键帧里会被忽略。
+      // 亮线是**独立元素**，不是卡片的 box-shadow —— 后者会跟着 transform 一起被压扁。
+      // 颜色由 JS 按明暗挂到容器上（浅色底白线看不见，只差 ~15/255），子元素用 currentColor 继承。
+      '.dsh-sel-crtline{position:fixed;height:3px;pointer-events:none;z-index:2147483001;opacity:0}',
+      '.dsh-sel-crtseg,.dsh-sel-crtspark{position:absolute;background:currentColor;border-radius:1px}',
+      '.dsh-sel-crtseg{top:0;height:100%;width:20%}',
+      '.dsh-sel-crtspark{top:-1px;width:3px;height:5px;opacity:0}',
+      '.dsh-sel-vcard[data-off="a"]{transform-origin:50% 50%;animation:dsh-sel-crt-card-a 460ms cubic-bezier(.3,0,.2,1) forwards}',
+      '.dsh-sel-crtline[data-off="a"]{animation:dsh-sel-crt-line-a 460ms cubic-bezier(.35,0,.25,1) forwards}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtseg{animation:dsh-sel-crt-seg-a 460ms cubic-bezier(.4,0,.3,1) forwards}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtspark{animation:dsh-sel-crt-spark-a 460ms linear forwards}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtseg:nth-child(1){left:0%;transform-origin:200% 50%;animation-delay:-16ms}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtseg:nth-child(2){left:20%;transform-origin:100% 50%;animation-delay:-38ms}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtseg:nth-child(3){left:40%;transform-origin:0% 50%;animation-delay:-4ms}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtseg:nth-child(4){left:60%;transform-origin:-100% 50%;animation-delay:-30ms}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtseg:nth-child(5){left:80%;transform-origin:-200% 50%;animation-delay:-22ms}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtspark:nth-child(6){left:31%;animation-delay:-46ms}',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtspark:nth-child(7){left:67%;animation-delay:-12ms}',
+      // opacity 必须在前面显式写 1：只在 100% 写 0 的话，CSS 会从 0% 起就线性插值，
+      // 整段塌缩都在同时淡出（实测 160ms 时 opacity 已经掉到 0.365），
+      // 而显像管是"一直亮着、最后一下才没"。
+      '@keyframes dsh-sel-crt-card-a{',
+      '0%{transform:scale(1,1);filter:brightness(1);opacity:1}',
+      '38%{transform:scale(1,1.06);filter:brightness(1.35);opacity:1}',
+      '62%{transform:scale(1,.055);filter:brightness(2.2);opacity:1}',
+      '88%{opacity:1}',
+      '100%{transform:scale(.5,.05);filter:brightness(2.4);opacity:0}}',
+      '@keyframes dsh-sel-crt-line-a{',
+      '0%,52%{opacity:0}',
+      '60%{opacity:1}',
+      '96%{opacity:1}',
+      '100%{opacity:0}}',
+      // 每段：一边往中心收，一边闪断（opacity 阶梯）+ 上下抖 1px
+      '@keyframes dsh-sel-crt-seg-a{',
+      '0%,58%{transform:scaleX(1) translateY(0);opacity:1}',
+      '64%{transform:scaleX(.94) translateY(1px);opacity:1}',
+      '70%{transform:scaleX(.78) translateY(-1px);opacity:.3}',
+      '74%{transform:scaleX(.66) translateY(0);opacity:1}',
+      '80%{transform:scaleX(.44) translateY(1px);opacity:.15}',
+      '84%{transform:scaleX(.34) translateY(0);opacity:1}',
+      '90%{transform:scaleX(.16) translateY(-1px);opacity:.5}',
+      '96%{transform:scaleX(.06) translateY(0);opacity:1}',
+      '100%{transform:scaleX(0) translateY(0);opacity:0}}',
+      // 火花：段子死掉之后还在原位闪两下的残留像素
+      '@keyframes dsh-sel-crt-spark-a{',
+      '0%,74%{opacity:0}',
+      '78%{opacity:1}',
+      '82%{opacity:0}',
+      '88%{opacity:.9}',
+      '94%{opacity:0}',
+      '100%{opacity:0}}',
+      '@media (prefers-reduced-motion:reduce){',
+      '.dsh-sel-vcard{transition:none}.dsh-sel-vcard[data-voiced="1"] .dsh-sel-vbar{animation:none}',
+      '.dsh-sel-vcard[data-off="a"],.dsh-sel-crtline[data-off="a"],',
+      '.dsh-sel-crtline[data-off="a"] .dsh-sel-crtseg,.dsh-sel-crtline[data-off="a"] .dsh-sel-crtspark{',
+      'animation:none!important;opacity:0}',
+      '.dsh-sel-thread{animation:none}}',
     ].join('')
 
     // ────────────────────── Markdown 轻渲染（全 DOM，无 innerHTML） ──────────────────────
@@ -2203,7 +2415,6 @@ window.__ModuleLoader__.load({
         /** 有工具正在跑（等待提示说"正在检索资料"，不显示是哪个工具、查了什么）。 */
         toolBusy: false,
         /** 模型输出了伪造的工具调用格式（已被剥掉）。 */
-        toolResidue: false,
         /** 这次内容是"从历史回放"出来的（不是本次请求）。 */
         fromHistory: false,
         /** 当前选区的本地缓存 key。 */
@@ -2247,6 +2458,12 @@ window.__ModuleLoader__.load({
          * 追问于是永远发 low —— 表现为"推理等级的设置没起作用"。
          */
         stageEffort: '',
+        /**
+         * 首轮/详解期间 host 发的 notice（换档重试、上游偶发错误…）。
+         * 以前首轮那条 SSE 处理器**没有 notice 分支**，host 说的话全被丢掉 ——
+         * 用户只看到"卡了十几秒"，不知道插件正在换档重试。
+         */
+        notice: '',
         /** 网页模式（小窗开关）：复杂问题默认用网页回答。 */
         webAnswer: false,
         /** 追问是否正在流式返回。 */
@@ -2566,6 +2783,16 @@ window.__ModuleLoader__.load({
       var settingsRailButtons = []
       var settingsPanes = []
       var settingsSegs = []
+      /**
+       * 四个格子的文案（关/低/高/最高）。
+       *
+       * 它是**插件的固定词汇**，与模型无关；落到模型的哪个真实档位由 host 按该模型的声明
+       * 实时算（`/models` 每个模型带一份 `effortMap`，见 host 的 mapEffortToModel）。
+       */
+      var SLOT_LABEL = { off: '关', low: '低', high: '高', max: '最高' }
+      var SLOT_ORDER = ['off', 'low', 'high', 'max']
+      /** 设置页里那几行"四格 → 当前模型真实档位"的提示节点（跟着模型实时变）。 */
+      var settingsEffortHints = []
       /** 自绘下拉的菜单节点（挂在抽屉上，重渲染时要一起清掉，否则会叠出第二份浮层）。 */
       var settingsMenus = []
       var settingsFetching = false
@@ -2712,6 +2939,7 @@ window.__ModuleLoader__.load({
           if (forceRoute) entry.filled = false
           fillModelMenu(entry, entry.catalog)
           paintModelPick(entry)
+          paintEffortMapHint()
         })
         fetchRoute(sessionId, isChat).then(applyFollowRoute)
       }
@@ -2840,6 +3068,79 @@ window.__ModuleLoader__.load({
         return (provider ? provider + ' / ' : '') + model
       }
 
+      /**
+       * 设置页那行"四格 → 当前模型的真实档位"。
+       *
+       * 映射是 **host 按模型声明实时算的**：`/models` 里每个模型带一份 `effortMap`
+       * （见 host 的 mapEffortToModel —— 它只吃"这个模型自己声明的档位列表"，
+       * 名字认不出就按位置插值，所以任何用户换任何模型都有落点）。
+       * 客户端只负责显示，插件里**没有**任何按模型写死的表；换模型 / 换会话立刻跟着变。
+       */
+      /** 模型自己给这个档位的名字（清单里没有就用 id）——「思考强度」那行映射提示专用。 */
+      function modelTierNameOf(item, id) {
+        var efforts = (item && item.efforts) || []
+        for (var i = 0; i < efforts.length; i += 1) {
+          if (efforts[i].id === id) return String(efforts[i].name || efforts[i].id)
+        }
+        return String(id)
+      }
+
+      /**
+       * 改「追问」的思考强度 —— **唯一**的写入口（设置页那一行与小窗那个控件共用）。
+       *
+       * 两处读写的是**同一个值**：host 配置 `chatReasoningEffort`（四个格子之一）。
+       * 于是不存在"两边各写各的"，也不需要任何反向映射 —— 一边改，另一边重画一次就同步了。
+       * `state.effort` 只是这个值的**内存镜像**（发请求时随 body.effort 带上，免得存盘还没回来
+       * 就发了请求；列表读到 `stages.chat` 之前也靠它兜底）。
+       */
+      function setChatSlot(slot) {
+        settingsLive.chatReasoningEffort = slot
+        state.effort = slot
+        var entry = settingsByKey.chatReasoningEffort
+        if (entry) {
+          setControlValue('chatReasoningEffort', slot)
+          paintSegPill(entry)
+        }
+        if (modelMenu.getAttribute('data-open') === '1') renderModelMenu()
+        renderSettingsNote('')
+        scheduleSettingsSave()
+      }
+
+      /** 当前「追问」档位：内存镜像 → 配置 → /models 报的配置值（都是四个格子之一）。 */
+      function chatSlot() {
+        return state.effort || settingsLive.chatReasoningEffort || (modelCatalog.stages && modelCatalog.stages.chat) || ''
+      }
+
+      function paintEffortMapHint() {
+        if (!settingsEffortHints.length) return
+        var choice = state.modelChoice
+        if (!choice && modelCatalog.current && modelCatalog.current.provider && modelCatalog.current.model) {
+          choice = { provider: String(modelCatalog.current.provider), model: String(modelCatalog.current.model) }
+        }
+        var item = choice ? catalogItemOf(choice.provider, choice.model) : null
+        var text = ''
+        if (!item) {
+          text = modelCatalog.error
+            ? '读不到模型清单（' + modelCatalog.error + '）：暂时按原档位发送，被拒时自动换档'
+            : '正在读取该模型的档位…'
+        } else if (item.hasReasoning === false) {
+          text = '该模型不支持思考强度：这四个格子对它不生效（不会发送档位）'
+        } else if (item.effortMap && item.effortMap[SLOT_ORDER[0]]) {
+          var parts = []
+          for (var i = 0; i < SLOT_ORDER.length; i += 1) {
+            var slot = SLOT_ORDER[i]
+            var actual = item.effortMap[slot]
+            // 右边用**模型自己的档位名**（Off/Low/Xhigh…），不要换成我们的「低/高」——
+            // 否则"关 → 低"这种看着像恒等映射，实际落到的是模型的 low 档
+            parts.push(SLOT_LABEL[slot] + ' → ' + (actual ? modelTierNameOf(item, actual) : '—'))
+          }
+          text = '当前模型：' + parts.join(' · ')
+        } else {
+          text = '暂未读到该模型声明的档位：先按原档位发送，被拒时自动换档重试'
+        }
+        for (var h = 0; h < settingsEffortHints.length; h += 1) settingsEffortHints[h].textContent = text
+      }
+
       function settingsDirtyCount() {
         var n = 0
         Object.keys(settingsLive).forEach(function (key) {
@@ -2882,6 +3183,8 @@ window.__ModuleLoader__.load({
         })
         updateSettingDependencies()
         syncComposerModel()
+        // 「追问」档位的内存镜像跟着配置走（四个格子之一；列表读到 stages.chat 之前也靠它兜底）
+        state.effort = settingsLive.chatReasoningEffort || ''
         applySelectionLimit(settingsLive)
         if (!state.modelChoice) refreshModelRow(settingsByKey.modelChoice, true)
         bridgeOn = settingsLive.bridgeSidebarPreview !== false
@@ -2906,6 +3209,7 @@ window.__ModuleLoader__.load({
         syncComposerModel()
         var entry = settingsByKey.modelChoice
         if (entry) { paintModelPick(entry); repaintModelMenu(entry) }
+        paintEffortMapHint()
         loadSettings(false)
         renderSettingsNote('')
         scheduleSettingsSave()
@@ -2963,7 +3267,13 @@ window.__ModuleLoader__.load({
           entry.cells[i].setAttribute('aria-checked', picked ? 'true' : 'false')
           if (picked) on = entry.cells[i]
         }
-        if (!on) return
+        // 值不在四格里（小窗选了模型自己的 medium/xhigh 这种）：一个格子都不点亮、
+        // 滑块也收起来 —— 留着上一次的位置会假装它还选中着
+        if (!on) {
+          entry.pill.style.display = 'none'
+          return
+        }
+        entry.pill.style.display = ''
         entry.pill.style.left = String(on.offsetLeft) + 'px'
         entry.pill.style.width = String(on.offsetWidth) + 'px'
       }
@@ -3047,7 +3357,7 @@ window.__ModuleLoader__.load({
           var entry = { spec: spec, row: row, seg: seg, pill: pill, cells: [] }
           var options = spec.options || []
           options.forEach(function (option) {
-            var cell = el('button', 'dsh-sel-segcell', { off: '关', low: '低', high: '高', max: '最高' }[option] || option)
+            var cell = el('button', 'dsh-sel-segcell', SLOT_LABEL[option] || option)
             cell.type = 'button'
             cell.setAttribute('role', 'radio')
             cell.setAttribute('data-value', option)
@@ -3056,7 +3366,8 @@ window.__ModuleLoader__.load({
               seg.setAttribute('data-value', option)
               paintSegPill(entry)
               settingsLive[spec.key] = option
-              if (spec.key === 'chatReasoningEffort') { state.effort = option; writeStore(EFFORT_KEY, option); paintModelPill() }
+              // 与小窗那个控件共用同一个写入口（同一份数据：配置里的 chatReasoningEffort）
+              if (spec.key === 'chatReasoningEffort') { setChatSlot(option); paintModelPill() }
               renderSettingsNote('')
               scheduleSettingsSave()
             })
@@ -3127,6 +3438,7 @@ window.__ModuleLoader__.load({
         settingsRailButtons = []
         settingsPanes = []
         settingsSegs = []
+        settingsEffortHints = []
         for (var m = 0; m < settingsMenus.length; m += 1) {
           if (settingsMenus[m].parentNode) settingsMenus[m].parentNode.removeChild(settingsMenus[m])
         }
@@ -3156,6 +3468,14 @@ window.__ModuleLoader__.load({
               if (item) block.appendChild(buildSettingRow(item))
             })
             if (part.note) block.appendChild(el('p', 'dsh-sel-ssectionnote', part.note))
+            // 「思考强度」那一节多一行：这四个格子**现在**落到当前模型的哪些档位上。
+            // 映射由 host 按模型声明实时算（换模型 / DSH 升级换 adapter 都会跟着变）。
+            if (part.keys.indexOf('chatReasoningEffort') >= 0) {
+              var effortHint = el('p', 'dsh-sel-ssectionnote dsh-sel-effortmap', '')
+              effortHint.setAttribute('data-effortmap', '1')
+              block.appendChild(effortHint)
+              settingsEffortHints.push(effortHint)
+            }
             section.appendChild(block)
           })
           settingsBody.appendChild(section)
@@ -3167,6 +3487,7 @@ window.__ModuleLoader__.load({
         updateSettingDependencies()
         syncComposerModel()
         applySelectionLimit(values)
+        paintEffortMapHint()
         showSettingsTab(groups.length ? groups[0].id : '')
       }
 
@@ -3405,7 +3726,6 @@ window.__ModuleLoader__.load({
             if (!payload || payload.ok === false) throw new Error('恢复默认失败')
             applyServerValues(payload.values, sent)
             state.effort = settingsLive.chatReasoningEffort || ''
-            writeStore(EFFORT_KEY, state.effort)
             applyPillPrefs({ enabled: settingsLive.pillEnabled, idleMs: settingsLive.pillIdleMs })
             bridgeOn = settingsLive.bridgeSidebarPreview !== false
             if (bridgeOn) scheduleBridgeScan()
@@ -3437,6 +3757,9 @@ window.__ModuleLoader__.load({
        */
       /** 开窗后"还没聚焦过输入框"（见 focusComposerOnce）。 */
       var askFocusPending = false
+      /** 调试：最后一次"没聚焦"卡在哪一步（-1 表示聚焦成功）。 */
+      /** 调试：最后一次"没聚焦"卡在哪一步（成功时是 'ok'）。自动聚焦这类问题很难从外部看出来。 */
+      var focusBail = ''
       var offSlot = null
       if (ctx.slots && typeof ctx.slots.inject === 'function') {
         try {
@@ -3763,18 +4086,23 @@ window.__ModuleLoader__.load({
 
       function showButton(rect) {
         // 浮标也在同一套配色下：它的底色是"页面背景"（浮层自身透明），按它判深浅
-        if (!panelOpen) layer.setAttribute('data-theme', isDarkSurface(layer) ? 'dark' : 'light')
+        if (!panelOpen) layer.setAttribute('data-theme', currentSurfaceTheme())
         // 只在"浮现"那一次播动效；已经可见时（划选范围被拖动、键盘调整）只平移，避免一直闪
         if (placeFloat(button, rect)) {
           setButtonPop(false)
           void button.offsetWidth // 强制重排，让动画能重播
           setButtonPop(true)
         }
+        // 有选区了：开始看"输入法是不是正在语音输入"（幂等，重复调用无副作用）
+        startMicWatch()
       }
 
       function hideButton() {
         button.style.display = 'none'
         setButtonPop(false)
+        // 浮标收了就没什么可等的了 —— 但语音卡开着时**不能停**：
+        // 卡片本身就是"检测到开麦"的结果，它还要靠轮询判断"说完了没有"
+        if (!vcardState.open) stopMicWatch()
       }
 
       /**
@@ -3806,11 +4134,1041 @@ window.__ModuleLoader__.load({
           void quoteButton.offsetWidth
           setQuotePop(true)
         }
+        // 浮标亮着就盯"输入法有没有开麦"（幂等）：这时开麦的语义是"引用这段 + 把光标移进小窗"，
+        // 见 autoQuoteFromVoice。没浮标就没人问 —— 探针也跟着停（它只在被问时活着）。
+        startMicWatch()
+      }
+
+      // ══════════════════ 语音卡：选中文字 + 输入法正在语音输入 ══════════════════
+      //
+      // 场景：用户划选一段文字，同时正用输入法（豆包）对着麦克风说话。
+      // 这时在那段文字**下方**弹一张临时输入框并自动聚焦 —— 输入法"上屏"的文字会直接
+      // 落进这个框（IME 只认焦点元素），所以我们**不需要**读它的转写结果，也不需要任何
+      // 输入法权限。点发送就跳过翻译与详解，直接进追问。
+      //
+      // 三条前提，缺一不可（缺了就完全不弹，不装作在等）：
+      //   ① 选区在本文档里（原生 App 里的选区我们既看不到、也接不住上屏）；
+      //   ② 占着麦克风的是已知输入法（IME_BUNDLES）；
+      //   ③ 页面有焦点、且用户没在别处打字（否则会把人家在别处的听写抢过来）。
+      //
+      // 时序是整件事成立的关键：检测到开麦（≤400ms）→ 弹卡 + 抢焦点 → 用户继续说 →
+      // **松手时**输入法才上屏。抢焦点发生在开始时、上屏发生在结束时，中间有几秒余量；
+      // 反过来"等检测到文字再弹框"就已经晚了 —— 字会落到原来那个焦点里去。
+      //
+      // ── 两条路，按"小窗开没开"分（2026-10-09 起）──
+      //   · 小窗**没开**：上面这套语音卡（选区是"要解读的对象"，说完进一个新的追问）。
+      //   · 小窗**开着**：划词浮出的是「❝ 引用」浮标，这时开麦等于**点一下那个浮标** ——
+      //     选中的文字挂进小窗、光标移到小窗输入框，输入法上屏的字直接落进小窗，
+      //     和引用一起成为下一条追问（`autoQuoteFromVoice`）。
+      //     两种情形互斥：面板一开，`state.selection` 就被清成 null，语音卡那套根本不启动。
+      //     轮询也只跟着浮标走（浮标亮着才问 /api/mic），没浮标就没人问。
+
+      var vcard = null
+      var vcardBox = null
+      var vcardSend = null
+      /** 关机动画那条亮线（懒建）。 */
+      var crtLine = null
+      /**
+       * 发送那一刻卡片的矩形（视口坐标）—— 小窗据此"从那一格长出来"。
+       * 只在 sendVCard 里写、只在 showPanel 里消费（用完即清）：其余开窗路径（划词解读 /
+       * 历史回放 / 升格）这里是 null，因此不受影响、保持原来的"瞬开"。
+       */
+      var vcardHandoff = null
+      /** 交接动画的兜底定时器与 transitionend 句柄（收尾要把内联的 transform/transition 清干净）。 */
+      var panelGrowTimer = null
+      var panelGrowHandler = null
+      /**
+       * 这一次录音周期里，"开麦 → 自动加引用 + 移光标"处理过没有。
+       *
+       * 为什么要这个：麦克风是每 200ms 问一次的，同一次录音会被问到十几遍 ——
+       * 不抑制的话引用会被反复加（虽然 addQuote 对重复文本会挡掉，但 hideQuoteButton /
+       * focusAskBox 会被反复执行，输入法的输入上下文也会被反复重绑）。
+       * 与 vcardState.suppress 同一套思路：录音**停止**时复位（见 micTick 的 !matchingIme 分支）。
+       */
+      var quoteVoiceHandled = false
+      /** 选中提示：下划线层 / 牵引线 / 牵引线起点的小圆点（懒建）。 */
+      var selMark = null
+      var selThread = null
+      var selThreadPath = null
+      var selThreadDot = null
+      var vcardState = {
+        open: false,
+        /** 打开时的选区快照（滚动 / 改窗口大小时按它重算位置）。 */
+        range: null,
+        /**
+         * 打开时的锚点矩形（视口坐标）。
+         *
+         * 侧边栏网页那条路**没有 Range**（不透明源帧里的选区拿不出来），定位只能靠桥换算好的
+         * 矩形 —— 新的 selection 消息会刷新它，于是帧内滚动 / 重报时卡片跟着走。
+         */
+        anchorRect: null,
+        timer: null,
+        /** 上一次 /mic 还没回来（不叠请求）。 */
+        busy: false,
+        /**
+         * 用户刚取消过这次录音（Esc / 点空白）：在**这次录音结束之前**不再自动弹卡片。
+         * 没有它的话：Esc 收卡片 → 恢复浮标 → 下一拍轮询发现"还在录" → 卡片又弹回来，
+         * Esc 看起来像失灵（实测就是这么暴露出来的）。等 !capturing 才解除。
+         */
+        suppress: false,
+        /** 形变期间钉住正文宽度用的兜底定时器 / transitionend 句柄。 */
+        unpinTimer: null,
+        unpinHandler: null,
+        /** 正在播关机动画（这段时间内卡片还没真正隐藏）。 */
+        closing: false,
+        /** 关机动画的兜底定时器 / animationend 句柄。 */
+        crtTimer: null,
+        crtHandler: null,
+        /** "等文字定稿"的观察（松手后豆包还会智能整理，见 VOICE_SETTLE_MS）。 */
+        settleTimer: null,
+        settleLastText: '',
+        settleStableAt: 0,
+        settleDeadline: 0,
+        /** 收到 compositionend 后的短定时器（见 VOICE_SETTLE_COMPOSE_MS）。 */
+        settleComposeTimer: null,
+      }
+
+      function ensureVCard() {
+        if (vcard) return
+        vcard = el('div', 'dsh-sel-vcard')
+        vcard.setAttribute('data-voiced', '0')
+        vcard.setAttribute('data-text', '0')
+        // 「在听」那根 3px 竖条：作为第一个 flex 子元素，正文排在它右边（占 3+9=12px）
+        vcard.appendChild(el('div', 'dsh-sel-vbar'))
+        vcardBox = el('textarea', 'dsh-sel-vcard-box')
+        vcardBox.rows = 1
+        vcardBox.placeholder = '正在听…'
+        vcardBox.setAttribute('spellcheck', 'false')
+        vcardSend = el('button', 'dsh-sel-vcard-send')
+        vcardSend.type = 'button'
+        vcardSend.title = '直接追问（跳过翻译与详解）'
+        vcardSend.textContent = '↑'
+        vcard.appendChild(vcardBox)
+        vcard.appendChild(vcardSend)
+        layer.appendChild(vcard)
+        listen(vcardBox, 'input', syncVCardText)
+        // 输入法上屏有的环境只发 compositionend 而不发 input：补一次（幂等）
+        listen(vcardBox, 'compositionend', syncVCardText)
+        // 「等定稿」的主信号：输入法的智能整理**走合成 API 提交**（实测 8 次录音里 6 次都有
+        // inputType=insertCompositionText + compositionend）。收到就在短窗口后决定，
+        // 不必等兜底的 500ms 静默；连着来两次（标点一次、改词一次）就重新计时。
+        listen(vcardBox, 'compositionend', function () {
+          if (!vcardState.settleTimer) return
+          if (vcardState.settleComposeTimer) clearTimeout(vcardState.settleComposeTimer)
+          vcardState.settleComposeTimer = setTimeout(function () {
+            vcardState.settleComposeTimer = null
+            if (!vcardState.open || !vcardState.settleTimer) return
+            var settled = String((vcardBox && vcardBox.value) || '')
+            stopVoiceSettle()
+            finishVoiceSettle(settled)
+          }, VOICE_SETTLE_COMPOSE_MS)
+        })
+        listen(vcardBox, 'keyup', syncVCardText)
+        listen(vcardBox, 'keydown', function (event) {
+          // Enter 发送、Shift+Enter 换行；输入法确认候选词的那个 Enter 不算（与追问框同一套判断）
+          if (event.key === 'Enter' && !event.shiftKey && !event.isComposing && event.keyCode !== 229) {
+            event.preventDefault()
+            sendVCard()
+          }
+        })
+        listen(vcardSend, 'click', function (event) {
+          event.preventDefault()
+          event.stopPropagation()
+          sendVCard()
+        })
+        // 卡片里的鼠标动作别冒泡出去：外面那套"点别处就收浮标"的逻辑会把卡收掉
+        listen(vcard, 'mousedown', function (event) {
+          event.stopPropagation()
+        })
+        // ④ 点屏幕空白处收卡片。用 capture：卡片自己的 mousedown 是冒泡阶段，
+        // 这里先跑，所以判断"在不在卡片里"必须用 contains 而不是靠冒泡顺序。
+        listen(document, 'mousedown', function (event) {
+          if (!vcardState.open) return
+          var target = event.target
+          if (target && (target === vcard || (vcard.contains && vcard.contains(target)))) return
+          vcardState.suppress = true
+          closeVCard(true)
+        }, true)
+        listen(window, 'scroll', function () {
+          if (vcardState.open) repositionVCard()
+        }, true)
+        listen(window, 'resize', function () {
+          if (vcardState.open) repositionVCard()
+        })
+      }
+
+      /** 有字了才摆出发送键；高度跟着内容长（最多 4 行，再多内部滚动并停在最新一行）。 */
+      function syncVCardText() {
+        if (!vcard || !vcardBox) return
+        vcard.setAttribute('data-text', String(vcardBox.value || '').trim() ? '1' : '0')
+        growVCardBox()
+      }
+
+      /**
+       * 形变结束后解开正文宽度（回到 flex 布局）。
+       *
+       * 形变期间正文宽度被钉在终值（见 openVCard ②）：卡片变宽只是"揭开"它。
+       * 不解开的话，之后打字时正文宽度不会再跟着卡片走。
+       */
+      function unpinVCardBox() {
+        if (vcardState.unpinTimer) {
+          clearTimeout(vcardState.unpinTimer)
+          vcardState.unpinTimer = null
+        }
+        if (vcard && vcardState.unpinHandler) {
+          vcard.removeEventListener('transitionend', vcardState.unpinHandler)
+          vcardState.unpinHandler = null
+        }
+        if (!vcardBox) return
+        vcardBox.style.flex = ''
+        vcardBox.style.width = ''
+      }
+
+      /**
+       * 排一次"解开正文宽度"。
+       *
+       * transitionend 是主路径；另挂一个兜底定时器 —— 形变被打断（切窗口、立刻关卡片）时
+       * transitionend 可能永远不来，正文宽度就会一直钉着。
+       */
+      function scheduleVCardUnpin() {
+        if (!vcard) return
+        if (vcardState.unpinTimer) {
+          clearTimeout(vcardState.unpinTimer)
+          vcardState.unpinTimer = null
+        }
+        if (vcardState.unpinHandler) {
+          vcard.removeEventListener('transitionend', vcardState.unpinHandler)
+          vcardState.unpinHandler = null
+        }
+        vcardState.unpinHandler = function (event) {
+          if (event.target !== vcard) return
+          if (event.propertyName === 'width') unpinVCardBox()
+          // ⚠️ 这里**不要**重画选中提示。
+          // 曾经加过"形变结束后重画一次"当安全网，结果是**闪一下**：
+          // 重画会先 clearSelectionMarkers()（牵引线 display:none）再重画（block），
+          // 而 display:none → block 会让生长动画**重放** —— 用户看到的就是"曲线生成后闪一下、
+          // 再重新长一遍"。而且卡片形变会分别触发 top 和 height 两次，所以闪两次。
+          // 现在终点用的是算出来的**最终位置**（不读卡片当下的 rect），本来就不需要这次重画。
+        }
+        vcard.addEventListener('transitionend', vcardState.unpinHandler)
+        vcardState.unpinTimer = later(unpinVCardBox, 420)
+      }
+
+      function growVCardBox() {
+        if (!vcardBox || !vcard) return
+        vcardBox.style.height = 'auto'
+        var content = Math.max(24, Math.min(vcardBox.scrollHeight, VCARD_TEXT_MAX))
+        vcardBox.style.height = content + 'px'
+        vcardBox.style.overflowY = vcardBox.scrollHeight > VCARD_TEXT_MAX ? 'auto' : 'hidden'
+        if (vcardBox.scrollHeight > VCARD_TEXT_MAX) vcardBox.scrollTop = vcardBox.scrollHeight
+        vcard.style.height = (content + VCARD_PAD_Y) + 'px'
+      }
+
+      /**
+       * 卡片几何：右缘钉在浮标右缘（横向不跳），左缘展开到**正文列左边**。
+       * 宽度不是拍脑袋定的 —— 它是"浮标右缘 − 正文列左边"，所以展开后左缘正好和正文对齐。
+       * 纵向落在整块文字下方（不是选中那一行下方）：否则会压住下面那行正文。
+       */
+      function vcardGeometry() {
+        var range = vcardState.range
+        var rect = null
+        if (range) {
+          try {
+            rect = range.getBoundingClientRect()
+          } catch (error) {
+            rect = null
+          }
+        }
+        // 侧边栏网页那条路没有 Range：锚点用桥换算好的视口矩形（两者都是视口坐标，可直接混用）。
+        if ((!rect || (!rect.width && !rect.height)) && vcardState.anchorRect) rect = vcardState.anchorRect
+        if (!rect || (!rect.width && !rect.height)) return null
+        // 帧内选区只知道自己那一段（"块"是帧内的事，父页面看不见）：整块就用它自己，
+        // 于是"落在整段文字下方"这条规则在网页里退化成"落在这段选区下方"。
+        var blockRect = (range && selectionBlockRect(range)) || rect
+        var right = Math.min(rect.right, Math.max(8, window.innerWidth - 8))
+        var width = VCARD_W
+        var left = Math.max(8, right - width)
+        // ⚠️ 纵向必须按**整个选区**的底边算，不能只按"选区起点所在的块"：
+        // 选中跨多个段落 / 代码块时，起点那个块的底边落在选区**中间**，
+        // 卡片就会压在剩下的选中文字上（用户实测："选大段文字时卡片有概率遮住文字"）。
+        var below = Math.max(blockRect.bottom, rect.bottom) + 22
+        var top = below
+        var cardHeight = 42
+        try {
+          var own = vcard && vcard.getBoundingClientRect()
+          if (own && own.height) cardHeight = own.height
+        } catch (error) {
+          /* 读不到就按单行 42 估 */
+        }
+        // 下方放不下就翻到选区上方；上方也放不下（选区比视口还高）就贴视口底边 ——
+        // 宁可压在可见文字的下缘，也不要把卡片推到屏幕外（那样等于没弹）
+        if (below + cardHeight > window.innerHeight - 8) {
+          var above = rect.top - cardHeight - 22
+          top = above >= 8 ? above : Math.max(8, window.innerHeight - cardHeight - 16)
+        }
+        return { left: left, top: top, width: width, height: cardHeight }
+      }
+
+      /** 选区所在的那个"块"（段落 / 列表项 / 单元格）—— 卡片挂在它的下方。 */
+      function selectionBlockRect(range) {
+        var node = range.startContainer
+        var element = node && node.nodeType === 1 ? node : node && node.parentElement
+        while (element && element !== document.body && element !== document.documentElement) {
+          var display = ''
+          try {
+            display = window.getComputedStyle(element).display
+          } catch (error) {
+            display = ''
+          }
+          if (display === 'block' || display === 'list-item' || display === 'table-cell') {
+            return element.getBoundingClientRect()
+          }
+          element = element.parentElement
+        }
+        return null
+      }
+
+      function applyVCardGeometry(geo) {
+        if (!vcard || !geo) return
+        vcard.style.left = Math.round(geo.left) + 'px'
+        vcard.style.top = Math.round(geo.top) + 'px'
+        vcard.style.width = Math.round(geo.width) + 'px'
+      }
+
+      /** 滚动 / 改窗口时重新贴住那段文字（关掉过渡，免得跟着滚"飘"）。 */
+      function repositionVCard() {
+        var geo = vcardGeometry()
+        if (!vcard || !geo) return
+        vcard.style.transition = 'none'
+        applyVCardGeometry(geo)
+        void vcard.offsetWidth
+        vcard.style.transition = ''
+        // 选中提示是按视口坐标摆的，滚动 / 改窗口要跟着重画
+        if (vcardState.open) paintSelectionMarkers(false)
+      }
+
+      /**
+       * 从浮标那一格**形变**过来：先按浮标的几何摆好（关过渡），强制重排，再切到最终几何。
+       * 于是"下移 + 展开"是一段连续动画，而不是旧的消失、新的出现。
+       */
+      function openVCard() {
+        if (vcardState.open || panelOpen) return
+        if (!state.selection) return
+        // ⚠️ 两条来源的定位依据不一样，不能只认 Range：
+        //   · 本文档里的选区 → 有 Range（几何 / 选中提示都按它算）；
+        //   · 侧边栏网页（不透明源 iframe）→ 父页面**拿不到那个 Range**，只有桥换算好的
+        //     视口矩形（state.selection.rect）和桥采好的上下文 —— 见 vcardGeometry / sendVCard。
+        if (!state.selection.range && state.selection.source !== 'iframe') return
+        // 页面没焦点 / 用户正在别处打字：不抢 —— 抢了就是把人家别处的听写拽过来
+        if (!hasFocusEvidence(state.selection)) return
+        if (isTypingTarget(document.activeElement)) return
+        ensureVCard()
+        // 上一轮的关机动画可能还没收尾（用户马上又划了新文字、又开麦）：先收干净再开
+        if (vcardState.closing || vcardState.crtTimer) finishCrtOff()
+        vcardState.range = state.selection.range || null
+        vcardState.anchorRect = state.selection.rect || null
+        var geo = vcardGeometry()
+        if (!geo) return
+        var pillRect = button.getBoundingClientRect()
+        vcardState.open = true
+        vcard.style.transition = 'none'
+        vcard.style.display = 'flex'
+        // ── ① 先在**最终宽度**下量一次（同一帧内完成，用户看不见）──
+        // 为什么必须在这个宽度下量：正文按宽度折行，在浮标那条窄缝（~86px）里量出来的行数会暴涨
+        // （踩过：单行卡被顶到 111px）。量完之后形变全程不再读 scrollHeight。
+        vcard.style.width = Math.round(geo.width) + 'px'
+        void vcard.offsetWidth
+        var finalBoxHeight = Math.max(24, Math.min(vcardBox.scrollHeight, VCARD_TEXT_MAX))
+        var finalCardHeight = finalBoxHeight + VCARD_PAD_Y
+        var finalBoxWidth = Math.round(vcardBox.getBoundingClientRect().width)
+        // ── ② 形变期间把**正文宽度钉死** ──
+        // 卡片变宽只是"揭开"正文，正文自己不再逐帧重新折行 —— 这是"下移展开"卡顿的主因
+        // （每帧重排 textarea 里的文本）。钉死之后，卡片变宽只是一次裁剪，代价小得多。
+        if (finalBoxWidth > 0) {
+          vcardBox.style.flex = '0 0 auto'
+          vcardBox.style.width = finalBoxWidth + 'px'
+        }
+        vcardBox.style.height = finalBoxHeight + 'px'
+        vcardBox.style.overflowY = finalBoxHeight >= VCARD_TEXT_MAX ? 'auto' : 'hidden'
+        // ── ③ 回到浮标那一格：位置 / 宽 / 高 / 圆角都从那里出发 ──
+        vcard.style.width = Math.round(pillRect.width || 86) + 'px'
+        vcard.style.left = Math.round(pillRect.left) + 'px'
+        vcard.style.top = Math.round(pillRect.top) + 'px'
+        vcard.style.height = Math.round(pillRect.height || 28) + 'px'
+        vcard.style.borderRadius = '999px'
+        markVCardListening(true)
+        void vcard.offsetWidth
+        // ── ④ 开过渡，走向终态 ──
+        // 宽度这次**也参与**：上一版它不参与，第一帧就从 86px 跳到 460px（用户报的"跳变"）。
+        vcard.style.transition = ''
+        vcard.style.borderRadius = ''
+        vcard.style.left = Math.round(geo.left) + 'px'
+        vcard.style.top = Math.round(geo.top) + 'px'
+        vcard.style.width = Math.round(geo.width) + 'px'
+        vcard.style.height = finalCardHeight + 'px'
+        scheduleVCardUnpin()
+        // 卡片打开后才画选中提示（选中/浮标阶段不画：那时原生底纹还在）
+        ensureSelectionMarkers()
+        paintSelectionMarkers(true)
+        hideButton()
+        // 卡片开着期间必须继续看麦克风：既要判断"这次录音结束了"（停掉呼吸），
+        // 也要能接住"又按了一次 Fn"（重新标记在听）。幂等，正常路径上计时器本来就在跑。
+        startMicWatch()
+        // 关键一步：输入法上屏只认焦点元素，焦点必须在我们这个框里
+        focusVCard()
+        // 注意：焦点一转移，原生选区就被浏览器清掉了，于是**卡片开着时看不到选中底纹**。
+        // 这是已知取舍：补底纹的两条路（CSS Custom Highlight / 自绘色块）都被否掉了 ——
+        // 前者只有 Chromium 系支持，后者是盖在字上的色块。要恢复就从这里接回去。
+      }
+
+      /**
+       * 「在听」标记与空框占位文案。
+       *
+       * 麦克风一松开就必须停掉呼吸 —— 否则卡片还在泛青呼吸，等于在说"我还在听"，
+       * 而这时输入法早就松手了。空框的占位也跟着换（"正在听…" → "直接打字也行…"），
+       * 不然那句话同样是在撒谎。
+       */
+      function markVCardListening(on) {
+        if (!vcard) return
+        vcard.setAttribute('data-voiced', on ? '1' : '0')
+        if (!vcardBox) return
+        if (String(vcardBox.value || '').trim()) return
+        vcardBox.placeholder = on ? '正在听…' : '直接打字也行…'
+      }
+
+      function focusVCard() {
+        if (!vcardBox) return
+        try {
+          vcardBox.focus({ preventScroll: true })
+        } catch (error) {
+          try {
+            vcardBox.focus()
+          } catch (inner) {
+            /* 桩环境没有 focus：不影响逻辑 */
+          }
+        }
+      }
+
+      /**
+       * 收起卡片。
+       *
+       * **不还回「✦ 解读」浮标**（用户要求）：取消就是取消 —— 浮标再冒出来，等于在问
+       * "要不要解读"，而用户刚表达的是"这次算了"。要解读就重新划一次。
+       * 发送那条路也不还（它直接开面板了）。
+       */
+      /** 选中提示的元素（懒建）：下划线层 + 牵引线（SVG 贝塞尔）+ 锚点圆。 */
+      function ensureSelectionMarkers() {
+        if (selMark) return
+        selMark = el('div', 'dsh-sel-umark')
+        layer.appendChild(selMark)
+        var NS = 'http://www.w3.org/2000/svg'
+        selThread = document.createElementNS(NS, 'svg')
+        selThread.setAttribute('class', 'dsh-sel-thread')
+        selThreadPath = document.createElementNS(NS, 'path')
+        selThreadPath.setAttribute('class', 'dsh-sel-threadpath')
+        selThreadPath.setAttribute('fill', 'none')
+        selThread.appendChild(selThreadPath)
+        selThreadDot = document.createElementNS(NS, 'circle')
+        selThreadDot.setAttribute('class', 'dsh-sel-threaddot')
+        selThreadDot.setAttribute('r', '2.6')
+        selThreadDot.setAttribute('stroke-width', '1.5')
+        selThread.appendChild(selThreadDot)
+        layer.appendChild(selThread)
+      }
+
+      /**
+       * 画"选中提示"：下划线（逐行矩形、两端渐隐）+ 从选区牵引到卡片的虚线。
+       *
+       * **只在卡片打开后才出现**（用户定的）：选中/浮标阶段不画 —— 那时原生底纹还在，
+       * 两者同时出现会互相打架。等底纹被抢焦点吃掉，这两样正好接上。
+       *
+       * 下划线按 range 的**逐行矩形**贴（多行选区就是多条），不是整块一条线。
+       * 牵引线从选区**末行中点**竖直落到卡片上缘 —— 这一条会穿过下方文字（用户接受），
+       * 所以它是 2px 宽的竖条 + repeating-gradient 虚线，而不是实线。
+       */
+      function paintSelectionMarkers(grow) {
+        if (!selMark) return
+        clearSelectionMarkers()
+        var range = vcardState.range
+        if (!vcard || !vcardState.open) return
+        if (!range && !vcardState.anchorRect) return
+        /**
+         * 侧边栏网页那条路（没有 Range）：**只画牵引线，不画下划线**。
+         *
+         * 两个理由：① 逐行矩形在帧内，父页面拿不到（桥只报了一个锚点矩形）；
+         * ② 帧内原生底纹是否还在由浏览器说了算 —— 万一还在，我们按估算位置再画一条
+         * 下划线就是"划两层"（本文档那条路当初踩过同一个坑）。
+         * 牵引线是独立的一条线，不存在这个冲突，所以留着：卡片和那段文字之间得有可见的联系。
+         */
+        var fromFrame = !range && !!vcardState.anchorRect
+        var rects = fromFrame ? null : range.getClientRects ? range.getClientRects() : null
+        if (!fromFrame && (!rects || !rects.length)) return
+        var accent = 'var(--sel-a1)'
+        // ⚠️ 必须先**按行归并**再画：
+        // 一行里如果有行内元素（<code>、粗体、链接），getClientRects() 会给出**多个矩形**，
+        // 而且它们的高度 / 底边各不相同 —— 按矩形各画一条就会"划两层"，
+        // 渐隐也会出现在行中间（用户实测的两个问题，同一个根因）。
+        // ⚠️ 第一步：丢掉"容器矩形"。
+        // 选区跨**整块**时，getClientRects() 会把块级盒子也返回 —— 一个覆盖整段的高矩形
+        // （实测：一段两行会额外给出 h=53 的块盒，一个代码块给出 h=80 的块盒）。
+        // 它会把段内所有行吞进一组，结果整段只画一条下划线、很多行没线（用户实测）。
+        // 判据用高度中位数：行片段的高度都接近行高，块盒是它的数倍。
+        // ⚠️ 这一整段只在有 `rects` 时跑：帧内那条根本没有逐行矩形（rects = null），
+        // 它只画下面的牵引线。
+        var lines = []
+        if (!fromFrame) {
+          var heights = []
+          for (var h = 0; h < rects.length; h += 1) {
+            var probe = rects[h]
+            if (probe && probe.width) heights.push(probe.bottom - probe.top)
+          }
+          heights.sort(function (a, b) {
+            return a - b
+          })
+          var median = heights.length ? heights[Math.floor(heights.length / 2)] : 0
+          var maxLineHeight = median > 0 ? median * 1.8 : Infinity
+          for (var i = 0; i < rects.length; i += 1) {
+            var rect = rects[i]
+            if (!rect || !rect.width) continue
+            if (rect.bottom - rect.top > maxLineHeight) continue
+            var height = rect.bottom - rect.top
+            var center = rect.top + height / 2
+            var line = null
+            for (var j = 0; j < lines.length; j += 1) {
+              var group = lines[j]
+              var groupHeight = group.bottom - group.top
+              var groupCenter = group.top + groupHeight / 2
+              // ⚠️ 判"同一行"必须看**垂直中心**，不能看重叠面积：
+              // 行内 code 的盒子可能比整行还高（行高 1.8 时尤其明显），
+              // 按重叠判会把**下一行**也吞进同一组 → 那几行就没有下划线了（用户实测）。
+              // 中心距的容差取"较矮者的一半"：同一行的元素中心几乎重合，
+              // 相邻行的中心差至少一个行高，两者区分得很干净。
+              if (height > 0 && groupHeight > 0 && Math.abs(groupCenter - center) <= Math.min(groupHeight, height) * 0.5) {
+                line = group
+                break
+              }
+            }
+            if (line) {
+              line.left = Math.min(line.left, rect.left)
+              line.right = Math.max(line.right, rect.right)
+              line.top = Math.min(line.top, rect.top)
+              line.bottom = Math.max(line.bottom, rect.bottom)
+            } else {
+              lines.push({ left: rect.left, right: rect.right, top: rect.top, bottom: rect.bottom })
+            }
+          }
+        }
+        for (var k = 0; k < lines.length; k += 1) {
+          var row = lines[k]
+          var mark = el('div', 'dsh-sel-uline')
+          mark.style.left = Math.round(row.left) + 'px'
+          mark.style.top = Math.round(row.bottom + 3) + 'px'
+          mark.style.width = Math.round(row.right - row.left) + 'px'
+          // U3：两端渐隐 —— 归并之后就是"一行的两端"，不会再出现在行中间
+          mark.style.background =
+            'linear-gradient(90deg,transparent,' + accent + ' 12%,' + accent + ' 88%,transparent)'
+          selMark.appendChild(mark)
+        }
+        var first = fromFrame ? vcardState.anchorRect : lines[0]
+        var last = fromFrame ? vcardState.anchorRect : lines[lines.length - 1]
+        var geo = vcardGeometry()
+        if (!first || !last || !geo) return
+        // 终点用**算出来的最终位置**（geo.top），不是卡片此刻的 rect ——
+        // 开卡片时卡片还在从"解读按钮"那一格形变过来，读当下的 rect 会先指到按钮上，
+        // 等形变结束才跳过去（用户："慢半拍""一开始不要连接到解读按钮上"）。
+        // 所以这里一律瞄准最终位置；形变期间不需要跟随（形变结束后那次重画只是安全网）。
+        var cardTop = geo.top
+        var above = cardTop < first.top
+        var anchor = above ? first : last
+        var sx = (anchor.left + anchor.right) / 2
+        var sy = above ? anchor.top - 2 : anchor.bottom + 2
+        // 终点：卡片上（下）缘，x 落在卡片宽度内、左右各留 24px；
+        // **多探进卡片 4px** —— SVG 在卡片下层，多出来那段被卡片盖住，视觉上正好接住。
+        var endY = above ? cardTop + (geo.height || 42) + 4 : cardTop + 4
+        var endX = Math.max(geo.left + 24, Math.min(sx, geo.left + geo.width - 24))
+        // 可见的贝塞尔：两端各一个反向的横向控制量 → S 形（原来控制点和端点同 x，是直线）
+        var dy = Math.abs(endY - sy) || 1
+        var bend = 18
+        selThreadPath.setAttribute(
+          'd',
+          'M' + sx + ' ' + sy + ' C ' + (sx + bend) + ' ' + (sy + dy * 0.45) + ', ' +
+            (endX - bend) + ' ' + (endY - dy * 0.45) + ', ' + endX + ' ' + endY,
+        )
+        selThreadPath.setAttribute('stroke', accent)
+        selThreadDot.setAttribute('cx', sx)
+        selThreadDot.setAttribute('cy', sy)
+        selThreadDot.setAttribute('fill', accent)
+        selThreadDot.setAttribute('stroke', 'var(--dsw-alias-bg-base,#fff)')
+        // 生长动画**只在开卡片时**播：滚动 / 缩放也会走到这里，而 display:none → block
+        // 会重启动画 —— 那就是又一次"闪一下"（同一个坑，别踩第二遍）。
+        if (grow) selThread.setAttribute('data-grow', '1')
+        else selThread.removeAttribute('data-grow')
+        selThread.style.display = 'block'
+        selThread.style.opacity = '1'
+      }
+
+      /** 收起选中提示（幂等）。 */
+      function clearSelectionMarkers() {
+        if (selMark && selMark.children.length) selMark.textContent = ''
+        if (selMark) selMark.style.opacity = ''
+        if (selThread) {
+          selThread.style.display = 'none'
+          selThread.style.opacity = ''
+        }
+      }
+
+      /** 关机动画那条亮线（懒建）。 */
+      function ensureCrtLine() {
+        if (crtLine) return crtLine
+        crtLine = el('div', 'dsh-sel-crtline')
+        layer.appendChild(crtLine)
+        return crtLine
+      }
+
+      /**
+       * 亮线的分段与火花（懒建，只建一次）。
+       *
+       * 5 段首尾相接拼成整条线（看上去就是一条实线）；收缩时各段延迟不同，
+       * 于是"往中间收"和"错位露缝"同时发生 —— 这点像素故障是刻意做的。
+       * 末尾两个火花是段子死掉之后还在原位闪两下的残留像素。
+       */
+      function ensureCrtSegments(line) {
+        if (line.children && line.children.length) return
+        for (var i = 0; i < 5; i += 1) line.appendChild(el('div', 'dsh-sel-crtseg'))
+        line.appendChild(el('div', 'dsh-sel-crtspark'))
+        line.appendChild(el('div', 'dsh-sel-crtspark'))
+      }
+
+      /** 系统是否要求减少动效。 */
+      function prefersReducedMotion() {
+        try {
+          return typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches
+        } catch (error) {
+          return false
+        }
+      }
+
+      /**
+       * 播"老式电视机关机"：卡片塌成一条线，亮线再横缩成一个点（A 方案，420ms）。
+       *
+       * 只在**取消**时播 —— 发送那条要立刻开面板，动画会和面板叠在一起。
+       *
+       * 亮线是**独立元素**，不是卡片的 box-shadow：box-shadow 会跟着 transform 一起被压扁，
+       * 塌到 5% 时连光晕都成一条（实测踩过）。颜色也按明暗给两套 ——
+       * 浅色底上白线看不见（实测只差 ~15/255），深色底上反过来，白线才亮得起来。
+       *
+       * 返回 false 表示没播（系统要求减少动效 / 卡片量不出尺寸），调用方直接收掉。
+       */
+      function playCrtOff() {
+        if (!vcard || prefersReducedMotion()) return false
+        var rect = vcard.getBoundingClientRect()
+        if (!rect.width || !rect.height) return false
+        var line = ensureCrtLine()
+        var dark = false
+        try {
+          dark = isDarkSurface(document.body)
+        } catch (error) {
+          dark = false
+        }
+        // 亮线摆在卡片正中、宽度跟着卡片（都是 fixed 定位，同一套视口坐标）
+        line.style.left = Math.round(rect.left) + 'px'
+        line.style.top = Math.round(rect.top + rect.height / 2 - 1.5) + 'px'
+        line.style.width = Math.round(rect.width) + 'px'
+        ensureCrtSegments(line)
+        // 颜色挂在容器上，分段/火花用 currentColor 继承 —— 一处赋值，7 个子元素跟着变
+        line.style.color = dark ? '#FFFFFF' : 'var(--sel-a1)'
+        line.style.background = 'transparent'
+        line.style.boxShadow = 'none'
+        line.style.filter = dark
+          ? 'drop-shadow(0 0 6px rgba(190,245,255,.8))'
+          : 'drop-shadow(0 0 6px rgba(13,148,136,.55))'
+        vcardState.closing = true
+        // 选中提示跟着卡片一起淡掉（它俩是"卡片这一段"的注解，卡片塌了就不该还挂着）
+        if (selMark) selMark.style.opacity = '0'
+        if (selThread) selThread.style.opacity = '0'
+        if (selThreadDot) selThreadDot.style.opacity = '0'
+        // 摘掉再挂上：让动画能重播（同一元素上连续两次收卡片）
+        vcard.removeAttribute('data-off')
+        line.removeAttribute('data-off')
+        void vcard.offsetWidth
+        vcard.setAttribute('data-off', 'a')
+        line.setAttribute('data-off', 'a')
+        var done = function () {
+          if (vcardState.crtTimer) {
+            clearTimeout(vcardState.crtTimer)
+            vcardState.crtTimer = null
+          }
+          if (vcard && vcardState.crtHandler) {
+            vcard.removeEventListener('animationend', vcardState.crtHandler)
+            vcardState.crtHandler = null
+          }
+          finishCrtOff()
+        }
+        // animationend 是主路径；另挂兜底 —— 标签页在后台时动画根本不跑，事件也就不会来
+        vcardState.crtHandler = function (event) {
+          if (event.target === vcard) done()
+        }
+        vcard.addEventListener('animationend', vcardState.crtHandler)
+        vcardState.crtTimer = later(done, 700)
+        return true
+      }
+
+      /**
+       * 关机动画收尾：真正把卡片和亮线藏掉。
+       *
+       * 幂等 —— 不播动画时 closeVCard 直接调它，顺便清掉上一轮动画的残留。
+       */
+      function finishCrtOff() {
+        vcardState.closing = false
+        if (vcardState.crtTimer) {
+          clearTimeout(vcardState.crtTimer)
+          vcardState.crtTimer = null
+        }
+        if (vcard && vcardState.crtHandler) {
+          vcard.removeEventListener('animationend', vcardState.crtHandler)
+          vcardState.crtHandler = null
+        }
+        if (vcard) {
+          vcard.removeAttribute('data-off')
+          vcard.style.display = 'none'
+          vcard.style.opacity = ''
+          vcard.style.filter = ''
+          vcard.style.transform = ''
+          vcard.style.borderRadius = ''
+          vcard.setAttribute('data-voiced', '0')
+          vcard.setAttribute('data-text', '0')
+        }
+        if (vcardBox) {
+          vcardBox.value = ''
+          vcardBox.style.height = ''
+          vcardBox.style.overflowY = 'hidden'
+        }
+        if (crtLine) {
+          crtLine.removeAttribute('data-off')
+          crtLine.style.opacity = ''
+          crtLine.style.filter = ''
+        }
+        clearSelectionMarkers()
+      }
+
+      /**
+       * 收起卡片。
+       *
+       * animate=true（取消：Esc / 点空白）时先播关机动画，动画结束再真正隐藏；
+       * 其余路径（发送 / 调试钩子）立刻收掉。
+       * **不还回「✦ 解读」浮标**：取消就是取消，要解读就重新划一次。
+       */
+      /** 停掉"等文字定稿"的观察（幂等）。 */
+      function stopVoiceSettle() {
+        if (vcardState.settleTimer) {
+          clearInterval(vcardState.settleTimer)
+          vcardState.settleTimer = null
+        }
+        if (vcardState.settleComposeTimer) {
+          clearTimeout(vcardState.settleComposeTimer)
+          vcardState.settleComposeTimer = null
+        }
+        // ⚠️ 这里**不**上报测量：停表既发生在"正常决定之前"（那一拍马上就要 finishVoiceSettle），
+        // 也发生在"被提前打断"时。在这里上报会把决策一律记成 stopped（踩过）。
+        // 提前打断的场景由调用方各自上报（closeVCard / 新录音）。
+        vcardState.settleLastText = ''
+        vcardState.settleStableAt = 0
+        vcardState.settleDeadline = 0
+      }
+
+      /** 文字定稿后，才真正执行收尾（发送 / 取消 / 什么都不做）。 */
+      function finishVoiceSettle(text) {
+        if (!vcardState.open) return
+        var spoken = String(text || '').trim()
+        if (spoken && settingsLive.voiceAutoSend !== false) {
+          sendVCard()
+          return
+        }
+        if (!spoken && settingsLive.voiceCancelOnSilence !== false) {
+          closeVCard(true)
+          return
+        }
+        markVCardListening(false)
+      }
+
+      /**
+       * 松手之后，等文字定稿再决定收尾动作。
+       *
+       * 判据是"连续 VOICE_SETTLE_MS 没有变化"，最长等 VOICE_SETTLE_MAX_MS。
+       * 豆包的智能整理通常会在这段窗口里把内容改写一到两次；每改一次就重新计时。
+       */
+      function startVoiceSettle() {
+        stopVoiceSettle()
+        vcardState.settleLastText = String((vcardBox && vcardBox.value) || '')
+        vcardState.settleStableAt = Date.now()
+        vcardState.settleDeadline = Date.now() + VOICE_SETTLE_MAX_MS
+        vcardState.settleTimer = setInterval(function () {
+          if (!vcardState.open) {
+            stopVoiceSettle()
+            return
+          }
+          var now = Date.now()
+          var text = String((vcardBox && vcardBox.value) || '')
+          if (text !== vcardState.settleLastText) {
+            // 还在改写（智能整理）→ 重新计时，继续等
+            vcardState.settleLastText = text
+            vcardState.settleStableAt = now
+            return
+          }
+          if (now - vcardState.settleStableAt < VOICE_SETTLE_MS && now < vcardState.settleDeadline) return
+          stopVoiceSettle()
+          finishVoiceSettle(text)
+        }, VOICE_SETTLE_POLL_MS)
+      }
+
+      function closeVCard(animate) {
+        if (!vcardState.open) return
+        vcardState.open = false
+        vcardState.range = null
+        vcardState.anchorRect = null
+        // ⚠️ 必须**显式 blur**，不能只把卡片 display:none 掉。
+        //
+        // 输入法（豆包）的输入上下文是绑在"当前那个文本输入框"上的：卡片打开时我们把焦点
+        // 抢给它，上下文就绑在了卡片的 textarea 上；卡片只是被隐藏时，它**仍然是输入法的输入框**
+        // （display:none 不会让 macOS 的输入法自己解绑）。于是之后焦点虽然转到小窗输入框，
+        // 输入法的合成仍然发生在卡片上 —— 用户实测的症状就是：
+        //   小窗输入框能收到 keydown，却**永远收不到 beforeinput**（输入法合成），
+        //   打不进字、也没有插入符。
+        // focus-trace 抓到的实测序列：
+        //   临时卡片上有 beforeinput（正常）→ 小窗输入框上只有 keydown（打不进）
+        //   → 焦点回到宿主输入框后 beforeinput 立刻恢复。
+        if (vcardBox && typeof vcardBox.blur === 'function') {
+          try {
+            vcardBox.blur()
+          } catch (error) {
+            /* 桩环境 */
+          }
+        }
+        stopVoiceSettle()
+        stopMicWatch()
+        // 形变还没结束就被关掉时，正文宽度可能还钉着 —— 一并解开
+        unpinVCardBox()
+        // 动画期间正文/占位都留着（要塌的就是它），收尾时才清
+        if (animate && playCrtOff()) return
+        finishCrtOff()
+      }
+
+      /** 发送：跳过翻译与详解，把说的话当作第一条追问直接发出去。 */
+      function sendVCard() {
+        var asked = String((vcardBox && vcardBox.value) || '').trim()
+        if (!asked) {
+          focusVCard()
+          return
+        }
+        var selection = state.selection
+        if (!selection) {
+          closeVCard()
+          return
+        }
+        // 侧边栏网页那条路没有 Range（不透明源帧的选区拿不出来），上下文 / 标签直接用
+        // 帧内桥采好带过来的那份 —— 与 openForSelection 的 iframe 分支同一条规则。
+        var contextInfo =
+          selection.source === 'iframe' || !selection.range
+            ? {
+                context: String(selection.context || ''),
+                keyContext: String(selection.keyContext || ''),
+                label: selection.label,
+              }
+            : collectContext(rangeSelection(selection.range))
+        // 交接起点：卡片**现在**的矩形。必须在 closeVCard 之前量 —— 之后它 display:none，量出来是 0。
+        // 小窗会从这一格"长出来"（见 growPanelFromCard）。
+        vcardHandoff = vcardRect()
+        closeVCard()
+        openPanelWith(
+          selection.text,
+          contextInfo.context,
+          contextInfo.label,
+          selection.rect,
+          contextInfo.keyContext,
+          { askFirst: asked },
+        )
+        clearDocSelection()
+        // 选区连同它的记录一起作废（与 openForSelection 一致）
+        state.selection = null
+        state.bridgeActive = false
+      }
+
+      /**
+       * "现在这一下该不该抢焦点"。
+       *
+       * 本文档里的选区：`document.hasFocus()` 就是答案（与改动前完全一致）。
+       * 侧边栏网页里的选区：焦点其实落在**不透明源子框架**里，父文档的 `hasFocus()`
+       * 有没有为真由浏览器实现说了算（跨引擎没有统一答案），所以对它改用
+       * "这一帧刚报过动作"当证据 —— 桥报上来的那一刻，用户确实正在那个网页里划词 / 点按。
+       */
+      function hasFocusEvidence(selection) {
+        if (typeof document.hasFocus !== 'function') return true
+        if (document.hasFocus()) return true
+        if (!selection || selection.source !== 'iframe' || !selection.frame) return false
+        return Date.now() - (frameTouchedAt.get(selection.frame) || 0) < FRAME_FOCUS_EVIDENCE_MS
+      }
+
+      /** 卡片当前的视口矩形（拿不到就返回 null —— 那就不做交接动画，老实瞬开）。 */
+      function vcardRect() {
+        if (!vcard || typeof vcard.getBoundingClientRect !== 'function') return null
+        try {
+          var rect = vcard.getBoundingClientRect()
+          return rect && rect.width && rect.height ? rect : null
+        } catch (error) {
+          return null
+        }
+      }
+
+      /** host 报的占用者里，有没有已知输入法。 */
+      function matchingIme(data) {
+        if (!data || !data.capturing || !Array.isArray(data.processes)) return null
+        for (var i = 0; i < data.processes.length; i++) {
+          var proc = data.processes[i] || {}
+          var id = String(proc.bundleId || '')
+          for (var j = 0; j < IME_BUNDLES.length; j++) {
+            if (id.indexOf(IME_BUNDLES[j]) === 0) return proc
+          }
+        }
+        return null
+      }
+
+      /**
+       * 只在"有选区"时轮询（浮标亮着的那几拍）。不叠请求：上一拍没回来就跳过这一拍。
+       * 拿不到 host 的能力（非 macOS / 探针没编出来）就**停掉轮询**，不再空转。
+       */
+      function startMicWatch() {
+        if (vcardState.timer) return
+        // 两条路都要盯麦克风：解读选区（面板没开 → 语音卡）与引用选区（面板开着 → 自动引用）
+        if (!state.selection && !state.quoteSelection) return
+        vcardState.timer = setInterval(micTick, MIC_POLL_MS)
+        timers.push(vcardState.timer)
+        micTick()
+      }
+
+      function stopMicWatch() {
+        // ⚠️ 抑制标记必须**跟着轮询一起复位**，不能只放在"轮询到没在录"那一拍上：
+        // 自动引用做完就会 hideQuoteButton → 停轮询（浮标收了就没什么可等的），
+        // 那一拍于是可能永远不来，标记就一直挂着 true。
+        //
+        // 靠"下一次划词自愈"也不可靠：只有浮标亮起来那一刻麦克风**已经关着**，
+        // 最早那一拍才会答"没在录"、顺手把它复位；麦克风正开着时每一拍都答"在录"，
+        // 标记就没机会复位。真实用法里这个顺序几乎凑不出来（鼠标一划，语音就断了），
+        // 所以它更像颗埋着的雷而不是现行 bug —— 但状态机不该建立在
+        // "用户凑不出这个顺序"上（将来若给这条路加"说完直接发送"，它就立刻变成真问题）。
+        //
+        // 语义上这样才对：一次观察窗口（浮标亮着的这段时间）里只处理第一次开麦。
+        quoteVoiceHandled = false
+        if (!vcardState.timer) return
+        clearInterval(vcardState.timer)
+        vcardState.timer = null
+      }
+
+      function micTick() {
+        if (vcardState.busy) return
+        // 两个都空了（选区没了 / 引用浮标收了）：没什么可等的，停掉轮询
+        if (!state.selection && !state.quoteSelection) {
+          stopMicWatch()
+          return
+        }
+        vcardState.busy = true
+        fetch(MIC_API)
+          .then(function (response) {
+            return response.json()
+          })
+          .then(function (data) {
+            vcardState.busy = false
+            if (!data || !data.available) {
+              stopMicWatch()
+              return
+            }
+            if (matchingIme(data)) {
+              // ── 小窗开着：引用那条路（开麦 = 点一下「❝ 引用」+ 光标进小窗输入框）──
+              // 与语音卡互斥：panelOpen 时前者根本不该启动（openVCard 自己也会拒）。
+              if (panelOpen && state.quoteSelection && !vcardState.open) {
+                if (quoteVoiceHandled) return
+                quoteVoiceHandled = true
+                autoQuoteFromVoice()
+                return
+              }
+              if (vcardState.suppress) return
+              // 又开始录了：上一次的"等定稿"作废
+              stopVoiceSettle()
+              if (!vcardState.open) openVCard()
+              else markVCardListening(true)
+              return
+            }
+            // 没人在录了：这一次录音结束，解除抑制（下一次开麦才允许再弹 / 再加引用）
+            vcardState.suppress = false
+            quoteVoiceHandled = false
+            if (!vcardState.open) return
+            // 开麦结束了。卡片**不立刻退出**：下面两个收尾行为都要等文字定稿
+            //（松手那一刻输入法还会做一次智能整理，见 startVoiceSettle）。
+            // 两个开关都关掉时卡片就留着 —— 一个字都没说也能接着手动打字。
+            // 这里只把"在听"停掉（见 markVCardListening）。
+            //
+            // 两个收尾行为（设置页「界面 · 语音输入」，**默认都开**，见 Config 注释）：
+            //   · voiceAutoSend：有字 → 等于替用户点了发送键（发送自己会关卡片、开小窗）；
+            //   · voiceCancelOnSilence：没字 → 等于替用户按了 Esc（带关机动画）。
+            // 都从 settingsLive 现读，所以设置一改下一次松手就生效；判断用 `!== false` ——
+            // 还没加载完 / 读失败时按**出厂默认（开）**处理，与 host 侧 Config 的缺省值一致。
+            // ⚠️ 松手这一刻**文字还没定稿**：豆包紧接着还会做一次智能整理，会改写输入框内容。
+            // 所以两个收尾行为都不在这里执行，而是先挂上"等定稿"的观察（见 startVoiceSettle）。
+            markVCardListening(false)
+            // ⚠️ 这个分支在"麦克风关着"期间**每一拍都会走**（200ms 一次），
+            // 所以必须幂等：已经在等定稿就不要再 startVoiceSettle() ——
+            // 那会把"稳定起点"重置，永远等不到 VOICE_SETTLE_MS（实测就是这个坑：
+            // settleFor 一直停在几十毫秒，卡片永远不动作）。
+            if (
+              !vcardState.settleTimer &&
+              (settingsLive.voiceAutoSend !== false || settingsLive.voiceCancelOnSilence !== false)
+            ) {
+              startVoiceSettle()
+            }
+          })
+          .catch(function () {
+            vcardState.busy = false
+            stopMicWatch()
+          })
+      }
+
+      /**
+       * 开麦 = 点一下「❝ 引用」（用户 2026-10-09 定的行为）。
+       *
+       * 小窗开着时，划词浮出的是引用浮标；这时用户按下输入法的语音键，我们做的正是
+       * "点一下那个浮标"那件事：把选中的文字挂进小窗、并把光标移到小窗输入框 ——
+       * 于是输入法上屏的字直接落进小窗，和引用一起成为下一条追问。
+       *
+       * 为什么必须在**开麦那一刻**做：输入法上屏发生在松手那一刻，焦点得提前挪好
+       * （与语音卡抢焦点同一条时序，见文件上方那段注释）。检测延迟由"探针 125ms +
+       * 页面轮询 200ms"构成，豆包从按下到松手通常有几秒，够用。
+       *
+       * 守卫与 openVCard 完全一致（页面没焦点 / 用户正在别处打字 → 不抢，否则就是把
+       * 人家在别处的听写拽进小窗），另外多加一条：插件自己的 🎤 正在录音时不抢 ——
+       * 那套走 host 识别、与输入法语音是两回事，焦点该留给它。
+       * （"没焦点"同样按 hasFocusEvidence 判：侧边栏网页里那条选区也得能走这条路。）
+       *
+       * 用户取消语音（Esc）或一个字没说：**引用留着**（可一键 ✕ 删）。撤销会让"引用到底
+       * 加没加"变得难预期，而且点浮标那条路也是加了就加了。
+       */
+      function autoQuoteFromVoice() {
+        var selection = state.quoteSelection
+        if (!panelOpen || !selection) return
+        if (!hasFocusEvidence(selection)) return
+        if (isTypingTarget(document.activeElement)) return
+        if (voice && voice.phase !== 'idle') return
+        // 与点浮标同一条路：上下文在这一刻才采（"引用当时在哪一段对话里"最有用的就是它）
+        addQuote(selection.text, selection.label, quoteContextFor(selection))
+        hideQuoteButton()
+        // addQuote 在"重复引用 / 到上限"时会提前 return（那两条路不会聚焦），但"说话的字要落进
+        // 小窗"这件事仍然必须成立 —— 所以焦点在这里再兜一次（composerVisible 已由 addQuote 保证）。
+        if (composerVisible()) focusAskBox()
       }
 
       function hideQuoteButton() {
         quoteButton.style.display = 'none'
         setQuotePop(false)
+        // 浮标收了就没什么可等的了（与 hideButton 同一条规则）；语音卡开着时不能停
+        if (!vcardState.open) stopMicWatch()
       }
 
       // ────────────────────── 引用（❝）：把别处的文字挂进输入框 ──────────────────────
@@ -4106,6 +5464,14 @@ window.__ModuleLoader__.load({
        * 用 Map 而不是数组：既要按帧查自己的 url，也要遍历找回消息来源对应的帧。
        */
       var bridged = new Map()
+      /**
+       * 帧 → 最后一次收到它的消息的时间戳。
+       *
+       * 只为一件事：判断"用户此刻是不是就在那个侧边栏网页里"（见 hasFocusEvidence）。
+       * 焦点落在不透明源子框架里时，父文档的 `document.hasFocus()` 未必为真，
+       * 而桥报上来的每条消息本身就是"用户刚在那儿动过"的证据。
+       */
+      var frameTouchedAt = new Map()
       /** 总开关：host 的 bridgeSidebarPreview 说关就关（见下面 ping 分支）。 */
       var bridgeOn = true
       /** 扫描节流用的定时器 id。 */
@@ -4285,11 +5651,14 @@ window.__ModuleLoader__.load({
           }
           // 帧没了就不会再有 clear 消息了：把它占着的那条选区一起清掉，
           // 否则 `bridgeActive` 会一直挂着（表现为顶层选区塌掉也不收浮标）。
+          // 卡片开着时也不清：帧没了但它占着的选区仍是"这一轮的解读对象"（发送要用），
+          // 与下面 clear 分支同一条规则。
           if (state.selection && state.selection.frame === dead[i]) {
-            state.selection = null
             state.bridgeActive = false
+            if (!vcardState.open) state.selection = null
             hideButton()
           }
+          frameTouchedAt.delete(dead[i])
           bridged.delete(dead[i])
         }
       }
@@ -4326,6 +5695,8 @@ window.__ModuleLoader__.load({
         if (!bridgeOn || !data || data.__dshSel !== 1) return
         var frame = frameBySource(event.source)
         if (!frame) return
+        // 这条消息本身就是"用户此刻正在那个网页里"的证据（见 hasFocusEvidence）
+        frameTouchedAt.set(frame, Date.now())
         if (data.kind === 'press') {
           // 帧内按下：与主会话一致——先收浮标。父页面收不到帧内的 mousedown，
           // 少了这一条，在网页里点一下（取消选区、点别处、点另一个网页）浮标就赖着不走。
@@ -4336,12 +5707,23 @@ window.__ModuleLoader__.load({
           }
           hideButton()
           hideQuoteButton()
+          // 卡片开着时同理要收卡片（与主会话"点别处就收卡"同一条规则：那边靠 document 上的
+          // mousedown，帧内的点击父页面收不到）。suppress 也要置上，否则下一拍轮询发现
+          // "还在录"会把卡片又弹回来 —— Esc 那条路同样是这么处理的。
+          if (vcardState.open && state.selection && state.selection.frame === frame) {
+            vcardState.suppress = true
+            closeVCard(true)
+          }
           return
         }
         if (data.kind === 'clear') {
           if (state.selection && state.selection.frame === frame) {
-            state.selection = null
             state.bridgeActive = false
+            // ⚠️ 卡片开着时**不清选区**：抢焦点必然让帧内选区塌掉（输入法上屏要的正是焦点），
+            // 桥于是报 clear —— 但用户选的那段文字仍然是这一轮的解读对象（发送时要用它，
+            // 麦克风轮询也要靠 state.selection 判断"说完了没有"）。
+            // 本文档那条路是一致的：顶层选区被抢焦点搞塌时也只收浮标，不清 state.selection。
+            if (!vcardState.open) state.selection = null
             hideButton()
             hideQuoteButton()
           }
@@ -4372,6 +5754,17 @@ window.__ModuleLoader__.load({
           label: labelForFrame(frame, data.sel.label),
         }
         state.bridgeActive = true
+        // 卡片开着时，帧内的重报（滚动 / 改尺寸 / 挪选区）只是"那段文字动了"：
+        // 跟着挪卡片与锚点，**不要**再浮出浮标（浮标与卡片是互斥的两态）。
+        if (vcardState.open) {
+          if (state.selection.frame === frame) {
+            vcardState.anchorRect = rect
+            repositionVCard()
+            return
+          }
+          // 另一帧报了新选区：这张卡已经不是用户在看的东西了，收掉再按新选区走
+          closeVCard(true)
+        }
         if (panelOpen) {
           // 小窗开着：帧内这条选区也只是"一段可以引用的文字"（上下文由帧内的桥给）
           state.quoteSelection = {
@@ -4561,7 +5954,10 @@ window.__ModuleLoader__.load({
        * 打开面板的公共路径：真实选区与自检钩子**共用**这一条，
        * 否则钩子会绕过缓存（缓存行为只能靠人工点选才能验证）。
        */
-      function openPanelWith(text, context, label, anchor, keyContext) {
+      function openPanelWithInner(text, context, label, anchor, keyContext, options) {
+        // 这一轮是不是"从语音卡直接进追问"：paint() 靠它决定不画翻译/详解两节、
+        // 并且让追问输入框直接可见（见 state.voiceAsk 的几处用法）
+        state.voiceAsk = !!(options && options.askFirst)
         // 记下"这次划词发生在哪个会话"——小窗后续所有按会话解析的东西都用它
         panelSessionId = currentSessionId()
         state.payload = buildPayload(text, context, label)
@@ -4575,11 +5971,39 @@ window.__ModuleLoader__.load({
         var cached = cache.get(cacheKey)
         state.cacheKey = cacheKey
         state.turns = []
-        // 换了一段选中文字 = 换了一次对话：上一段攒的引用不该跟过来
+        // 换了一段选中文字 = 换了一次对话：上一段攒的引用**和检索结果**都不该跟过来。
+        //
+        // ⚠️ toolDigest 原来漏在这一步（属遗漏，不是有意保留）。它的语义单位就是"一次对话"：
+        // 按历史条目落盘、按条目恢复，宿主发给模型的措辞也是「本会话已经查到的结果」。
+        // 但 state 是整页只建一次的，而它**只在历史回放时被恢复、别处从不复位** ——
+        // 于是只要某段对话搜过东西（比如问过一次新闻），之后**每一段新选区**的追问
+        // 都会把那段结果一并带给模型（用户实测："每次后面都带着我之前搜的新闻"）。
+        //
+        // 只清 digest、不动 tools/thought：那几个在请求开始处另有一份复位，
+        // digest 则该在这里（以及历史回放）动。
+        state.toolDigest = ''
         clearQuotes()
         state.parts = (cached && cached.parts) || { translation: '', detail: '' }
         state.stage = ''
         state.raw = ''
+        // 语音卡那条路（options.askFirst）：**不请求 /analyze**，直接把说的话当第一条追问发出去。
+        // 面板停在"追问"阶段、翻译与详解两节是空的 —— 这正是"跳过解读"的字面意思。
+        // 缓存与历史回放一律不参与：用户要的是"现在这句"，不是"这段文字上次的解读"。
+        if (options && options.askFirst) {
+          state.parts = { translation: '', detail: '' }
+          state.phase = 'done'
+          state.chars = 0
+          state.error = ''
+          state.fromCache = false
+          state.sharedCache = false
+          state.elapsed = 0
+          state.toolBusy = false
+          state.cacheState = ''
+          renderTurns()
+          paint()
+          sendAsk(options.askFirst)
+          return
+        }
         renderTurns()
         if (cached) {
           state.turns = (cached.turns || []).slice()
@@ -4607,6 +6031,24 @@ window.__ModuleLoader__.load({
           runRequest(state.payload, cacheKey)
         })
       }
+
+      /**
+       * 开窗（带"卡片 → 小窗"的交接动画）。
+       *
+       * 为什么动画放在**内容画完之后**、而不是 showPanel 里面：showPanel 那一刻面板还挂着
+       * 上一轮的 DOM（新内容要到后面的 renderTurns / paint 才换上去），在那里量高度量到的是旧的 ——
+       * 实测起点 scaleY 用的是上一轮的 398px 高度，而这一轮内容是 354px。
+       * 起点本来就要把面板压到卡片那一格（视觉上一样），但拿旧高度算缩放会让中段多一折。
+       *
+       * 只有"从语音卡发送"那条路会留下起点（vcardHandoff）；其余开窗路径这里是 null，
+       * 行为与以前完全一致（瞬开）。
+       */
+      function openPanelWith(text, context, label, anchor, keyContext, options) {
+        openPanelWithInner(text, context, label, anchor, keyContext, options)
+        var handoff = vcardHandoff
+        vcardHandoff = null
+        growPanelFromCard(handoff)
+      }
       /** 由 Range 还原一个 selection 形状的对象（collectContext 只用到这两个方法）。 */
       function rangeSelection(range) {
         return {
@@ -5365,10 +6807,32 @@ window.__ModuleLoader__.load({
         panel.setAttribute('data-resized', '1')
       }
 
+      /**
+       * 面板的**布局**矩形（不受"卡片 → 小窗"交接动画的 transform 影响）。
+       *
+       * 为什么需要它：交接那 260ms 里面板带着 `translate+scale`，这时 `getBoundingClientRect()`
+       * 给的是**缩放后**的框 —— 谁在这段时间里量它（拖拽、夹进视口、历史列表定位、测试钩子），
+       * 拿到的都是错的（比如把面板拖到卡片那个小格子的位置上去）。
+       * `offsetLeft/Top/Width/Height` 是布局值，不受 transform 影响；面板是 position:fixed，
+       * 所以它们本来就是视口坐标，与 getBoundingClientRect 同源。
+       */
+      function panelLayoutRect() {
+        var width = panel.offsetWidth
+        var height = panel.offsetHeight
+        var left = panel.offsetLeft
+        var top = panel.offsetTop
+        // 拿不到布局值时（单测的桩 DOM、面板隐藏着量到 0×0）退回渲染矩形：
+        // 那两种情况下也不可能有交接动画，退回是安全的，而且与改动前的行为一致。
+        if (!isFinite(width) || !isFinite(height) || !isFinite(left) || !isFinite(top) || (width === 0 && height === 0)) {
+          var rect = panel.getBoundingClientRect()
+          return { left: rect.left, top: rect.top, width: rect.width, height: rect.height, right: rect.right, bottom: rect.bottom }
+        }
+        return { left: left, top: top, width: width, height: height, right: left + width, bottom: top + height }
+      }
+
       /** 当前尺寸（读实际渲染值，比拿变量算更稳 —— 拖拽过程中变量会漂）。 */
       function currentPanelSize() {
-        var rect = panel.getBoundingClientRect()
-        return { w: rect.width, h: rect.height }
+        return { w: panel.offsetWidth, h: panel.offsetHeight }
       }
 
       /** 夹进视口：改大小/窗口变化后都调，保证手柄还在屏幕里、小窗不会超出可视区。 */
@@ -5389,7 +6853,7 @@ window.__ModuleLoader__.load({
        * 优先保住左上角（那是用户看到的锚点），右边/下边放不下才往回收。
        */
       function clampPanelPosition() {
-        var rect = panel.getBoundingClientRect()
+        var rect = panelLayoutRect()
         var maxLeft = Math.max(4, window.innerWidth - rect.width - 4)
         var maxTop = Math.max(4, window.innerHeight - rect.height - 4)
         panel.style.left = Math.round(Math.min(Math.max(rect.left, 4), maxLeft)) + 'px'
@@ -5491,6 +6955,12 @@ window.__ModuleLoader__.load({
             changed = Math.abs(clamped.w - startSize.w) + Math.abs(clamped.h - startSize.h)
             panel.style.width = Math.round(clamped.w) + 'px'
             panel.style.height = Math.round(clamped.h) + 'px'
+            // ⚠️ **必须同步抬高 max-height**。
+            // 开窗时 applyPanelSizeOnOpen() 会把"上次记住的高度"写成 max-height 当天花板；
+            // 拖拽如果只写 height，写大的部分会被那条旧天花板直接截掉 ——
+            // 用户实测就是"拖拽的上限不是视口高度减 8，而是上次关闭小窗之前的高度"。
+            // （反过来拖小没问题：height 小于旧天花板，看不出来。）
+            panel.style.maxHeight = Math.round(clamped.h) + 'px'
             panelSize = clamped
             panel.setAttribute('data-resized', '1')
             if (historyList.style.display === 'flex') placeHistoryList()
@@ -5558,6 +7028,64 @@ window.__ModuleLoader__.load({
         warmModelCatalog()
       }
 
+      /**
+       * 让小窗"从卡片那一格长出来"（260ms，只动 transform）。
+       *
+       * 起手把面板用 transform 压到卡片矩形上（`translate(dx,dy) scale(sx,sy)`，原点取左上角），
+       * 再回到 `transform:none` —— 于是"卡片 → 小窗"是一段连续的量变，而不是两次 display 切换。
+       *
+       * 几个必须这么写的点：
+       *   · 量 `to` 之前先**清掉残留的 transform**：否则量到的是上一次动画的半截几何；
+       *   · 先 `transition:none` 摆好起点、强制重排，再开过渡 —— 否则浏览器会把"设起点"和
+       *     "设终点"合并成一次样式变更，动画根本不播（插件在 openVCard 里踩过同一个坑）；
+       *   · 收尾必须把内联的 `transform/transition/transformOrigin` 清干净 —— 面板之后还要被
+       *     拖拽改大小、还要开设置抽屉（抽屉是 inset:0 贴在面板上的），留着 transform 会连累它们；
+       *   · 系统要求减少动效时**不做**（与 playCrtOff 同一条规矩）。
+       */
+      function growPanelFromCard(from) {
+        if (!from || !panel || !from.width || !from.height) return
+        if (prefersReducedMotion()) return
+        panel.style.transition = 'none'
+        panel.style.transform = ''
+        panel.style.transformOrigin = ''
+        var to = panel.getBoundingClientRect()
+        if (!to.width || !to.height) return
+        var sx = from.width / to.width
+        var sy = from.height / to.height
+        var dx = from.left - to.left
+        var dy = from.top - to.top
+        // 卡片正好在面板位置上（差不到 1px）就没必要做 —— 那是"没动"，别白播一段
+        if (Math.abs(dx) < 1 && Math.abs(dy) < 1 && Math.abs(1 - sx) < 0.02 && Math.abs(1 - sy) < 0.02) return
+        panel.style.transformOrigin = '0 0'
+        panel.style.transform = 'translate(' + dx.toFixed(1) + 'px,' + dy.toFixed(1) + 'px) scale(' + sx.toFixed(4) + ',' + sy.toFixed(4) + ')'
+        void panel.offsetWidth
+        panel.style.transition = 'transform ' + PANEL_GROW_MS + 'ms ' + PANEL_GROW_EASE
+        panel.style.transform = 'none'
+        if (panelGrowTimer) {
+          clearTimeout(panelGrowTimer)
+          panelGrowTimer = null
+        }
+        var settle = function () {
+          if (panelGrowTimer) {
+            clearTimeout(panelGrowTimer)
+            panelGrowTimer = null
+          }
+          if (panelGrowHandler) {
+            panel.removeEventListener('transitionend', panelGrowHandler)
+            panelGrowHandler = null
+          }
+          panel.style.transition = ''
+          panel.style.transform = ''
+          panel.style.transformOrigin = ''
+        }
+        panelGrowHandler = function (event) {
+          if (event.target === panel && event.propertyName === 'transform') settle()
+        }
+        panel.addEventListener('transitionend', panelGrowHandler)
+        // transitionend 是主路径；标签页在后台时动画不跑、事件也就不会来，所以另挂兜底
+        panelGrowTimer = later(settle, PANEL_GROW_MS + 140)
+      }
+
       function closePanel() {
         closeModelMenu()
         // 小窗关掉时设置抽屉也一起收：否则下次开窗会直接停在设置页上
@@ -5566,6 +7094,20 @@ window.__ModuleLoader__.load({
         closeSettings()
         panelOpen = false
         panel.style.display = 'none'
+        // 交接动画还没跑完就被关掉：连同它的定时器一起收干净，别把半截 transform 留在面板上
+        // （下次开窗量几何会量到它，拖拽改大小也会被它带偏）
+        if (panelGrowTimer) {
+          clearTimeout(panelGrowTimer)
+          panelGrowTimer = null
+        }
+        if (panelGrowHandler) {
+          panel.removeEventListener('transitionend', panelGrowHandler)
+          panelGrowHandler = null
+        }
+        panel.style.transition = ''
+        panel.style.transform = ''
+        panel.style.transformOrigin = ''
+        vcardHandoff = null
         hideHistoryList()
         // 小窗收起来了：引用浮标跟着走（它只在"小窗开着"时有意义）
         hideQuoteButton()
@@ -5607,7 +7149,8 @@ window.__ModuleLoader__.load({
         for (var i = 0; i < state.turns.length; i += 1) {
           if (state.turns[i].role === 'user') asked = true
         }
-        expandButton.style.display = !hasDetail && translationReady && !asked ? '' : 'none'
+        // 语音卡那条路没有解读可展开，别摆一个点了没反应的按钮
+        expandButton.style.display = !hasDetail && translationReady && !asked && !state.voiceAsk ? '' : 'none'
         expandButton.disabled = false
         return asked
       }
@@ -5635,6 +7178,9 @@ window.__ModuleLoader__.load({
         var stage = state.stage
         var selected = state.payload && state.payload.text ? state.payload.text : state.selection ? state.selection.text : ''
         var sections = splitSections(visibleRaw())
+        // 语音卡那条路（选中文字 + 输入法语音 → 直接追问）：这一轮**没有解读**，
+        // 所以翻译节整节不画 —— 不是"画个空节、里面写这次没有返回内容"（用户否掉的正是它）。
+        translationSection.root.style.display = state.voiceAsk ? 'none' : ''
 
         // 翻译节：首轮流式期间逐字渲染；已有结果就用结果；一个字都还没有时给等待特效
         var live = stripEchoPrefix(stage === 'detail' ? '' : sections.translation || sections.other, selected)
@@ -5651,6 +7197,7 @@ window.__ModuleLoader__.load({
             // 创建时 start 事件还没到，state.effort 是空的；用函数实时读，档位才不会显示成兜底值
             effortOf: function () { return state.stageEffort || 'low' },
             thoughtOf: function () { return state.thought },
+            noticeOf: function () { return state.notice },
           })
         } else if (state.phase === 'error') {
           translationSection.content.textContent = ''
@@ -5670,19 +7217,6 @@ window.__ModuleLoader__.load({
           retryButton.style.display = ''
         }
 
-        // 伪造的工具调用被剥掉时，正文下面补一句交代（不是没查，是这轮没工具可用）
-        if (state.phase === 'done' && state.toolResidue) {
-          var hasNote = false
-          for (var ni = 0; ni < translationSection.content.children.length; ni += 1) {
-            if (translationSection.content.children[ni].className === 'dsh-sel-note') hasNote = true
-          }
-          if (!hasNote) {
-            translationSection.content.appendChild(
-              el('div', 'dsh-sel-note', '（本轮没有可用工具：模型输出的工具调用格式已忽略，以上是它凭已有知识的回答）'),
-            )
-          }
-        }
-
         // 详解节：只在第二阶段出现（或已缓存过）
         var wantDetail = !!(state.parts.detail || stage === 'detail')
         detailSection.root.style.display = wantDetail ? '' : 'none'
@@ -5696,6 +7230,7 @@ window.__ModuleLoader__.load({
             effort: state.effort,
             effortOf: function () { return state.stageEffort || 'high' },
             thoughtOf: function () { return state.thought },
+            noticeOf: function () { return state.notice },
           })
         }
 
@@ -5707,9 +7242,10 @@ window.__ModuleLoader__.load({
         var translationReady = state.phase === 'done' && !!state.parts.translation
         var wide = syncPanelStage()
         // 配色按**面板实际底色**选（不看系统偏好）：主题实现方式怎么变都不影响
-        layer.setAttribute('data-theme', isDarkSurface(panel) ? 'dark' : 'light')
-        panel.setAttribute('data-theme', isDarkSurface(panel) ? 'dark' : 'light')
-        askRow.style.display = wide || translationReady || state.quotes.length > 0 ? '' : 'none'
+        var surfaceTheme = currentSurfaceTheme()
+        layer.setAttribute('data-theme', surfaceTheme)
+        panel.setAttribute('data-theme', surfaceTheme)
+        askRow.style.display = wide || translationReady || state.voiceAsk || state.quotes.length > 0 ? '' : 'none'
         // 展开 CTA：翻译还在跑（含思考期）时先不出现——那时候该看的是等待特效，
         // 摆在下面只会是个灰着的按钮，反而像"没反应"；发过追问之后也收起（见 syncExpandCta）。
         syncExpandCta()
@@ -5769,26 +7305,33 @@ window.__ModuleLoader__.load({
        *   · preventScroll：别因为聚焦把页面滚一下（划完词页面跳走最难受）。
        */
       function focusComposerOnce() {
+        focusBail = 'pending=' + String(askFocusPending) + ' panel=' + String(panelOpen)
         if (!askFocusPending || !panelOpen) return
+        focusBail = 'composerVisible=' + String(composerVisible()) + ' panelSel=' + String(hasPanelSelection())
         if (!composerVisible()) return
         // 小窗里正有一段选中文字（用户正在划词、准备点「❝ 引用」）：**这一下聚焦会把选区清掉**。
         // 让位给用户，并且不再补焦 —— 引用浮标是这个功能的主入口，不能因为抢焦点而让它消失。
         //（实测：开窗后那一帧恰好落在"首轮刚出完"的自动聚焦上，划好的词会瞬间没了。）
         if (hasPanelSelection()) {
+          focusBail = '让位给小窗里的选区'
           askFocusPending = false
           return
         }
         var active = document.activeElement
         var inside = active && (active === panel || active === askBox || (panel.contains && panel.contains(active)))
+                focusBail = 'active=' + String((active && active.className) || active) + ' typing=' + String(isTypingTarget(active))
         // 只有"人家正在别处打字"才值得让路。
         // 注意别把普通的按钮焦点也算进去：点浮标时焦点正好落在浮标那个 <button> 上
         //（Chrome 点按钮会给它焦点），照"非 body 就不抢"的老写法会把我们自己挡在门外 ——
         // 这正是"开窗后没有自动聚焦"的原因。
         if (!inside && isTypingTarget(active)) {
+          focusBail = '让位给别处正在打字（' + String((active && active.tagName) || active) + '.' + String((active && active.className) || '')
+            + ' 链=' + (function(){ var n=active, out=[]; while(n && out.length<5){ out.push(String(n.className||n.tagName)+':'+String((n.style&&n.style.display)||'')); n=n.parentNode } return out.join('>') })() + '）'
           askFocusPending = false // 人家真的在别处打字，这次开窗就不再抢
           return
         }
         askFocusPending = false
+        focusBail = 'ok'
         focusAskBox()
       }
 
@@ -5808,12 +7351,45 @@ window.__ModuleLoader__.load({
       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
+        var editable = tag === 'input' || tag === 'textarea' || tag === 'select' || node.isContentEditable === true
+        if (!editable) return false
+        // 已经隐藏起来的输入框不算"人家正在打字"：它既收不到键盘，也不该挡住我们聚焦。
+        // 典型场景就是临时语音卡收起后焦点还挂在它的 textarea 上（display:none 的元素
+        // 在部分浏览器里仍然是 activeElement）。
+        if (typeof node.getClientRects === 'function' && node.getClientRects().length === 0) return false
+        return true
       }
 
-      /** 把光标交给输入框（preventScroll：别因为聚焦把页面滚一下）。 */
+      /**
+       * 小窗自己的规则：**一轮输出结束（成功或失败）后，把光标交回输入框**。
+       *
+       * 为什么是规则而不是某个入口的特例：不管是划词解读、语音卡直接追问、还是打开历史，
+       * 用户看完一轮结果之后，下一步十有八九是接着追问 —— 光标本来就该在那儿。
+       *
+       * 与"开窗时聚焦一次"（focusComposerOnce 的首次调用）的区别：
+       * 那次可能因为"人家正在别处打字"而作废并就此作罢；这次是每轮结束都重新申请，
+       * 仍然尊重同一条礼貌规则（不抢正在别处打字的人的焦点）。
+       */
+      function askFocusAfterTurn() {
+        focusBail = 'panelOpen=' + String(panelOpen)
+        if (!panelOpen) return
+        askFocusPending = true
+        focusComposerOnce()
+      }
+
+      /**
+       * 把光标交给输入框（preventScroll：别因为聚焦把页面滚一下）。
+       *
+       * 先 blur 再 focus：如果输入法的输入上下文还绑在别处（见 closeVCard 里的注释 ——
+       * 典型就是刚收起的临时卡片），单叫 focus() 不足以让它重新绑定到这个输入框；
+       * 走一次 blur → focus 才能把输入法重新挂过来。已经是当前焦点时，blur 是无害的。
+       */
       function focusAskBox() {
+        try {
+          askBox.blur()
+        } catch (error) {
+          /* 桩环境 */
+        }
         try {
           askBox.focus({ preventScroll: true })
         } catch (error) {
@@ -5841,7 +7417,7 @@ window.__ModuleLoader__.load({
       /** 内容变高后把面板拉回视口内。 */
       function keepInsideViewport() {
         if (!panelOpen) return
-        var rect = panel.getBoundingClientRect()
+        var rect = panelLayoutRect()
         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))
@@ -6205,46 +7781,58 @@ window.__ModuleLoader__.load({
         return folded
       }
 
-      function sanitizeToolResidue(text) {
-        var out = String(text || '')
-        out = out.replace(/<ds_safety_tool_call>[\s\S]*?<\/ds_safety_tool_call>\s*/gi, '')
-        out = out.replace(/<ds_safety_tool_call>[\s\S]*$/i, '')
-        out = out.replace(/<\/?ds_safety_tool_call>\s*/gi, '')
-        // DeepSeek 原生 DSML 工具调用（全角竖线 U+FF5C 包起来的 tool_calls/invoke/parameter）。
-        // host 侧已经在流里滤过一道，这里兜住"旧缓存 / 历史回放 / 升格"这些不经过 host 的路径。
-        // 形态不止一种：marker 与标签名之间**可能有空格**（实测），且可能是逐标签式
-        // （只有 <MARK parameter …> 而没有 tool_calls 包裹）——按"标签栈"整段丢掉最稳。
-        var dsml = '\uFF5C\uFF5CDSML\uFF5C\uFF5C'
-        var tag = new RegExp('</?\\s*' + dsml + '\\s*(?:tool_calls|calls|invoke|parameter)\\b[^>]*>', 'g')
-        out = stripTaggedBlocks(out, tag)
-        out = stripTaggedBlocks(out, /<\/?\s*ds_safety_tool_call\s*>/gi)
-        return out
-      }
 
-      /** 按标签栈把"残渣块"整段删掉（未闭合就删到结尾）。 */
-      function stripTaggedBlocks(text, tag) {
-        var out = ''
-        var rest = text
-        var depth = 0
-        for (;;) {
-          tag.lastIndex = 0
-          var hit = tag.exec(rest)
-          if (!hit) {
-            if (depth === 0) out += rest
-            break
+      /**
+       * 当前面板底色是深还是浅（'dark' | 'light'）。
+       *
+       * 用途：网页输出时告诉 host 该按哪套配色生成页面 —— 深色 Harness 里给一张白底页面很刺眼。
+       * 判据优先用面板自己的 `data-theme`（painter 已经按实际底色设过），
+       * 没有就现算一次 `isDarkSurface`，再不行按浅色兜底。
+       */
+      function currentSurfaceTheme() {
+        try {
+          // ① 先读 **DSH 自己的信号**：`body[data-ds-dark-theme]`。
+          //    这是 DSH 把"当前配色方案"投影到 document 的结果 —— 用户选的是
+          //    「浅色 / 深色 / 跟随系统」哪一档都无所谓，这里拿到的都是**最终结论**。
+          // 踩过的坑：一开始只看面板的合成底色（isDarkSurface）—— 面板底色取自 DSH 变量、
+          // 自身与祖先的 background-color 往往是透明的，于是被算成浅色。
+          // 用户实测：外观设为"跟随系统（暗）"时，生成的网页却是亮色。
+          var bodyEl = document.body
+          if (bodyEl && bodyEl.getAttribute && bodyEl.getAttribute('data-ds-dark-theme') !== null) return 'dark'
+          // ② html 的 color-scheme：DSH 同时用它驱动原生控件，浅/深都会写上
+          var rootEl = document.documentElement
+          if (rootEl) {
+            var scheme = ''
+            try {
+              scheme = String((window.getComputedStyle(rootEl) || {}).colorScheme || '')
+            } catch (error) {
+              scheme = ''
+            }
+            if (!scheme && rootEl.style) scheme = String(rootEl.style.colorScheme || '')
+            if (scheme.indexOf('dark') >= 0) return 'dark'
+            if (scheme.indexOf('light') >= 0) return 'light'
           }
-          if (depth === 0) out += rest.slice(0, hit.index)
-          depth = hit[0].charAt(1) === '/' ? Math.max(0, depth - 1) : depth + 1
-          rest = rest.slice(hit.index + hit[0].length)
+          // ③ 面板自己的 data-theme（painter 设过）
+          var attr = panel && panel.getAttribute ? panel.getAttribute('data-theme') : ''
+          if (attr === 'dark' || attr === 'light') return attr
+          // ④ 合成底色兜底（可能误判，所以放在后面）
+          if (isDarkSurface(panel)) return 'dark'
+          // ⑤ 最后才问系统偏好（"跟随系统"且上面都读不到时的兜底）
+          if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) return 'dark'
+          return 'light'
+        } catch (error) {
+          return 'light'
         }
-        return out
       }
 
-      /** 当前可见的原文（已去掉伪造的工具调用）。 */
+      /** 当前可见的原文。
+       *
+       * 以前这里会剥掉"伪造的工具调用"文本（DSML / ds_safety_tool_call），
+       * 现在**不再做任何文本清洗** —— 照主会话的做法：工具每轮都在请求里，
+       * 模型走协议层表达调用，正文里根本不该出现这种标记。
+       * 清洗留在那儿只会再吃一次正文（未闭合就删到结尾）。 */
       function visibleRaw() {
-        var cleaned = sanitizeToolResidue(state.raw)
-        if (cleaned !== state.raw) state.toolResidue = true
-        return cleaned
+        return state.raw
       }
 
       // ────────────────────── 小窗对话历史（A′） ──────────────────────
@@ -6303,6 +7891,8 @@ window.__ModuleLoader__.load({
         state.raw = ''
         state.phase = 'done'
         state.error = ''
+        // 打开历史/命中缓存也是"已完成"状态 → 光标交回输入框
+        askFocusAfterTurn()
         state.sharedCache = false
         state.fromCache = source === 'local'
         state.fromHistory = source !== 'local'
@@ -6371,7 +7961,7 @@ window.__ModuleLoader__.load({
        * 高度跟面板对齐（上限视口高度），自带滚动条。
        */
       function placeHistoryList() {
-        var rect = panel.getBoundingClientRect()
+        var rect = panelLayoutRect()
         var width = 250
         var gap = 10
         var viewportW = window.innerWidth || 1200
@@ -6588,6 +8178,28 @@ window.__ModuleLoader__.load({
           })
       }
 
+      /**
+       * 撤掉"进行中"类提示：`conclusion-retry`（"查询已完成，正在整理结论…"）是**过程状态** ——
+       * 正文一开始到达、或者本轮结束，它就该消失。
+       *
+       * 踩过的坑：这条提示写进 answerTurn.notice 之后，**全代码没有任何地方清掉它** ——
+       * 回答早就写完了，黄条还挂在气泡上（用户截图报的现象）。
+       * 其余 notice（effort-clamped / effort-rejected / reasoning-leak）是"这条回答发生了什么"的
+       * 说明，属于该留下的信息，不在这里清。
+       */
+      function clearTransientNotice(turn) {
+        if (!turn) return false
+        var code = String(turn.noticeCode || '')
+        // conclusion-retry：进行中状态，正文到了就撤；
+        // upstream-retry：上游偶发错误（host 已换档重试），重试成功时正文会到、失败时走 error，
+        //   两种情况都不该把这句一直挂在回答上面。
+        // effort-rejected / reasoning-leak 是"这个模型这一档有问题"的结论性说明，留着。
+        if (code !== 'conclusion-retry' && code !== 'upstream-retry') return false
+        turn.notice = ''
+        turn.noticeCode = ''
+        return true
+      }
+
       /** 工具名 → 中文标签（只用于内部摘要，不上界面）。 */
       function toolLabel(name) {
         // 小窗默认用的是 free-search 插件的工具（见 host 侧 toolNames 注释）
@@ -6688,6 +8300,51 @@ window.__ModuleLoader__.load({
         }
       }
 
+      /**
+       * 面板被内容顶出屏幕 → 收回可视区。
+       *
+       * 为什么需要：开窗时"放得下吗"是按**当时**的高度算的（那会儿往往只有一行翻译在流），
+       * 之后正文长高（上限 78vh 或 720px），面板从固定的 top 往下长 —— 而它是 position:fixed、
+       * 页面不滚，被顶出视口的那部分（通常是回复框）就点不到了（实测能挂出去 287px）。
+       *
+       * 用面板**自己**的 ResizeObserver：只在尺寸变化时触发（内容长高、拖拽、阶段切换都算），
+       * 而挪位置（left/top）不改变尺寸 → 不存在"写回自身"的循环。
+       * 每帧只多一次 getBoundingClientRect，且只在真的溢出时才写样式。
+       */
+      var panelGrowWatch = null
+
+      /**
+       * 复核一次：面板被顶出视口就收回来（只在真的溢出时才写样式）。
+       *
+       * 两条入口都会调它：
+       *   · paint() —— 流式/内容变化时的**主力**（渲染本来就节流在 90ms，一次 rect 读约 0.02ms）；
+       *   · 面板自己的 ResizeObserver —— 兜住不经过 paint 的尺寸变化（阶段切换、composer 长高）。
+       *
+       * ⚠️ 曾经只挂 ResizeObserver，实测**不生效**：内容长高时面板往往已经顶到 max-height，
+       * 伸长的是内部滚动区 —— 面板尺寸不变，观察器根本不触发（冒烟用例里探针显示 open:false、
+       * 且灌内容后零唤醒）。所以主力必须是绘制路径上的复核。
+       */
+      function ensurePanelInsideViewportNow() {
+        if (!panelOpen || panelInteracting) return
+        var rect = panelLayoutRect()
+        if (rect.bottom <= window.innerHeight - 4) return
+        clampPanelPosition()
+      }
+
+      function ensurePanelInsideViewport() {
+        if (panelGrowWatch || typeof ResizeObserver !== 'function') return null
+        panelGrowWatch = new ResizeObserver(function () {
+          ensurePanelInsideViewportNow()
+        })
+        panelGrowWatch.observe(panel)
+        return function () {
+          if (panelGrowWatch) {
+            panelGrowWatch.disconnect()
+            panelGrowWatch = null
+          }
+        }
+      }
+
       /** 滚轮/触摸：用户自己滚 = 立刻收回跟随权；滚回底部再交还。 */
       function noteUserScroll(event) {
         var up = event && typeof event.deltaY === 'number' && event.deltaY < 0
@@ -6766,7 +8423,7 @@ window.__ModuleLoader__.load({
             if (node.__sig !== sig) {
               // 内容没变就别重建：重建会把预览 iframe 一起换掉（多建一次 = 白闪一次）
               node.__sig = sig
-              renderRich(node, sanitizeToolResidue(turn.text) || '…', { settled: turn.streaming !== true })
+              renderRich(node, turn.text || '…', { settled: turn.streaming !== true })
             }
             paintNotice(node, turn)
             paintQuoteAll(node, turn)
@@ -6829,7 +8486,7 @@ window.__ModuleLoader__.load({
           bubble.className += ' dsh-sel-bubble-err'
           bubble.textContent = turn.text
         } else {
-          renderRich(bubble, sanitizeToolResidue(turn.text) || '…', { settled: turn.streaming !== true })
+          renderRich(bubble, turn.text || '…', { settled: turn.streaming !== true })
         }
         if (turn.role !== 'user') {
           paintNotice(bubble, turn)
@@ -6869,7 +8526,7 @@ window.__ModuleLoader__.load({
             event.stopPropagation()
             var source = existing.__turn
             if (!source) return
-            var body = foldForHistory(sanitizeToolResidue(source.text))
+            var body = foldForHistory(source.text)
             // 整条引用同样不带上下文：出处写进标签（「小窗第 N 轮回答」），对话本身在历史里
             addQuote(body, turnLabelOf(source), { context: '', session: false })
           })
@@ -6878,7 +8535,7 @@ window.__ModuleLoader__.load({
 
       /** 把首轮解读结果作为追问的第一条助手上下文（截断，避免过长）。 */
       function seedHistoryFromExplanation() {
-        var fallback = splitSections(sanitizeToolResidue(state.raw))
+        var fallback = splitSections(state.raw)
         var translation = (state.parts.translation || fallback.translation || '').trim()
         var detail = (state.parts.detail || fallback.detail || '').trim()
         // 写成"前情提要"而不是"我上一轮的回答"：否则模型会顺着把两节内容再复述一遍
@@ -6999,6 +8656,17 @@ window.__ModuleLoader__.load({
           setStatus('正在取引用的上下文…')
           return
         }
+        // ⚠️ 到这里才算"收下了这条提问"，此刻才清空输入框。
+        //
+        // 以前是**调用方先清空、再调 ask()**：于是"生成中按 Enter"这种被 ask() 拒掉的情况，
+        // 输入框已经被清空 —— 用户打的字直接丢了（只剩一句"还在生成，请稍候…"）。
+        // 清空放在这里，就不会再出现"没送出去却清掉了"。
+        // 只清"确实是这条提问的内容"：ask() 也可能被程序用别的文本调用（测试钩子等），
+        // 那种情况下输入框里的东西不该被抹掉。
+        if (askBox.value && String(askBox.value).trim() === asked) {
+          askBox.value = ''
+          refreshAskState()
+        }
         // 引用是"下一条提问"的：立刻清空（提问已经在手上，别让下一轮又带上）
         if (quotes.length > 0) {
           state.quotes = []
@@ -7089,6 +8757,8 @@ window.__ModuleLoader__.load({
           clearInterval(timer)
           state.asking = false
           state.toolBusy = false
+          // 本轮结束了："正在整理结论…"这类过程提示一律撤掉（结论轮一个字没吐时也别留着）
+          clearTransientNotice(answerTurn)
           answerTurn.asking = false
           answerTurn.streaming = false
           clearWaiting(chatLog)
@@ -7112,6 +8782,10 @@ window.__ModuleLoader__.load({
                 ? ''
                 : '追问完成 · 耗时 ' + ((Date.now() - startedAt) / 1000).toFixed(1) + 's',
           )
+          // 一轮**追问**结束（成功 / 失败 / 被停止）—— 与小窗其它轮同一条规则：光标交回输入框。
+          // ⚠️ 这里原来是漏的：首轮的 succeed/fail 有规则，追问这条路径没有，
+          // 所以"追问失败"之后输入框里不出现光标（用户实测）。
+          askFocusAfterTurn()
         }
 
         fetch(API, {
@@ -7124,7 +8798,8 @@ window.__ModuleLoader__.load({
             sessionId: panelOrCurrentSessionId(),
             question: sent,
             history: history,
-            ...(state.webAnswer ? { webAnswer: true } : {}),
+            // 网页输出要跟着当前深浅走：深色 Harness 里给一张白底页面会很刺眼
+            ...(state.webAnswer ? { webAnswer: true, theme: currentSurfaceTheme() } : {}),
             ...(state.modelChoice ? { provider: state.modelChoice.provider, model: state.modelChoice.model } : {}),
             ...(state.effort ? { effort: state.effort } : {}),
             ...(state.toolDigest ? { toolDigest: state.toolDigest } : {}),
@@ -7159,6 +8834,8 @@ window.__ModuleLoader__.load({
                   continue
                 }
                 if (message.type === 'delta') {
+                  // 正文开始到达 → 撤掉"正在整理结论…"这类过程提示（以前它永远挂着）
+                  clearTransientNotice(answerTurn)
                   if (!answerTurn.text.trim()) answerTurn.asking = false
                   answerTurn.text += message.text
                   scheduleTurnsRender()
@@ -7195,15 +8872,16 @@ window.__ModuleLoader__.load({
                   // host 发现档位被上游拒绝（400/401/500）会自动去掉档位重试，这里如实告诉用户，
                   // 并把"这个模型不吃这个档位"记下来 —— 下次不再拿同一个组合去撞墙
                   answerTurn.notice = String(message.text || '')
+                  // 记下 code：'conclusion-retry' 是"进行中"状态，正文到了/本轮结束就该撤
+                  answerTurn.noticeCode = String(message.code || '')
                   if ((message.code === 'effort-rejected' || message.code === 'reasoning-leak') && message.tier) {
+                    // 记下"这个模型的这一档被拒 / 会泄漏"，菜单里给它划一道斜线（下次不再撞）
                     rememberBadTier(message.tier, message.code === 'reasoning-leak' ? 'leak' : 'rejected')
-                    // 回退到默认档：清掉持久化的选择，胶囊随即显示配置里的默认档
-                    state.effort = null
-                    writeStore(EFFORT_KEY, '')
+                    // **不动**用户选的那一格：设置页与菜单读的就是它（唯一一份数据），
+                    // 悄悄清掉会让人以为自己没选过；这一轮该发什么由 host 的换档重试兜。
                     paintModelPill()
                   }
-                  scheduleTurnsRender()
-                } else if (message.type === 'error') {
+                  scheduleTurnsRender()                } else if (message.type === 'error') {
                   finish(message.message || '模型返回错误')
                 }
               }
@@ -7316,6 +8994,7 @@ window.__ModuleLoader__.load({
         entry.effort = opts.effort || ''
         entry.effortOf = opts.effortOf || null
         entry.thoughtOf = opts.thoughtOf || null
+        entry.noticeOf = opts.noticeOf || null
         entry.busyOf = opts.busyOf || toolBusyNow
         updateWaitClocks()
         return entry
@@ -7347,9 +9026,14 @@ window.__ModuleLoader__.load({
           if (!entry.hint) continue
           var thinking = entry.thoughtOf ? String(entry.thoughtOf() || '') : ''
           thinking = thinking.replace(/\s+/g, ' ').trim()
+          var notice = entry.noticeOf ? String(entry.noticeOf() || '') : ''
+          notice = notice.replace(/\s+/g, ' ').trim()
           if (entry.busyOf && entry.busyOf()) {
             // 检索阶段：只说"在查资料"。查询词/命中/链接都不进小窗（那是模型的原料，不是结果）
             entry.hint.textContent = '🔍 正在检索资料…'
+          } else if (notice) {
+            // host 的"正在换档重试 / 上游偶发错误"比思考尾巴更该让人看见（它解释了这段时间去哪了）
+            entry.hint.textContent = '↻ ' + notice.slice(-72)
           } else if (thinking) {
             // 看得见它在想什么，就不会以为"没反应"了
             entry.hint.textContent = '💭 ' + thinking.slice(-72)
@@ -7384,8 +9068,8 @@ window.__ModuleLoader__.load({
         state.aborted = false
         state.stageEffort = ''
         state.thought = ''
+        state.notice = ''
         state.tools = []
-        state.toolResidue = false
         state.startedAt = Date.now()
         state.elapsed = 0
         paint()
@@ -7409,6 +9093,8 @@ window.__ModuleLoader__.load({
           // 用户收起小窗导致的中止：不算失败，记成"已停止"，重开还能接着看
           state.phase = state.aborted ? 'paused' : 'error'
           state.error = state.aborted ? '' : message
+          // 一轮失败/中止结束 → 同样把光标交回输入框，用户可以直接重试或换个问法
+          askFocusAfterTurn()
           state.toolBusy = false
           state.elapsed = Date.now() - state.startedAt
           stopTicker()
@@ -7419,6 +9105,8 @@ window.__ModuleLoader__.load({
 
         function succeed() {
           state.phase = 'done'
+          // 一轮成功结束 → 光标交回输入框（小窗自己的规则，见 askFocusAfterTurn）
+          askFocusAfterTurn()
           // 按内容归并（stage 只决定"请求哪一节"，不决定结果落到哪个格子）：
           // 模型偶尔会两节都写，或没写标题，这里都要接住
           var parsed = splitSections(visibleRaw())
@@ -7472,7 +9160,13 @@ window.__ModuleLoader__.load({
             } else if (message.type === 'delta') {
               state.raw += message.text
               state.phase = 'streaming'
+              // 正文到了 = 那次换档重试成功了，等待提示里那句"已自动重试"不必再挂着
+              state.notice = ''
               dirty = true
+            } else if (message.type === 'notice') {
+              // host 的"正在换档重试 / 上游偶发错误"：以前这条分支不存在，全被丢掉。
+              // 不 schedulePaint：由 200ms 的 ticker 写字，和 thought 同一条路。
+              state.notice = String(message.text || '')
             } else if (message.type === 'thought') {
               // 只留尾巴：等待提示里显示"正在想什么"，不给正文添乱；
               // 刻意不 schedulePaint —— 由 200ms 的 ticker 写字，思考流不会把界面刷爆
@@ -7520,6 +9214,11 @@ window.__ModuleLoader__.load({
                 state.chars = state.raw.length
               }
               paint()
+              // 复核放在**绘制之后**：内容这时候才在 DOM 里，面板这一帧长高的量当场就能夹住
+              //（放在 paint 开头会晚一帧——那帧量到的还是旧高度，实测过）。
+              // 位置只在开窗/拖拽/窗口 resize 时夹过，内容长高这条路径原先没人管 ——
+              // 面板是 position:fixed、页面不滚，顶出去那截（回复框）就点不到了。
+              ensurePanelInsideViewportNow()
             })
           }
           // 流式期间限速（同 scheduleTurnsRender）：长内容每帧整块重建会把小窗拖卡
@@ -7598,8 +9297,8 @@ window.__ModuleLoader__.load({
         // 用分阶段保存的结果：展开详解后 state.raw 里只有详解那一段，
         // 直接拿 raw 解析会导致翻译丢失（升格出来的会话里翻译变成「未记录」）
         var sections = {
-          translation: state.parts.translation || splitSections(sanitizeToolResidue(state.raw)).translation,
-          detail: state.parts.detail || splitSections(sanitizeToolResidue(state.raw)).detail,
+          translation: state.parts.translation || splitSections(state.raw).translation,
+          detail: state.parts.detail || splitSections(state.raw).detail,
         }
         state.promoting = true
         promoteButton.disabled = true
@@ -7745,6 +9444,21 @@ window.__ModuleLoader__.load({
         scheduleCheck()
       }, true)
 
+      /**
+       * Esc 收语音卡。
+       *
+       * 用 capture 抢在最前面：卡片是当下最内层的东西，Esc 该先退它
+       * （小窗那套 Esc 是"从最内层往外退"，这里是同一条规则往外多包一层）。
+       * 已经说出来的字**丢掉**：卡还没发出去，取消就是取消；要留着就先点发送。
+       */
+      var offVoiceEscape = listen(document, 'keydown', function (event) {
+        if (event.key !== 'Escape' || !vcardState.open || event.defaultPrevented) return
+        event.preventDefault()
+        event.stopPropagation()
+        vcardState.suppress = true
+        closeVCard(true)
+      }, true)
+
       /**
        * 浮标亮着的时候，隔几拍确认一次"那段文字还在不在"。
        *
@@ -7850,9 +9564,8 @@ window.__ModuleLoader__.load({
       // —— 悬浮状态胶囊：点一下回到最近一次小窗 ——
       // —— 模型 + 推理等级（追问档） ——
       var MODEL_KEY = 'dsh-selection-explain:model' // 存 "provider\tmodel"
-      var EFFORT_KEY = 'dsh-selection-explain:effort'
-      var TIER_LABEL = { off: '关', low: '低', medium: '中', high: '高', max: '最大' }
-      var FALLBACK_TIERS = ['off', 'low', 'high', 'max']
+      /** 四个格子的中文名（设置页与小窗共用一套词；`medium` 只在标注模型自己的档位时出现）。 */
+      var TIER_LABEL = { off: '关', low: '低', medium: '中', high: '高', max: '最高' }
       /**
        * 模型清单缓存。
        *
@@ -8012,6 +9725,11 @@ window.__ModuleLoader__.load({
         modelPillTier.textContent = tier ? '· ' + tierLabel(tier) : ''
         modelPill.title = (provider ? provider + ' · ' : '') + name + (tier ? ' · 推理等级 ' + tierLabel(tier) : '') +
           '（模型与追问思考强度）'
+        // 胶囊是"当前模型"的**唯一**统一落点：换模型的所有路径最后都会走到这里
+        //（设置抽屉的模型下拉、小窗的模型菜单、跟随主会话时主界面换模型…），
+        // 设置页那行"四格 → 真实档位"也在这里跟着重画 —— 早先只在 chooseSharedModel 里画，
+        // 于是"从抽屉的下拉里换模型"那行纹丝不动（用户报的正是这个）。
+        paintEffortMapHint()
       }
 
       /**
@@ -8133,44 +9851,51 @@ window.__ModuleLoader__.load({
         modelMenu.appendChild(el('div', 'dsh-sel-pickersplit'))
         modelMenu.appendChild(el('div', 'dsh-sel-pickergroup', '推理等级（追问档）'))
         var tiers = el('div', 'dsh-sel-tiers')
-        var effortIds = FALLBACK_TIERS
-        // 档位按钮列的是**当前在用那个模型**声明的档位（跟随态也照它列，否则列出来的档位
-        // 和实际发出去的模型对不上）
-        var inUseItem = effectiveItem()
-        if (inUseItem && (inUseItem.efforts || []).length > 0) {
-          effortIds = []
-          for (var e = 0; e < inUseItem.efforts.length; e += 1) effortIds.push(inUseItem.efforts[e].id)
-        }
+        /**
+         * 档位按钮 = 与设置页**同一套四个格子**（关/低/高/最高）。
+         *
+         * 以前这里列的是"该模型自己声明的档位"（可能是 minimal/medium/xhigh 这种），于是
+         * 两边词汇不同、还要把模型档位反向折回格子；现在两边同词同源：这里的选中值就是
+         * 配置里的 `chatReasoningEffort`，改一边另一边跟着变，没有任何映射。
+         * 格子落到模型哪个真实档位由 host 算（见设置页那行"当前模型：关 → …"）。
+         */
+        var tierItem = effectiveItem()
+        var tierMap = (tierItem && tierItem.effortMap) || null
         var badTiers = badTiersOf()
         // host 在进程内学到的：这个模型"关"档会把思考写进正文
         var leaky = effectiveChoice()
         if (leaky && modelCatalog.leakyOff.indexOf(leaky.provider + '/' + leaky.model) >= 0) {
           badTiers = { ...badTiers, off: 'leak' }
         }
-        var active = state.effort || (modelCatalog.stages && modelCatalog.stages.chat) || ''
-        for (var t = 0; t < effortIds.length; t += 1) {
-          ;(function (id) {
-            var button = el('button', 'dsh-sel-tierbtn', tierLabel(id))
+        var activeSlot = chatSlot()
+        for (var t = 0; t < SLOT_ORDER.length; t += 1) {
+          ;(function (slot) {
+            // 这一格的落点（模型真实档位）：用来把"实测被拒/会泄漏"的标注对上来
+            var target = (tierMap && tierMap[slot]) || slot
+            var bad = badTiers[slot] || (target !== slot ? badTiers[target] : '')
+            var button = el('button', 'dsh-sel-tierbtn', SLOT_LABEL[slot])
             button.type = 'button'
-            button.setAttribute('data-on', id === active ? '1' : '0')
-            if (badTiers[id]) {
+            button.setAttribute('data-on', slot === activeSlot ? '1' : '0')
+            button.setAttribute('data-slot', slot)
+            if (bad) {
               button.setAttribute('data-bad', '1')
               button.title =
-                badTiers[id] === 'leak'
-                  ? '实测该模型在「' + tierLabel(id) + '」档会把思考写进正文：已自动改用「低」档'
-                  : '实测该模型不支持「' + tierLabel(id) + '」档：选它会自动回退到默认档'
+                bad === 'leak'
+                  ? '实测该模型在这一档会把思考写进正文：已自动改用「低」档'
+                  : '实测该模型不支持这一档：选它会自动回退到默认档'
             }
+            if (target !== slot) button.title = (button.title ? button.title + ' · ' : '') + '该模型发 ' + target
             listen(button, 'click', function (event) {
               event.preventDefault()
               event.stopPropagation()
-              state.effort = id
-              writeStore(EFFORT_KEY, id)
+              // 唯一写入口：写的就是设置页那一行读的那个值
+              setChatSlot(slot)
               paintModelPill()
               renderModelMenu()
-              setStatus('追问档位：' + tierLabel(id))
+              setStatus('追问档位：' + SLOT_LABEL[slot] + (target !== slot ? '（该模型发 ' + target + '）' : ''))
             })
             tiers.appendChild(button)
-          })(effortIds[t])
+          })(SLOT_ORDER[t])
         }
         modelMenu.appendChild(tiers)
         modelMenu.appendChild(
@@ -8247,8 +9972,8 @@ window.__ModuleLoader__.load({
       // 模型/档位：从 localStorage 恢复；没存过就跟随"当前路由 + 配置档位"（ping 里就有）
       // 从 host 的统一设置恢复模型，不读取旧浏览器模型覆盖。
       loadSettings(false)
-      var storedEffort = readStore(EFFORT_KEY, '')
-      if (storedEffort) state.effort = storedEffort
+      // 「追问」档位不再有浏览器本地覆盖：设置页那一行、小窗那四个格子、发出去的请求
+      // 读的都是同一份配置（chatReasoningEffort，加载完由 applyServerValues 同步进 state.effort）
       paintModelPill()
       fetch(PING + (currentSessionId() ? '?sessionId=' + encodeURIComponent(currentSessionId()) : ''), {
         headers: { accept: 'application/json' },
@@ -8485,8 +10210,7 @@ window.__ModuleLoader__.load({
         var question = askBox.value
         // 空输入框照发**只在挂了引用时**成立（引用本身就是用户要送出去的内容）
         if (!question.trim() && state.quotes.length === 0) return
-        askBox.value = ''
-        refreshAskState()
+        // 清空交给 ask()：它收下才清（生成中被拒时保留你打的字）
         ask(question)
       })
 
@@ -8502,8 +10226,7 @@ window.__ModuleLoader__.load({
         }
         var question = askBox.value
         if (!question.trim() && state.quotes.length === 0) return
-        askBox.value = ''
-        refreshAskState()
+        // 清空交给 ask()：它收下才清
         ask(question)
       })
 
@@ -9762,7 +11485,7 @@ window.__ModuleLoader__.load({
         if (promoteButton.contains(event.target) || closeButton.contains(event.target)) return
         if (settingsButton.contains(event.target) || historyButton.contains(event.target)) return
         event.preventDefault()
-        var rect = panel.getBoundingClientRect()
+        var rect = panelLayoutRect()
         var offsetX = event.clientX - rect.left
         var offsetY = event.clientY - rect.top
         panelInteracting = true
@@ -9781,6 +11504,7 @@ window.__ModuleLoader__.load({
         window.addEventListener('mouseup', up, true)
       })
 
+      ensurePanelInsideViewport()
       bindResizeGrip(gripCorner, 'se')
       bindResizeGrip(gripRight, 'e')
       bindResizeGrip(gripBottom, 's')
@@ -9798,6 +11522,58 @@ window.__ModuleLoader__.load({
 
       // —— 调试钩子（自动化验证用） ——
       window.__dshSelectionExplain = {
+        /**
+         * 语音卡（选中文字 + 输入法正在语音输入 → 就地追问）的状态。
+         * 给自动化验证用：能不能弹、有没有焦点、几何对不对，全在这里读。
+         */
+        voiceCard: function () {
+          return {
+            open: vcardState.open,
+            closing: vcardState.closing,
+            watching: !!vcardState.timer,
+            /** 正在等文字定稿（松手后输入法还会智能整理）；settleFor = 距上次文字变化多久（毫秒）。 */
+            settling: !!vcardState.settleTimer,
+            settleFor: vcardState.settleStableAt ? Date.now() - vcardState.settleStableAt : -1,
+            voiced: !!(vcard && vcard.getAttribute('data-voiced') === '1'),
+            hasText: !!(vcard && vcard.getAttribute('data-text') === '1'),
+            text: vcardBox ? vcardBox.value : '',
+            focused: !!(vcardBox && document.activeElement === vcardBox),
+            geometry: vcard
+              ? {
+                  left: vcard.style.left,
+                  top: vcard.style.top,
+                  width: vcard.style.width,
+                  height: vcard.style.height,
+                }
+              : null,
+          }
+        },
+        /** 手工把卡打开/收起/发送（测试与调试用；正常路径由麦克风轮询驱动）。 */
+        /** 调试：最后一次自动聚焦卡在哪一步。 */
+        focusBail: function () {
+          return focusBail
+        },
+        /** 重新拉一次设置（测试用：设置只在启动时读一次，桩里改完值要能刷新）。 */
+        reloadSettings: function () {
+          loadSettings(true)
+          return Object.assign({}, settingsLive)
+        },
+        voiceCardOpen: function () {
+          openVCard()
+          return window.__dshSelectionExplain.voiceCard()
+        },
+        voiceCardClose: function () {
+          closeVCard()
+          return window.__dshSelectionExplain.voiceCard()
+        },
+        voiceCardSend: function (text) {
+          if (vcardBox && text !== undefined) {
+            vcardBox.value = String(text)
+            syncVCardText()
+          }
+          sendVCard()
+          return true
+        },
         /** 重新读一次 host 上的小窗尺寸（测试用；正常路径只在挂载时读一次）。 */
         loadPanelSize: function () {
           panelSizeAsked = false
@@ -9806,7 +11582,7 @@ window.__ModuleLoader__.load({
         },
         /** 当前小窗几何（测试用：直接读渲染值，不经过变量）。 */
         panelGeom: function () {
-          var rect = panel.getBoundingClientRect()
+          var rect = panelLayoutRect()
           return { x: rect.left, y: rect.top, w: rect.width, h: rect.height, resized: panel.getAttribute('data-resized') === '1' }
         },
         /** 重新读一次 host 上的胶囊位置（测试用；正常路径只在挂载时读一次）。 */
@@ -10036,8 +11812,7 @@ window.__ModuleLoader__.load({
             stageEffort: state.stageEffort,
             raw: state.raw,
             model: state.model,
-            sections: splitSections(sanitizeToolResidue(state.raw)),
-            toolResidue: state.toolResidue,
+            sections: splitSections(state.raw),
             tools: state.tools.length,
             toolBusy: state.toolBusy,
             toolDigest: state.toolDigest,
@@ -10056,10 +11831,6 @@ window.__ModuleLoader__.load({
         pill: function () {
           return pill
         },
-        /** 自检用：残渣清理（供单测直接打表）。 */
-        stripResidue: function (text) {
-          return sanitizeToolResidue(text)
-        },
         /** 自检用：模型/档位当前值 + 已加载的目录规模。 */
         modelState: function () {
           return {
@@ -10277,6 +12048,7 @@ window.__ModuleLoader__.load({
           offMouseUp()
           offKeyUp()
           offSelectionChange()
+          offVoiceEscape()
           if (floatWatchId) clearInterval(floatWatchId)
           offMouseDown()
           offButtonDown()
@@ -10326,6 +12098,10 @@ window.__ModuleLoader__.load({
           offBodyTouch()
           offBodyScroll()
           if (chatGrowWatch) chatGrowWatch.disconnect()
+          if (panelGrowWatch) {
+            panelGrowWatch.disconnect()
+            panelGrowWatch = null
+          }
           if (pillPlacerId) clearTimeout(pillPlacerId)
           if (pillObserver) {
             try {