@yfwu2020/dsh-selection-explain 0.8.3 → 0.9.0

package/src/client/index.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/src/index.ts

@@ -1321,6 +1321,14 @@ export function apply(ctx: Context, rawConfig: Config): void {
   let modelCache: { at: number; items: ModelChoice[] } = { at: 0, items: [] }
   /** 哪些 provider/model 在 "关" 档会把思考写进正文（实测过一次就记住，之后自动改用「低」）。 */
   const leakyOnOff = new Set<string>()
+  /**
+   * 哪些 provider/model **根本不接受 "关" 档**（上游直接 400 invalid_request_error）。
+   *
+   * 和 leakyOnOff 分开记：那个是"能发但会泄漏"，这个是"发了就报错"。
+   * 记下来之后不再发 off，直接改用 low —— 这是"最接近关"的可接受档位。
+   * 不记的话每次划词都要先失败一轮再重试：用户看到一次报错闪动 + 多一个来回的时延。
+   */
+  const noOffRoutes = new Set<string>()
   const leakyFile = (): string => join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'leaky-off.json')
   let leakyLoaded = false
 
@@ -1330,17 +1338,20 @@ export function apply(ctx: Context, rawConfig: Config): void {
     leakyLoaded = true
     try {
       const raw = await readFile(leakyFile(), 'utf8')
-      const parsed = JSON.parse(raw) as { routes?: unknown }
+      const parsed = JSON.parse(raw) as { routes?: unknown; noOff?: unknown }
       if (Array.isArray(parsed?.routes)) {
         for (const item of parsed.routes) 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(): void {
-    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: unknown) => {
       ctx.logger?.warn?.(`[${name}] 泄漏清单写盘失败：${String((error as Error)?.message ?? error)}`)
     })
@@ -1352,6 +1363,13 @@ export function apply(ctx: Context, rawConfig: Config): void {
     leakyOnOff.add(route)
     if (leakyLoaded) saveLeaky()
   }
+
+  /** 记住一个"不接受关档"的模型（内存 + 落盘）：下次直接改用 low，不再先撞一次。 */
+  function markNoOff(route: string): void {
+    if (noOffRoutes.has(route)) return
+    noOffRoutes.add(route)
+    if (leakyLoaded) saveLeaky()
+  }
   const MODEL_CACHE_MS = 60_000
 
   async function listModelChoices(force = false): Promise<ModelChoice[]> {
@@ -1724,6 +1742,105 @@ export function apply(ctx: Context, rawConfig: Config): void {
     pillPosTimer.unref?.()
   }
 
+  /**
+   * 小窗的**尺寸**（拖角改过大小之后记下来）。
+   *
+   * 只记尺寸，**不记位置**：小窗每次开窗都由 client 按选区重新锚定
+   * （落在选区下方，放不下就翻到上方，再夹进视口）—— 那套锚定逻辑是既有的设计，
+   * 位置一旦被"记住"就等于架空了它，开窗不再跟着划词的地方走。
+   * 尺寸则是用户明确调过的东西，值得跨开窗保留。
+   */
+  const panelSizeFile = (): string =>
+    join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'selection-explain', 'panel.json')
+
+  let panelSize: { w: number; h: number } | null = null
+  let panelSizeLoaded = false
+  let panelSizeTimer: ReturnType<typeof setTimeout> | null = null
+
+  /**
+   * 尺寸校验：两个数都得是有限值，并夹到一个合理的区间。
+   *
+   * client 那边已经有 min/max 了，但文件是手工可编辑的（也可能被旧版本写坏），
+   * 不能让一个 5px 宽的小窗把界面弄成没法用。
+   */
+  function normalizePanelSize(input: unknown): { w: number; h: number } | null {
+    const value = input as { w?: unknown; h?: unknown } | null | undefined
+    const num = (v: unknown): number => (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: number, lo: number, hi: number): number => Math.round(Math.min(hi, Math.max(lo, n)))
+    return { w: clamp(w, 280, 4000), h: clamp(h, 200, 4000) }
+  }
+
+  async function loadPanelSize(): Promise<void> {
+    if (panelSizeLoaded) return
+    panelSizeLoaded = true
+    try {
+      const parsed = JSON.parse(await readFile(panelSizeFile(), 'utf8')) as { size?: unknown }
+      panelSize = normalizePanelSize(parsed?.size)
+    } catch {
+      panelSize = null // 没存过 / 坏了都当作"没调过"
+    }
+  }
+
+  function schedulePanelSizeWrite(): void {
+    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 as Error)?.message ?? error)}`)
+        }
+      })()
+    }, 300)
+    panelSizeTimer.unref?.()
+  }
+
+  /**
+   * 小窗尺寸：GET 读回来（挂载时恢复）、POST 存（{w,h}）或清（{clear:true}，回到默认尺寸）。
+   */
+  const handlePanelSize = (req: IncomingMessage, res: ServerResponse): void => {
+    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: { size?: unknown; clear?: unknown } = {}
+      try {
+        body = raw ? (JSON.parse(raw) as { size?: unknown; clear?: unknown }) : {}
+      } 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: unknown) => {
+      sendJson(res, 500, { ok: false, error: String((error as Error)?.message ?? error) })
+    })
+  }
+
   /**
    * 胶囊位置：GET 读回来（挂载时恢复）、POST 存（{right,y}）或清（{clear:true}，吸附回右下角时调）。
    */
@@ -3039,11 +3156,14 @@ export function apply(ctx: Context, rawConfig: Config): void {
         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',
@@ -3113,9 +3233,13 @@ export function apply(ctx: Context, rawConfig: Config): void {
         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) {
@@ -3240,13 +3364,24 @@ export function apply(ctx: Context, rawConfig: Config): void {
           // （保守：已经吐出正文的失败不重试，避免把半截答案丢掉）
           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
@@ -3495,6 +3630,10 @@ export function apply(ctx: Context, rawConfig: Config): void {
     () => 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`,