@yfwu2020/dsh-selection-explain 0.8.3 → 0.9.0

package/README.md

@@ -356,6 +356,42 @@ curl -s http://127.0.0.1:3080/selection-explain/api/ping
 
 ---
 
+## 档位兜底：「关」档不被支持时自动降级
+
+有些模型**不接受关闭推理**（上游直接 `400 invalid_request_error`）。首轮默认就是 `off`，
+撞上这种模型时整个划词解读会全挂。
+
+处理方式：
+
+- 撞到一次就**记住这个 provider/model**（`${DSH_HOME:-~/.dsh}/selection-explain/leaky-off.json`
+  的 `noOff` 字段），改用 **`low`**（最接近"关"的可接受档位）重试同一轮，并推一条 notice 说明。
+- **下次不再尝试 `off`** —— 直接发 `low`，不再先失败一轮（省一个来回的时延，也不闪报错）。
+- 重试只在"这一轮一个字都还没吐出来"时进行：已经出正文的失败不重试，避免把半截答案丢掉。
+- 兜底覆盖**三种轮次**（首轮 / 详解 / 追问）。以前只对追问生效、而且要客户端显式传了档位才触发，
+  所以首轮撞上这种模型时无人兜底。
+
+## 拖动与改大小
+
+小窗可以拖标题栏挪位置，拖右下角（或右/下边缘）改大小。
+
+**位置和尺寸是两回事，只有尺寸会记住：**
+
+- **位置不记**。每次开窗都按选区重新锚定：落在选区下方，下方放不下就翻到选区上方，
+  再夹进视口。拖动只对这一次有效，关掉重开就回到划词的地方 —— 这是刻意的设计。
+- **尺寸记**。拖角调过的大小存在 host 上（`${DSH_HOME:-~/.dsh}/selection-explain/panel.json`，
+  接口 `GET/POST /selection-explain/api/panel`，载荷只有 `{w,h}`），
+  刷新、换标签页、换浏览器 profile 都回到那个大小。
+- **双击右下角角标**恢复默认尺寸（清掉存档）。
+
+其余约定：
+
+- 尺寸下限 320×240，且始终夹在视口内（窗口缩小也不会超出）。上限是视口大小。
+- 用户拉过大小后，设置页那条约 560px 的高度下限就**不再插手**（`data-resized` 标记）。
+- 改动过程中不写盘，松手后防抖 300ms 再存 —— 不然每帧一个请求。
+- 改大小用 **pointer 事件**（不是 mouse）：触控板/触屏一样能拖，并且 `setPointerCapture`
+  保证鼠标划出窗口也不会丢掉这一轮。
+- 只有**真的拖动过**才会触发存档逻辑（点一下角标不算改了大小）。
+
 ## 配置
 
 ### 方式一：在小窗里改（推荐）

package/lib/client.js

@@ -29,6 +29,8 @@ window.__ModuleLoader__.load({
     var PROMOTE = '/selection-explain/api/promote'
     /** 胶囊拖到别处后的位置（记在 host 上：拖到别处→存，吸附回右下角→清，挂载→读回来）。 */
     var PILL_POS = '/selection-explain/api/pill'
+    /** 小窗的**尺寸**（改过大小之后记在 host 上，刷新后回到那个大小）。位置不记。 */
+    var PANEL_SIZE = '/selection-explain/api/panel'
     var HISTORY = '/selection-explain/api/history'
     /** 模型清单（带每个模型支持的推理等级）。 */
     var MODELS = '/selection-explain/api/models'
@@ -330,11 +332,47 @@ window.__ModuleLoader__.load({
       '.dsh-sel-layer[data-theme=dark]{--sel-a1:#4ecdc4;--sel-a1-text:#6fe3d8;--sel-a2:#4ecdc4;--sel-a2-text:#6fe3d8;',
       '--sel-fill:#4ecdc4;--sel-fill-fg:#052b26;',
       '--sel-a2-soft:color-mix(in srgb,var(--sel-a2) 16%,transparent);--sel-a1-soft:color-mix(in srgb,var(--sel-a1) 16%,transparent)}',
-      '.dsh-sel-panel{position:fixed;display:none;flex-direction:column;width:min(540px,calc(100vw - 20px));max-height:min(78vh,720px);',
-      '.dsh-sel-panel[data-stage=translation]{width:min(440px,calc(100vw - 20px))}',
+      // ⚠️ 声明块必须在**同一段字符串里收尾**。
+      // 以前这里是 `...max-height:...;` 后面直接接了一条完整规则 `[data-stage=translation]{...}`，
+      // `.dsh-sel-panel{` 的 `}` 于是永远没出现 —— 那条阶段规则被当成块内的**非法声明**整条丢弃，
+      // "首轮收窄到 440" 从来没生效过（实测计算宽度一直是 540）。后面几段的 border-radius /
+      // overflow 之所以没事，是因为 CSS 出错恢复会跳过坏声明继续往下读。
+      // 单测只断言了 data-stage 这个**属性**，而桩 DOM 没有布局，所以一直没暴露。
+      // box-sizing:border-box 是**必须**的：拖角改大小时我们把 getBoundingClientRect()（含边框）
+      // 的宽高写回 style.width/height，而它们默认按 content-box 解释 —— 差一个边框宽（1px），
+      // 于是"存进去 → 读回来"每来一轮就胖 1px，拖几次就明显走形（实测 584 存进去、读回来 586）。
+      '.dsh-sel-panel{position:fixed;display:none;flex-direction:column;box-sizing:border-box;width:min(540px,calc(100vw - 20px));max-height:min(78vh,720px);',
       'border-radius:16px;overflow:hidden;background:var(--dsw-alias-bg-layer-1,Canvas);color:var(--dsw-alias-label-primary,CanvasText);',
       'border:.5px solid var(--dsw-alias-border-l3,rgba(140,140,140,.35));box-shadow:0 20px 52px rgba(0,0,0,.3);',
       'font:400 13.5px/1.7 ' + FONT + '}',
+      // 这里曾经有一条 `.dsh-sel-panel[data-stage=translation]{width:440px}`：
+      // "首轮只出翻译时收窄一点"。它因为上面那个漏掉的 `}` 一直是死代码，修好闭合之后才真正生效，
+      // 一生效就暴露了问题 —— 宽度会**在追问那一刻从 440 跳到 540**（见 syncPanelStage 的判定），
+      // 用户看到同一个窗口自己变宽，问"怎么有追问和没追问的宽度不一样"。
+      // 决定：**统一成 540，宽度不随阶段变**。少一档就没这档子事，也没有"什么时候会跳"的心智负担。
+      // （data-stage 本身保留 —— 它还决定追问输入框显不显示，见 renderPanel。）
+      // 设置抽屉开着时只补**高度**下限，**不动宽度**。
+      //
+      // 抽屉是 inset:0 贴在面板上的：面板多宽，抽屉就多宽 —— 这是要的（设置窗口与小窗等宽，
+      // 开抽屉时小窗不该"胖一圈"）。但高度不能不管：面板高度是由"解读内容有多长"撑出来的，
+      // 刚开窗（只出了翻译）时面板才 ~115px 高，设置列表只剩 17px 可视高度（实测）。
+      // 所以只给 min-height；宽度交给面板自己的规则（首轮 440 / 其余 540），抽屉自动跟随。
+      // min-height 用 min() 与 max-height 同源，视口矮时两者相等，不会顶出屏幕。
+      // 只在**用户没自己改过尺寸**时才补这个下限：他拉过大小就按他的来（min-height 会压过 inline height）
+      '.dsh-sel-panel[data-settings="1"]:not([data-resized="1"]){min-height:min(560px,78vh)}',
+      // 改大小手柄：右下角一个角标 + 右边/下边各一条（细，不抢视线；hover/拖动时才明显）
+      // z-index 比设置抽屉(6)高 —— 但抽屉开着时整体隐藏（见下面的规则）：
+      // 抽屉页脚右侧就是「关闭」按钮，角标压上去会误点。
+      '.dsh-sel-grip{position:absolute;z-index:7;background:transparent;touch-action:none}',
+      '.dsh-sel-grip-corner{right:0;bottom:0;width:16px;height:16px;cursor:nwse-resize}',
+      '.dsh-sel-grip-r{right:0;top:12px;bottom:16px;width:6px;cursor:ew-resize}',
+      '.dsh-sel-grip-b{left:12px;right:16px;bottom:0;height:6px;cursor:ns-resize}',
+      // 手柄**不画任何常驻标识**：以前角上有一道小斜纹（两条 1.5px 边框拼的直角），
+      // 在浅色面板上看着像多出来的一笔，用户明确要求去掉。
+      // 保留 hover 时边缘的高亮（只在鼠标移上去时出现，不占视觉）——
+      // 加上 cursor: nwse-resize / ew-resize / ns-resize，可发现性还在。
+      // 抽屉开着时收起手柄（页脚右侧是「关闭」按钮，别让角标压上去）
+      '.dsh-sel-panel[data-settings="1"] .dsh-sel-grip{display:none}',
       '.dsh-sel-head{display:flex;align-items:center;gap:8px;padding:10px 10px 10px 14px;cursor:grab;user-select:none;',
       'border-bottom:.5px solid var(--dsw-alias-border-l4,rgba(140,140,140,.22))}',
       '.dsh-sel-head:active{cursor:grabbing}',
@@ -2481,6 +2519,15 @@ window.__ModuleLoader__.load({
       settingsSheet.appendChild(settingsHead)
       settingsSheet.appendChild(settingsMain)
       settingsSheet.appendChild(settingsFoot)
+      // ── 改大小手柄（右下角 + 右边缘 + 下边缘）──
+      // 小窗的尺寸/位置都由这里驱动；拖完记在 host 上（见 savePanelBox）。
+      var gripCorner = el('div', 'dsh-sel-grip dsh-sel-grip-corner')
+      var gripRight = el('div', 'dsh-sel-grip dsh-sel-grip-r')
+      var gripBottom = el('div', 'dsh-sel-grip dsh-sel-grip-b')
+      gripCorner.title = '拖动改大小（双击恢复默认）'
+      panel.appendChild(gripCorner)
+      panel.appendChild(gripRight)
+      panel.appendChild(gripBottom)
       panel.appendChild(settingsScrim)
       panel.appendChild(settingsSheet)
 
@@ -3292,6 +3339,8 @@ window.__ModuleLoader__.load({
       function openSettings() {
         if (settingsOpen) return
         settingsOpen = true
+        // 抽屉贴着面板（inset:0），所以给面板一个合适的尺寸下限 —— 否则内容短时抽屉被压成一条
+        panel.setAttribute('data-settings', '1')
         settingsSheet.setAttribute('data-open', '1')
         settingsScrim.setAttribute('data-open', '1')
         settingsButton.setAttribute('aria-pressed', 'true')
@@ -3306,6 +3355,7 @@ window.__ModuleLoader__.load({
       function closeSettings() {
         if (!settingsOpen) return
         settingsOpen = false
+        panel.removeAttribute('data-settings')
         closeModelPicks()
         settingsSheet.setAttribute('data-open', '0')
         settingsScrim.setAttribute('data-open', '0')
@@ -5225,6 +5275,209 @@ window.__ModuleLoader__.load({
         return { left: rect.left, top: rect.top, right: rect.right, bottom: rect.bottom, width: rect.width, height: rect.height }
       }
 
+      /**
+       * 小窗的尺寸（用户拖角改过之后才有值；null = 用 CSS 里的默认尺寸）。
+       *
+       * **只记尺寸，不记位置**：小窗每次开窗都必须按选区重新锚定（见 showPanel），
+       * 这是既有的设计 —— 位置一旦被记住，开窗就不再跟着划词的地方走，等于把那套锚定架空了。
+       * 尺寸是用户明确调过的东西，跨开窗保留才合理。
+       */
+      var panelSize = null
+      var panelSizeAsked = false
+      var panelSizeTimer = 0
+      /** 正在拖手柄 / 拖标题栏时，别让 window resize 的夹取插一脚。 */
+      var panelInteracting = false
+      /**
+       * 尺寸下限：比"设置页要放得下"低一点就行。真实约束在 CSS/JS 里：
+       * 太窄了模型下拉和提示文案会挤成一团，太矮了正文没得看。
+       */
+      var PANEL_MIN_W = 320
+      var PANEL_MIN_H = 240
+
+      /**
+       * 开窗时应用"记住的尺寸"。
+       *
+       * ⚠️ 宽度是**固定值**，高度只能是**上限**（max-height）。
+       *
+       * 高度要是写成固定值，新开一个会话（内容只有一小段翻译）时面板会硬撑到上次那么大，
+       * 下面留一大片空白 —— 那是回退。以前高度一直是内容撑的（`max-height` 只是个天花板），
+       * 这个手感必须保住：内容短就短，内容长才长到上限、再滚动。
+       *
+       * 所以每次开窗都把 `height` **清掉**（回到自适应），只把用户调过的高度当作新的天花板。
+       * 用户当场拖出来的尺寸在**本次**打开里照旧生效（拖动时直接写 inline height），
+       * 只是下次开窗会重新按内容自适应 —— 既没有空白，拖动也看得见反馈。
+       */
+      function applyPanelSizeOnOpen() {
+        // 先还原成"内容撑高 + CSS 默认天花板"
+        panel.style.height = ''
+        panel.style.maxHeight = ''
+        if (!panelSize) {
+          panel.style.width = ''
+          panel.removeAttribute('data-resized')
+          return
+        }
+        panel.style.width = Math.round(panelSize.w) + 'px'
+        panel.style.maxHeight = Math.round(panelSize.h) + 'px'
+        // 打过标记：设置页那条约 560 的 min-height 就别再插手了（用户已经自己定了高）
+        panel.setAttribute('data-resized', '1')
+      }
+
+      /** 当前尺寸（读实际渲染值，比拿变量算更稳 —— 拖拽过程中变量会漂）。 */
+      function currentPanelSize() {
+        var rect = panel.getBoundingClientRect()
+        return { w: rect.width, h: rect.height }
+      }
+
+      /** 夹进视口：改大小/窗口变化后都调，保证手柄还在屏幕里、小窗不会超出可视区。 */
+      function clampPanelSize(size) {
+        var maxW = Math.max(PANEL_MIN_W, window.innerWidth - 8)
+        var maxH = Math.max(PANEL_MIN_H, window.innerHeight - 8)
+        return {
+          w: Math.min(maxW, Math.max(PANEL_MIN_W, size.w)),
+          h: Math.min(maxH, Math.max(PANEL_MIN_H, size.h)),
+        }
+      }
+
+      /**
+       * 把面板夹回可视区。
+       *
+       * **每次尺寸变化之后都要调**：位置是当初按旧尺寸算好的，尺寸一变就可能把面板顶出屏幕。
+       * 用户报的就是这个 —— 小窗贴着屏幕边缘时双击角标恢复默认尺寸，一部分直接跑到屏幕外。
+       * 优先保住左上角（那是用户看到的锚点），右边/下边放不下才往回收。
+       */
+      function clampPanelPosition() {
+        var rect = panel.getBoundingClientRect()
+        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'
+        panel.style.top = Math.round(Math.min(Math.max(rect.top, 4), maxTop)) + 'px'
+        if (historyList.style.display === 'flex') placeHistoryList()
+      }
+
+      /** 存到 host（防抖：拖动过程中每帧都存会把接口打爆）。 */
+      function savePanelSize() {
+        if (panelSizeTimer) clearTimeout(panelSizeTimer)
+        panelSizeTimer = setTimeout(function () {
+          panelSizeTimer = 0
+          var size = clampPanelSize(currentPanelSize())
+          panelSize = size
+          fetch(PANEL_SIZE, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ size: size }),
+          }).catch(function () { /* 存不上不影响使用，下次再改还会存 */ })
+        }, 300)
+      }
+
+      /** 挂载时问一次（异步，回来再摆；用户已经动过就以用户的为准）。 */
+      function loadPanelSize() {
+        if (panelSizeAsked) return
+        panelSizeAsked = true
+        fetch(PANEL_SIZE)
+          .then(function (res) { return res.json() })
+          .then(function (data) {
+            var size = data && data.size
+            if (!size || panelInteracting) return
+            if (typeof size.w !== 'number' || typeof size.h !== 'number') return
+            panelSize = clampPanelSize(size)
+            if (panelOpen) {
+              applyPanelSizeOnOpen()
+              clampPanelPosition()
+            }
+          })
+          .catch(function () {})
+      }
+
+      /**
+       * 恢复默认尺寸（双击右下角）。
+       *
+       * 和"高度自适应"是**同一个动作**：把整份存档清掉 ——
+       * 宽度回到 CSS 默认（540 / 首轮阶段 440），高度清成 auto 由内容撑（也就是自适应）。
+       *
+       * ⚠️ 必须走 applyPanelSizeOnOpen() 来清，而不是手写两行 `style.width = ''`：
+       * 高度上限是写在 `style.maxHeight` 上的，只清 width/height 会把它留下 ——
+       * 用户先前把窗口**拉小**过的话，双击之后高度仍被旧上限卡着，看着就不像"恢复默认"。
+       */
+      function resetPanelSize() {
+        panelSize = null
+        // ⚠️ 先掐掉还没落盘的那次保存。
+        // savePanelSize 是防抖的，而且**在定时器触发时**才去读当前尺寸 ——
+        // 刚拖完角标马上双击还原时，这一次来不及取消的保存会在 300ms 后读到
+        // "已经还原好的默认尺寸"，又把它当成"用户选的尺寸"写回去：
+        // 还原被无声撤销，宽度还被钉死在那一刻（连带把按阶段收窄那套也废掉）。
+        if (panelSizeTimer) {
+          clearTimeout(panelSizeTimer)
+          panelSizeTimer = 0
+        }
+        applyPanelSizeOnOpen() // 宽度 / 高度 / 高度上限 一次全还原
+        fetch(PANEL_SIZE, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ clear: true }),
+        }).catch(function () {})
+        // 宽度/高度都变了 → 位置得重夹，否则贴着屏幕边缘时会被顶出去
+        clampPanelPosition()
+        autoGrowAskBox()
+      }
+
+      /**
+       * 拖手柄改大小。
+       *
+       * edge 决定这次动哪几个方向：'se' 角标两个方向都能动，'e' 只动宽，'s' 只动高。
+       * 用 pointer 事件（不是 mouse）：触控板/触屏一样能拖，而且能 setPointerCapture，
+       * 鼠标划出窗口也不会丢掉这一轮（mouse 版本会卡在中途）。
+       */
+      function bindResizeGrip(node, edge) {
+        listen(node, 'pointerdown', function (event) {
+          if (event.button !== undefined && event.button !== 0) return
+          event.preventDefault()
+          event.stopPropagation()
+          var startSize = currentPanelSize()
+          var startX = event.clientX
+          var startY = event.clientY
+          panelInteracting = true
+          var layer = panel.parentNode
+          if (layer) layer.setAttribute('data-resizing', '1')
+          try { node.setPointerCapture(event.pointerId) } catch (error) { /* 老浏览器没有就算了 */ }
+          var changed = 0
+          var move = function (moveEvent) {
+            var next = { w: startSize.w, h: startSize.h }
+            if (edge.indexOf('e') >= 0) next.w = startSize.w + (moveEvent.clientX - startX)
+            if (edge.indexOf('s') >= 0) next.h = startSize.h + (moveEvent.clientY - startY)
+            var clamped = clampPanelSize(next)
+            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'
+            panelSize = clamped
+            panel.setAttribute('data-resized', '1')
+            if (historyList.style.display === 'flex') placeHistoryList()
+          }
+          var up = function () {
+            window.removeEventListener('pointermove', move, true)
+            window.removeEventListener('pointerup', up, true)
+            panelInteracting = false
+            if (layer) layer.removeAttribute('data-resizing')
+            // 尺寸定下来后，正文/输入框要按新高度重新分配（composer 自动撑高那套）
+            autoGrowAskBox()
+            // 尺寸变了 → 位置重夹，别让面板被顶出屏幕
+            if (changed >= 2) {
+              clampPanelPosition()
+              savePanelSize()
+            }
+          }
+          window.addEventListener('pointermove', move, true)
+          window.addEventListener('pointerup', up, true)
+        })
+        // 双击角标 = 恢复默认大小
+        if (edge === 'se') {
+          listen(node, 'dblclick', function (event) {
+            event.preventDefault()
+            event.stopPropagation()
+            resetPanelSize()
+          })
+        }
+      }
+
       function showPanel(anchor) {
         panelOpen = true
         // 键盘用户开窗即可打字：这一轮的输入框一旦可见就聚焦一次（见 focusComposerOnce）
@@ -5236,6 +5489,11 @@ window.__ModuleLoader__.load({
         panel.style.display = 'flex'
         panel.style.left = '0px'
         panel.style.top = '0px'
+        // 每次都按选区重新锚定 —— **不要**在这里插"用上次的位置"的分支：
+        // 位置一旦被记住，开窗就不再跟着划词的地方走，这套锚定逻辑等于被架空。
+        // 尺寸是另一回事：宽度沿用用户调过的，高度**每次开窗都回到自适应**（只保留天花板），
+        // 否则新会话内容短、面板却硬撑成上次那么高，下面留一大片空白。
+        applyPanelSizeOnOpen()
         // 面板刚显示出来才量得到 scrollHeight：草稿里原来的几行要立刻撑开
         autoGrowAskBox()
         var width = panel.offsetWidth
@@ -5399,7 +5657,8 @@ window.__ModuleLoader__.load({
         }
 
         // —— 按阶段重排 ——
-        // 只有翻译时：更窄的面板、不显示小节序号（轻量卡片形态）
+        // 只有翻译时：不显示小节序号（轻量卡片形态）。宽度**不随阶段变**（恒 540）——
+        // 以前这里还顺手收窄到 440，追问一下又跳回 540，用户看着像窗口自己抖了一下。
         var hasDetail = !!(state.parts.detail || stage === 'detail')
         // 追问输入框：**翻译一出来就能问，不必先展开详解**
         var translationReady = state.phase === 'done' && !!state.parts.translation
@@ -7979,6 +8238,7 @@ window.__ModuleLoader__.load({
 
       // 费用胶囊的位置/尺寸会变（展开、缩放、数字变长、插件迟到挂载）→ 自适应频率地贴上去
       loadPillPos() // 先问一句上次拖到哪儿（异步，回来再摆）
+      loadPanelSize() // 小窗的尺寸也问一句（拖角改过之后才有的值；位置不记）
       placePill()
       ensureResizeWatch()
       schedulePillPlacer()
@@ -9371,10 +9631,12 @@ window.__ModuleLoader__.load({
 
       var offDrag = listen(head, 'mousedown', function (event) {
         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 offsetX = event.clientX - rect.left
         var offsetY = event.clientY - rect.top
+        panelInteracting = true
         var move = function (moveEvent) {
           panel.style.left = clamp(moveEvent.clientX - offsetX, 4, window.innerWidth - rect.width - 4) + 'px'
           panel.style.top = clamp(moveEvent.clientY - offsetY, 4, window.innerHeight - 40) + 'px'
@@ -9383,13 +9645,41 @@ window.__ModuleLoader__.load({
         var up = function () {
           window.removeEventListener('mousemove', move, true)
           window.removeEventListener('mouseup', up, true)
+          panelInteracting = false
+          // **不存位置**：拖动只对这一次有效；下次开窗仍按选区重新锚定。
         }
         window.addEventListener('mousemove', move, true)
         window.addEventListener('mouseup', up, true)
       })
 
+      bindResizeGrip(gripCorner, 'se')
+      bindResizeGrip(gripRight, 'e')
+      bindResizeGrip(gripBottom, 's')
+
+      // 窗口变小：把**尺寸**夹回可视区（位置不归这里管 —— 它由 showPanel 的锚定决定）
+      var offPanelResize = listen(window, 'resize', function () {
+        if (!panelSize || panelInteracting) return
+        var next = clampPanelSize({ w: panelSize.w, h: panelSize.h })
+        if (next.w === panelSize.w && next.h === panelSize.h) return
+        panelSize = next
+        applyPanelSizeOnOpen()
+        clampPanelPosition()
+        savePanelSize()
+      })
+
       // —— 调试钩子（自动化验证用） ——
       window.__dshSelectionExplain = {
+        /** 重新读一次 host 上的小窗尺寸（测试用；正常路径只在挂载时读一次）。 */
+        loadPanelSize: function () {
+          panelSizeAsked = false
+          loadPanelSize()
+          return true
+        },
+        /** 当前小窗几何（测试用：直接读渲染值，不经过变量）。 */
+        panelGeom: function () {
+          var rect = panel.getBoundingClientRect()
+          return { x: rect.left, y: rect.top, w: rect.width, h: rect.height, resized: panel.getAttribute('data-resized') === '1' }
+        },
         /** 重新读一次 host 上的胶囊位置（测试用；正常路径只在挂载时读一次）。 */
         loadPillPos: function () {
           pillPosAsked = false
@@ -9887,6 +10177,7 @@ window.__ModuleLoader__.load({
           cancelVoice()
           offClose()
           offDrag()
+          offPanelResize()
           offPillDown()
           offPillClick()
           offPillEnter()

package/lib/index.js

@@ -1047,6 +1047,14 @@ export function apply(ctx, rawConfig) {
     let modelCache = { at: 0, items: [] };
     /** 哪些 provider/model 在 "关" 档会把思考写进正文（实测过一次就记住，之后自动改用「低」）。 */
     const leakyOnOff = new Set();
+    /**
+     * 哪些 provider/model **根本不接受 "关" 档**（上游直接 400 invalid_request_error）。
+     *
+     * 和 leakyOnOff 分开记：那个是"能发但会泄漏"，这个是"发了就报错"。
+     * 记下来之后不再发 off，直接改用 low —— 这是"最接近关"的可接受档位。
+     * 不记的话每次划词都要先失败一轮再重试：用户看到一次报错闪动 + 多一个来回的时延。
+     */
+    const noOffRoutes = new Set();
     const leakyFile = () => join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'leaky-off.json');
     let leakyLoaded = false;
     /** 载入"关档会泄漏思考"的模型清单（跨重启保留；文件坏了就当空）。 */
@@ -1062,13 +1070,18 @@ export function apply(ctx, rawConfig) {
                     if (typeof item === 'string' && item)
                         leakyOnOff.add(item);
             }
+            if (Array.isArray(parsed?.noOff)) {
+                for (const item of parsed.noOff)
+                    if (typeof item === 'string' && item)
+                        noOffRoutes.add(item);
+            }
         }
         catch {
             /* 没有这个文件是常态 */
         }
     }
     function saveLeaky() {
-        const body = JSON.stringify({ version: 1, routes: Array.from(leakyOnOff) }, null, 0);
+        const body = JSON.stringify({ version: 1, routes: Array.from(leakyOnOff), noOff: Array.from(noOffRoutes) }, null, 0);
         void writeFile(leakyFile(), body, 'utf8').catch((error) => {
             ctx.logger?.warn?.(`[${name}] 泄漏清单写盘失败：${String(error?.message ?? error)}`);
         });
@@ -1081,6 +1094,14 @@ export function apply(ctx, rawConfig) {
         if (leakyLoaded)
             saveLeaky();
     }
+    /** 记住一个"不接受关档"的模型（内存 + 落盘）：下次直接改用 low，不再先撞一次。 */
+    function markNoOff(route) {
+        if (noOffRoutes.has(route))
+            return;
+        noOffRoutes.add(route);
+        if (leakyLoaded)
+            saveLeaky();
+    }
     const MODEL_CACHE_MS = 60_000;
     async function listModelChoices(force = false) {
         if (!force && modelCache.items.length > 0 && Date.now() - modelCache.at < MODEL_CACHE_MS)
@@ -1402,6 +1423,104 @@ export function apply(ctx, rawConfig) {
         }, 300);
         pillPosTimer.unref?.();
     }
+    /**
+     * 小窗的**尺寸**（拖角改过大小之后记下来）。
+     *
+     * 只记尺寸，**不记位置**：小窗每次开窗都由 client 按选区重新锚定
+     * （落在选区下方，放不下就翻到上方，再夹进视口）—— 那套锚定逻辑是既有的设计，
+     * 位置一旦被"记住"就等于架空了它，开窗不再跟着划词的地方走。
+     * 尺寸则是用户明确调过的东西，值得跨开窗保留。
+     */
+    const panelSizeFile = () => join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'panel.json');
+    let panelSize = null;
+    let panelSizeLoaded = false;
+    let panelSizeTimer = null;
+    /**
+     * 尺寸校验：两个数都得是有限值，并夹到一个合理的区间。
+     *
+     * client 那边已经有 min/max 了，但文件是手工可编辑的（也可能被旧版本写坏），
+     * 不能让一个 5px 宽的小窗把界面弄成没法用。
+     */
+    function normalizePanelSize(input) {
+        const value = input;
+        const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : NaN);
+        const w = num(value?.w);
+        const h = num(value?.h);
+        if (!Number.isFinite(w) || !Number.isFinite(h))
+            return null;
+        const clamp = (n, lo, hi) => Math.round(Math.min(hi, Math.max(lo, n)));
+        return { w: clamp(w, 280, 4000), h: clamp(h, 200, 4000) };
+    }
+    async function loadPanelSize() {
+        if (panelSizeLoaded)
+            return;
+        panelSizeLoaded = true;
+        try {
+            const parsed = JSON.parse(await readFile(panelSizeFile(), 'utf8'));
+            panelSize = normalizePanelSize(parsed?.size);
+        }
+        catch {
+            panelSize = null; // 没存过 / 坏了都当作"没调过"
+        }
+    }
+    function schedulePanelSizeWrite() {
+        if (panelSizeTimer)
+            clearTimeout(panelSizeTimer);
+        panelSizeTimer = setTimeout(() => {
+            panelSizeTimer = null;
+            void (async () => {
+                try {
+                    await mkdir(join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain'), { recursive: true });
+                    await writeFile(panelSizeFile(), JSON.stringify({ version: 1, size: panelSize }, null, 0), 'utf8');
+                }
+                catch (error) {
+                    ctx.logger?.warn?.(`[${name}] 写入小窗尺寸失败：${String(error?.message ?? error)}`);
+                }
+            })();
+        }, 300);
+        panelSizeTimer.unref?.();
+    }
+    /**
+     * 小窗尺寸：GET 读回来（挂载时恢复）、POST 存（{w,h}）或清（{clear:true}，回到默认尺寸）。
+     */
+    const handlePanelSize = (req, res) => {
+        void (async () => {
+            await loadPanelSize();
+            if (req.method === 'GET') {
+                sendJson(res, 200, { ok: true, size: panelSize });
+                return;
+            }
+            if (req.method !== 'POST') {
+                sendJson(res, 405, { ok: false, error: '只支持 GET / POST' });
+                return;
+            }
+            const raw = await readBody(req, 4_000);
+            let body = {};
+            try {
+                body = raw ? JSON.parse(raw) : {};
+            }
+            catch {
+                sendJson(res, 400, { ok: false, error: '请求体不是合法 JSON' });
+                return;
+            }
+            if (body.clear === true) {
+                panelSize = null;
+                schedulePanelSizeWrite();
+                sendJson(res, 200, { ok: true, size: null });
+                return;
+            }
+            const next = normalizePanelSize(body.size ?? body);
+            if (!next) {
+                sendJson(res, 400, { ok: false, error: 'size 需要 { w, h } 两个有限数值' });
+                return;
+            }
+            panelSize = next;
+            schedulePanelSizeWrite();
+            sendJson(res, 200, { ok: true, size: panelSize });
+        })().catch((error) => {
+            sendJson(res, 500, { ok: false, error: String(error?.message ?? error) });
+        });
+    };
     /**
      * 胶囊位置：GET 读回来（挂载时恢复）、POST 存（{right,y}）或清（{clear:true}，吸附回右下角时调）。
      */
@@ -2666,11 +2785,15 @@ export function apply(ctx, rawConfig) {
                 text: '该模型在「关」档会把思考写进正文，已自动改用「低」档',
             });
         }
-        const requestEffort = isChat
+        let requestEffort = isChat
             ? bodyEffort || config.chatReasoningEffort || effort
             : stage === 'detail'
                 ? effort
                 : config.translationReasoningEffort || effort;
+        // 已知这个模型不接受"关"档（之前撞过一次并记下来了）：直接换 low，不再先失败一轮。
+        // 首轮默认就是 off，所以这条对"默认配置 + 不吃 off 的模型"是必经之路。
+        if (requestEffort === 'off' && noOffRoutes.has(routeKey))
+            requestEffort = 'low';
         sse(res, {
             type: 'start',
             provider: route.provider,
@@ -2739,9 +2862,13 @@ export function apply(ctx, rawConfig) {
                 error: '',
             };
             const toolRounds = config.maxToolRounds;
-            // 档位被上游拒绝时（400/401/500）去掉档位重试一次：清单里声明的档位是**建议值**，
+            // 档位被上游拒绝时（400/401/500）重试一次：清单里声明的档位是**建议值**，
             // 实测很多模型并不接受 max（qwen3.7-max 直接 400、minimax-m2.7/gpt-5.6-luna 500）。
-            const canRetryEffort = isChat && bodyEffort.length > 0;
+            //
+            // 以前这里限定了 `isChat && bodyEffort.length > 0` —— 只有追问、且客户端显式传了档位才重试。
+            // 于是**首轮**（档位来自配置、默认 off）撞上不吃 off 的模型时无人兜底，整个划词解读全挂。
+            // 现在按"这一轮实际在发显式档位"判，三种轮次一视同仁。
+            const canRetryEffort = requestEffort.length > 0;
             let effortRetried = false;
             let roundEffort = requestEffort;
             for (let round = 0; round <= toolRounds; round += 1) {
@@ -2867,13 +2994,25 @@ export function apply(ctx, rawConfig) {
                     // （保守：已经吐出正文的失败不重试，避免把半截答案丢掉）
                     if (canRetryEffort && !effortRetried && roundText.length === 0) {
                         effortRetried = true;
-                        roundEffort = '';
+                        const rejected = roundEffort;
+                        if (rejected === 'off') {
+                            // "关"被拒：记下这个 route，改用 low（最接近关的可接受档位），并让重试也用 low。
+                            // 只去掉档位（交给供应商默认）在有些模型上等于开了深度思考 —— 又慢又可能把思考写进正文。
+                            markNoOff(routeKey);
+                            requestEffort = 'low';
+                            roundEffort = 'low';
+                        }
+                        else {
+                            roundEffort = '';
+                        }
                         errored = false;
                         sse(res, {
                             type: 'notice',
                             code: 'effort-rejected',
-                            tier: bodyEffort,
-                            text: `「${bodyEffort}」档位该模型不支持，已按默认档位重试`,
+                            tier: rejected,
+                            text: rejected === 'off'
+                                ? '该模型不支持「关」档，已自动改用「低」档（以后不再尝试关档）'
+                                : `「${rejected}」档位该模型不支持，已按默认档位重试`,
                         });
                         round -= 1;
                         continue;
@@ -3116,6 +3255,7 @@ export function apply(ctx, rawConfig) {
     ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/route`, handler: handleRoute }), `${name}: route route`);
     ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/ping`, handler: handlePing }), `${name}: ping route`);
     ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/history`, handler: handleHistory }), `${name}: history route`);
+    ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/panel`, handler: handlePanelSize }), `${name}: panel box route`);
     ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/pill`, handler: handlePillPos }), `${name}: pill position route`);
     ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/models`, handler: handleModels }), `${name}: models route`);
     ctx.effect(() => ctx.webServer.register({ kind: 'exact', path: `${API_PREFIX}/promote`, handler: handlePromote }), `${name}: promote route`);