dsh-sidecard-ask 2.1.2 → 2.1.4

package/CHANGELOG.md

@@ -1,5 +1,83 @@
 # Changelog
 
+## 2.1.4
+
+**主题：把「技术方案评审团」查出的 11 条缺陷一次修完。四套脚本全绿，新增 21 条回归断言。**
+排查依据：Software Architect / Application Security Engineer / Reality Checker 三方评审 + 源码复核 + 实测复现。
+
+### 修复
+
+- **B1（阻断，静默数据丢失）关闭的卡片在下次答题完成时被抹掉**。`syncPersisted()` 只从
+  「活跃卡片」重建整个持久化集合再整键覆盖，而 `close()` 只把卡片移出活跃区、durable 快照
+  仍留在 `store.state.history` 里，于是关掉的那张被静默删除（`contract-test` 原先把破坏后的
+  结果当成了期望值）。现在写的是并集：活跃卡片 ∪ 尚未关闭的历史条目，按 id 去重（活跃方
+  优先）后按 newest-first 截到 cap。删除路径本来就先改 `store.history` 再写盘，并集不会把
+  它们删掉的条目复活。
+- **B2（高，虚假安全保证）`agentPreset` 在 0.2.1-alpha.2+ 的 activation 面没被转发**。
+  `startSubagent` 只在旧 `start(provider, request)` 面转发 `agentPreset`，新面的 `request`
+  漏了它 → 子代理拿默认全套工具，而 start 帧仍按配置上报 `toolFilter: 'preset'`，卡片于是
+  对用户谎报「工具集由 preset 决定」。现在两个面都转发。
+- **B3（中高，降级链断裂）Rung 1 `sessions.using()` 没有 try/catch**。它一抛（会话归档、
+  形状漂移，或它内部的 `no-session-face`），整条「改发到主对话」就断在第一档，后面
+  `retain` / `inputActions` / `draft` 三档全部不可达。现在与 Rung 2 对称降级，
+  `prompt-rejected` 仍照旧抛给调用方（那是用户可见的拒绝，不是通道缺失）。
+- **B4（中，原生栏串卡）第二张卡开进原生右栏时第一张没有迁回浮层**。它只是被盖住——卡片
+  仍标 `native-rightbar`、store 里被过滤掉，流式输出继续往看不见的卡片里写，且 rail 上那张
+  永远关不掉。现在 `open()` 先把栏里其它卡片迁回 `flow`；`close()` 增加归属校验（栏被另一
+  张卡占用时不替它关）与 `contentId` 行匹配（多行时关「属于这张卡」的那行）；`openTab`
+  抛错时回滚 `cardId`，避免 CardHost 去渲染一张根本没有 tab 的卡。
+- **B5（中低）`/cancel` 把跨会话的全局 run id 列表回给页面**。`runs` 是跨会话的全局表，
+  回 `active` 等于泄露别的会话正在追问的卡片 id（`cancel` 本身也不校验归属），而 Client
+  从不消费它。现在只回 `{ cancelled }`。
+- **B6（中低，迁移被永久挡住）空的 v3 信封会阻断 v1/v2 迁移**。`raw !== null` 就直接
+  return，损坏的 JSON 或旧版本留下的空信封同样挡住。现在写盘时带 `writtenAt` 标记，只有
+  「本版本自己写的空信封」才算权威（用户确实清空了历史，绝不从 v2/v1 复活），没有该标记的
+  空信封与损坏 JSON 继续向下探测。
+- **B7（低，卸载泄漏）`dispose()` 只清了 `streamListeners`，漏了 `chunkListeners`**。第二个
+  流来源的订阅者会留下仍被 `session/event` 桥持有的闭包（它捕获整个 engine 状态）。
+- **B9（低，死重量）持久化写死 `slice(-12)`，而 `followUp` 只发 6 轮**。改成
+  `HISTORY_TURNS`，与上下文预算同一个上限。
+- **B10（低，死代码）`let finished = false` 只赋值不读取**，删除。
+- **B11（低，可诊断性）信任围栏的 403 只说 `forbidden`**。现在说明「Host 不在信任范围 +
+  怎么放行（127.0.0.1 或 `trustedHosts`）」。有意**不**自动信任绑定地址：插件读不到宿主的
+  bind 配置，猜一个就等于自己拆掉 DNS-rebinding 防线。
+- **B8（条件性，平台限制）配置里的 SMTP 密码以明文落在 `~/.dsh/` 下的用户层 JSON**。
+  写盘已带 `mode: 0o600`（POSIX 生效，Windows 忽略），代码注释与 README 均已注明；
+  无进程内可做的进一步缓解，**保留为已文档化的限制**，建议优先用环境变量。
+
+### 验证
+
+`node test/verify.mjs` / `contract-test.mjs` / `float-placement.mjs` / `smoke-test.mjs`：
+**57 / 1446 / 100 / 277 全绿（1880 条，0 失败）**。相对修复前 1859 条新增 21 条回归断言，
+逐条对应上面的缺陷：关卡片后历史仍在（contract）、activation 面转发 preset 且无能力时
+不带该字段（smoke）、`using()` 抛错降级而 `prompt-rejected` 仍抛（contract）、空/损坏 v3
+信封不挡迁移且自有空信封不被复活（contract）、原生栏单地址与关 tab 归属（contract）、
+`/cancel` 不泄露 `active`（smoke）。
+
+## 2.1.3
+
+**主题：折叠态胶囊不再压在聊天输入框上（2026-10-25 实拍报告）。**
+
+### 修复
+
+- **胶囊盖住输入框**。浮层固定在 `bottom:16px`，而输入框就在会话列底部，折叠态胶囊
+  正好落在输入框上。新增纯函数
+  `floatBottom({ frameHeight, composerTop, fallback, limit })`：测量 `[data-composer-card]`
+  的顶边，把浮层抬到输入框上方 8px（CSS 变量 `--dsa-gap-bottom`）。两道保险——输入框
+  顶边落在窗口上半部（空会话的居中输入框）时不抬；结果上限 240px，避免超高输入框把
+  浮层推到会话正文上。
+- **胶囊改为按内容收缩**。浮层本就贴着右边缘（`right:8px`），「再往右」没有余量，所以
+  改为缩窄：内容自适应、上限 240px、容器右对齐，左边缘随之右退。内边距 8/12 → 6/10、
+  行高 18 → 16，问题文本由 `flex:1` 改为 `flex:0 1 auto`（只在真放不下时才截断）。
+  取舍：抬到输入框上方后它会压住最后一行消息，所以必须足够窄小。
+- 新增 `node.dataset.layerBottom`（与 `layerWidth` 并列），用户反馈可以直接报出浮层
+  离底多少。
+
+### 验证
+
+`test/float-placement.mjs` 新增 `floatBottom` 数值用例与源码钩子；四套脚本
+100 / 1427 / 57 / 271 全绿。
+
 ## 2.1.2
 
 **主题：按 DSH 0.2.1-rc.3 的实测契约修复——原生右栏卡片、语言跟随、只读工具收窄、可信主机围栏。

package/README.md

@@ -196,7 +196,7 @@ plugin_manager(action="install_bundle", target="D:\\Users\\34332\\AI\\dsh-sideca
 
 非法值会被拒绝（设置页报错、接口返回 `invalid-config`），并把被忽略的项列在 `/state` 的 `problems` 里——不会静默吞掉。
 
-### 4.1 内置浮层的位置规则（`floatPlacement`）
+### 4.1 内置浮层的位置规则（`floatPlacement` / `floatBottom`）
 
 用户实测报告过一个问题：浮层是 `position:fixed; right:16px; width:min(400px,92vw)` 的实心卡片。
 实测那一次（1400px 宽的窗口）对话区右边界在 x≈971，而浮层左边界在 x≈858，**压住正文约 113px**，
@@ -218,7 +218,23 @@ bleeds = 对话区右边界 - left > 1          // 只有带宽 < 240px 时才
 - 浮层**只使用对话区右侧的预留带**（右栏也在这条带里），窗口越窄它越窄，而不是越靠左。
 - `capped: true` 表示「上限没用满，是被可用带宽压住的」——这是正常的自适应，不是错误。
 - 挂载时、窗口 resize 时、右栏开合时（`ResizeObserver`）都会重算；流式刷新只重渲染，不动几何。
-- 浮层根节点带 `data-layer-width`（实际宽度）与 `data-dsa-float-mode`：报告问题时可直接读这两个值。
+- 浮层根节点带 `data-layer-width`（实际宽度）、`data-layer-bottom`（距窗口底的距离）与
+  `data-dsa-float-mode`：报告问题时可直接读这三个值。
+
+**垂直位置（2.1.3）**：宽度不是唯一的问题——浮层原本固定在 `bottom:16px`，而输入框就在会话列底部，
+折叠态胶囊必然压在输入框上（2026-10-25 实拍报告「挡住聊天框了」）。垂直位置由纯函数 `floatBottom` 决定：
+
+```js
+// floatBottom({ frameHeight, composerTop = null, fallback = 16, limit = 240 })
+if (composerTop 未知 || 帧高为 0) return 16      // 测不到就保持旧锚点
+if (composerTop < 帧高 / 2)      return 16       // 居中输入框（空会话）不是底栏，不抬
+bottom = clamp(帧高 - composerTop + 8, 16, 240)  // 抬到输入框上方 8px，上限 240px
+```
+
+`composerTop` 取自 DSH 的 `[data-composer-card]`（输入框那张卡片的顶边），该节点也进了
+`ResizeObserver`——输入多行时卡片会往上长，浮层跟着重算，不会重新沉回输入框上。
+取舍要讲清楚：抬起来之后它**改压最后一两行消息**，所以胶囊同时改成按内容收缩（≤240px、右对齐），
+尽量把覆盖面积压到最小。
 
 ### 4.2 右侧栏打开时「占满它」（`dockRail`，1.8.3）
 
@@ -782,10 +798,12 @@ node tools/compat-probe.mjs --json tools/.cache/matrix.json
    展开后标题栏右侧有**收起为胶囊（⇥）**与**删除这条追问对话（×）**——× 会把该卡片从浮层与追问历史里
    一并移除，**无法撤销**（有内容时会先弹插件内确认层；点浮层底部的「关闭」则只把它摘离浮层、历史仍保留在
    设置页的历史管理器里）。2.0.0 起不再有「隐藏整个浮层 / 只留一个计数圆点」这套形态。
-   用 F12 选中浮层根节点（`[data-dsa-root]`）读两个值自检：
+   用 F12 选中浮层根节点（`[data-dsa-root]`）读三个值自检：
    - `data-dsa-float-mode` 应为 `capsule` / `full`（铺满右栏时为 `dock`）；
-   - `data-layer-width` 应等于 `min(floatMaxWidth, 对话区右边界到帧右边缘的可用带宽)`。
-   **关键判据：胶囊/卡片的左边缘不得越过对话区（`[data-slot^="conversation"]`）的右边界**。
+   - `data-layer-width` 应等于 `min(floatMaxWidth, 对话区右边界到帧右边缘的可用带宽)`；
+   - `data-layer-bottom` 应等于 `帧高 - 输入框（`[data-composer-card]`）顶边 + 8`（空会话/测不到时为 16）。
+   **关键判据：胶囊/卡片的左边缘不得越过对话区（`[data-slot^="conversation"]`）的右边界，
+   下边缘不得落在输入框上**。
    把窗口从 1920px 拖到 900px、再开关一次右侧栏，浮层应随之变窄而不是往左压住正文；
    只有窗口窄到可用带宽不足 240px 时才允许压入（此时是设计内的降级，不是 bug）。
 9. **占满右侧栏（1.8.3，`dockRail`）**：先把右侧栏打开（任意面板，例如「团队任务板」），再追问一次 →

package/client.js

@@ -117,7 +117,7 @@ window.__ModuleLoader__.load({
      * the Host and the module's `api.version` both read it, so a report can
      * never claim a generation the browser is not actually running.
      */
-    const CLIENT_VERSION = '2.1.2'
+    const CLIENT_VERSION = '2.1.4'
 
     /**
      * Tab kind served by the DSH native right rail (also its implementation id).
@@ -364,6 +364,17 @@ window.__ModuleLoader__.load({
     const FLOAT_GAP_SIDEBAR = 10
     const FLOAT_MIN_WIDTH = 240
     const FLOAT_MAX_WIDTH_LIMIT = 560
+    /**
+     * Vertical clearance (2.1.3). The layer used to be pinned `bottom:16px`,
+     * i.e. straight on top of the composer — which is what the 2026-10-25
+     * report ("挡住聊天框了") caught: the capsule covered the input box. The
+     * layer now measures the composer and sits just above it.
+     */
+    const FLOAT_GAP_BOTTOM = 16
+    const FLOAT_GAP_COMPOSER = 8
+    const FLOAT_BOTTOM_LIMIT = 240
+    /** The capsule is a status pill, not a card: it sizes to its content. */
+    const CAPSULE_MAX_WIDTH = 240
 
     /**
      * The floating layer's width for one frame.
@@ -394,6 +405,40 @@ window.__ModuleLoader__.load({
       return { width, avail, capped: width < cap, bleeds: lane - left > 1 }
     }
 
+    /**
+     * How far above the frame's bottom edge the floating layer sits (2.1.3).
+     *
+     * Pure, like {@link floatPlacement}, and mirrored by the tests.
+     * `composerTop` is the composer card's top edge, in frame coordinates. The
+     * composer is part of the conversation column, so the old fixed
+     * `bottom:16px` parked the layer straight on top of the input box; the
+     * layer is lifted until its own bottom edge clears the composer by
+     * `FLOAT_GAP_COMPOSER`.
+     *
+     * Two guards keep that lift honest: a composer whose top sits in the frame's
+     * upper half is not a bottom bar (the empty-session composer is vertically
+     * centred) and is ignored, and the result is clamped to `limit` so an
+     * unusually tall composer cannot push the layer over the conversation.
+     *
+     * @param {object} input - `frameHeight`, `composerTop`, `fallback`, `limit`.
+     * @returns {number} Bottom offset in px, never below `fallback`.
+     */
+    function floatBottom({
+      frameHeight,
+      composerTop = null,
+      fallback = FLOAT_GAP_BOTTOM,
+      limit = FLOAT_BOTTOM_LIMIT,
+    }) {
+      const base = Number.isFinite(fallback) ? Math.max(0, Math.round(fallback)) : FLOAT_GAP_BOTTOM
+      const frame = Number.isFinite(frameHeight) ? frameHeight : 0
+      if (frame <= 0 || !Number.isFinite(composerTop)) return base
+      // A centred composer is not a bottom bar; leave the layer where it was.
+      if (composerTop < frame / 2) return base
+      const clear = Math.round(frame - composerTop + FLOAT_GAP_COMPOSER)
+      const cap = Number.isFinite(limit) ? Math.max(base, limit) : FLOAT_BOTTOM_LIMIT
+      return Math.max(base, Math.min(clear, cap))
+    }
+
     const DOCK_MIN_WIDTH = 280
     const DOCK_MIN_HEIGHT = 240
 
@@ -2133,16 +2178,26 @@ window.__ModuleLoader__.load({
       }
 
       // Rung 1 — `using()`: the documented helper, present from 0.1.6-alpha.2.
+      // 与 Rung 2 必须对称地包 try/catch：`using()` 本身（或它内部的
+      // `no-session-face` 抛出）一失败就该降级到 retain → inputActions →
+      // draft，而不是让整个"改发到主对话"断在这里 —— 后两档存在的理由
+      // 正是这种情况。`prompt-rejected` 仍然照旧抛给调用方（那是用户可见的
+      // 拒绝，不是通道缺失）。
       if (sessionId !== null && typeof sessions?.using === 'function') {
-        const result = await sessions.using(sessionId, { source: 'gateway' }, async (reference) => {
-          const face = reference?.binding?.session
-          if (face === undefined || typeof face.prompt !== 'function') {
-            throw Object.assign(new Error('session face has no prompt()'), { code: 'no-session-face' })
-          }
-          return face.prompt(parts, 'queue')
-        })
-        accepted(result)
-        return { mode: 'session', via: 'sessions.using' }
+        try {
+          const result = await sessions.using(sessionId, { source: 'gateway' }, async (reference) => {
+            const face = reference?.binding?.session
+            if (face === undefined || typeof face.prompt !== 'function') {
+              throw Object.assign(new Error('session face has no prompt()'), { code: 'no-session-face' })
+            }
+            return face.prompt(parts, 'queue')
+          })
+          accepted(result)
+          return { mode: 'session', via: 'sessions.using' }
+        } catch (error) {
+          if (error?.code === 'prompt-rejected') throw error
+          console.warn(`[${PLUGIN_ID}] sessions.using 提交失败，尝试下一级：`, error)
+        }
       }
 
       // Rung 2 — `retain()` + explicit release: the same operation spelled out,
@@ -2262,8 +2317,22 @@ window.__ModuleLoader__.load({
         cardId: null,
         open(card) {
           if (!this.available() || typeof this.controller.openTab !== 'function') return false
+          // 同一个 kind 在原生栏里只有一个地址（见 cardId 的注释）：先把栏里
+          // 其它卡片迁回浮层，否则它们既不在栏里也不在浮层上，流式输出还会
+          // 继续往一张看不见的卡片里写。
+          for (const other of store.state.cards) {
+            if (other.id !== card.id && other.surface === 'native-rightbar') {
+              patchCard(other.id, { surface: 'flow' })
+            }
+          }
           this.cardId = card.id
-          this.controller.openTab(CARD_KIND, { params: { cardId: card.id }, revealIfOpened: true })
+          try {
+            this.controller.openTab(CARD_KIND, { params: { cardId: card.id }, revealIfOpened: true })
+          } catch (error) {
+            // 开栏失败就把地址回滚，免得 CardHost 去渲染一张根本没有 tab 的卡。
+            this.cardId = null
+            throw error
+          }
           return true
         },
         close(card) {
@@ -2274,6 +2343,10 @@ window.__ModuleLoader__.load({
           // and lets CardHost show its closed-card face.
           const controller = this.controller
           if (controller === null || controller === undefined) return false
+          // 归属校验：栏里那条同 kind 的 tab 若正被另一张卡片占用，就不能替它
+          // 关掉（否则关 A 会把 B 的 tab 一起关掉）。cardId === null 是"清理
+          // 残留 tab"的路径，此时按 kind 关是对的。
+          if (this.cardId !== null && this.cardId !== card.id) return false
           let rows = []
           try {
             rows = typeof controller.openTabs?.getSnapshot === 'function'
@@ -2283,6 +2356,12 @@ window.__ModuleLoader__.load({
           const row = Array.isArray(rows)
             ? rows.find(entry => entry?.kind === CARD_KIND
               && typeof entry?.tabId === 'string' && entry.tabId !== ''
+              // 单地址模型下这里只该有一行；万一宿主保留了多行，必须关"属于这张
+              // 卡片"的那一行（openTab 把 cardId 写进 params → contentId），
+              // 否则会替另一张卡片关掉它的 tab。
+              && (typeof entry?.contentId !== 'string'
+                || entry.contentId === ''
+                || entry.contentId === card.id)
               && (typeof entry?.sessionId !== 'string'
                 || store.state.sessionId === null
                 || entry.sessionId === store.state.sessionId))
@@ -2654,9 +2733,15 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
    \`floatPlacement\` through --dsa-float-w, so it grows left only as far as the
    conversation column allows. pointer-events stays off on the container so the
    empty area around the pill never eats a click meant for the conversation. */
-.dsa-float{pointer-events:none;position:fixed;right:var(--dsa-gap-right, 8px);bottom:16px;
+.dsa-float{pointer-events:none;position:fixed;right:var(--dsa-gap-right, 8px);bottom:var(--dsa-gap-bottom, 16px);
   display:flex;flex-direction:column;gap:8px;width:var(--dsa-float-w, 340px);max-width:92vw}
 .dsa-float > *{pointer-events:auto}
+/* Capsule mode (2.1.3): the layer is a status pill, not a card. It sizes to its
+   own content and stays right-aligned, so shrinking it is what pulls its left
+   edge back over the conversation — the layer is already flush with the frame's
+   right edge, so it has nowhere further right to go. */
+.dsa-float[data-dsa-float-mode="capsule"]{width:auto;align-items:flex-end;
+  max-width:min(var(--dsa-float-w, 340px), var(--dsa-capsule-max, 240px), 92vw)}
 /* Docked presentation (1.8.3): the same container, but pinned to the right
    rail's measured rectangle (inline left/top/width/height) instead of the
    frame's bottom-right corner. Right/bottom must be released, otherwise the
@@ -2671,8 +2756,8 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
   box-shadow:none;background:transparent;padding:10px 12px 8px}
 .dsa-float[data-dsa-float-mode="dock"] .dsa-answer{max-height:none;flex:1 1 auto;min-height:0;overflow:auto}
 .dsa-stack{display:flex;flex-direction:column;gap:8px;max-height:52vh;overflow:auto}
-.dsa-capsule{display:flex;align-items:center;gap:8px;width:100%;box-sizing:border-box;text-align:left;
-  padding:8px 12px;border-radius:999px;cursor:pointer;font:inherit;font-size:12px;line-height:18px;
+.dsa-capsule{display:flex;align-items:center;gap:6px;width:auto;max-width:100%;box-sizing:border-box;text-align:left;
+  padding:6px 10px;border-radius:999px;cursor:pointer;font:inherit;font-size:12px;line-height:16px;
   border:1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.35));
   background:var(--dsw-alias-bg-overlay, #fff);color:var(--dsw-alias-label-primary, #111);
   box-shadow:0 2px 10px rgba(0,0,0,.14)}
@@ -2685,7 +2770,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
 .dsa-capsule-dot[data-status="error"]{background:var(--dsw-alias-state-error-primary, #c0392b)}
 .dsa-capsule-dot[data-status="stopped"]{background:var(--dsw-alias-state-warn-primary, #b8860b)}
 .dsa-capsule-label{font-weight:600;white-space:nowrap}
-.dsa-capsule-q{min-width:0;flex:1;color:var(--dsw-alias-label-secondary, #666);
+.dsa-capsule-q{min-width:0;flex:0 1 auto;color:var(--dsw-alias-label-secondary, #666);
   white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
 .dsa-capsule-chev{flex:none;color:var(--dsw-alias-label-secondary, #888)}
 /* Delete confirmation (2.0.0). Fixed, not inline: a card docked into the right
@@ -4707,7 +4792,10 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
         // Slot subtrees only: `.rightbar` and `[data-dsh-panel-host]` were
         // dropped in 2.1.2 — no supported build renders either marker, so they
         // were two dead branches in a selector that runs on every resize.
-        const selector = '[data-slot^="conversation"], [data-slot^="sidebar.right"]'
+        // 2.1.3: the composer card joins the list so a multi-line draft (which
+        // grows the box upward) re-measures the layer's vertical clearance
+        // instead of letting the pill sink back onto the input.
+        const selector = '[data-slot^="conversation"], [data-slot^="sidebar.right"], [data-composer-card]'
         const observed = new Set()
         const all = () => {
           try {
@@ -4743,11 +4831,25 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           const railBox = rail === null ? null : rail.box
           const laneRight = laneRect === null ? rootWidth : laneRect.right
           const railLeft = railBox === null ? null : railBox.left
+          // 2.1.3: the composer occupies the bottom of the conversation column,
+          // so the layer's old fixed `bottom:16px` landed straight on top of the
+          // input box. Measure the composer card (the box the user types in) and
+          // lift the layer clear of it; `floatBottom` owns the guards.
+          const composerEl = one('[data-slot^="conversation"] [data-composer-card]')
+            ?? one('[data-composer-card]')
+          const composerRect = measure(composerEl)
+          const gapBottom = floatBottom({
+            frameHeight: rootHeight,
+            composerTop: composerRect === null ? null : composerRect.top,
+          })
+          node.style.setProperty('--dsa-gap-bottom', `${gapBottom}px`)
           const placement = floatPlacement({ frameWidth: rootWidth, laneRight, railLeft, maxWidth })
           node.style.setProperty('--dsa-float-w', `${placement.width}px`)
           node.style.setProperty('--dsa-gap-right', `${FLOAT_GAP_RIGHT}px`)
+          node.style.setProperty('--dsa-capsule-max', `${CAPSULE_MAX_WIDTH}px`)
           // Readable placement, so a user report can say WHERE the layer sat.
           node.dataset.layerWidth = String(placement.width)
+          node.dataset.layerBottom = String(gapBottom)
 
           // Docked presentation: the card fills the rail page's body instead of
           // floating over it. Only measured in `full` mode — a capsule/launcher
@@ -5773,13 +5875,32 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           } catch { return [] }
         }
 
+        /** 是否是「本版本自己写下的空信封」（带 writtenAt 标记）。 */
+        function isOwnedEmptyEnvelope(raw) {
+          try {
+            const value = JSON.parse(raw)
+            return value !== null
+              && typeof value === 'object'
+              && value.version === 3
+              && Array.isArray(value.cards)
+              && Number.isFinite(value.writtenAt)
+          } catch {
+            return false
+          }
+        }
+
         function readPersisted() {
           let raw = null
           try {
             raw = window.localStorage?.getItem(PERSIST_KEY)
           } catch { return [] }
           const v3 = parseEnvelope(raw, 3).slice(0, 50)
-          if (v3.length > 0 || (raw !== null && raw !== undefined)) return v3
+          if (v3.length > 0) return v3
+          // 空的 v3 信封只有在「本版本自己写的」时候才算权威：它带 writtenAt，
+          // 说明用户确实把历史清空了，此时绝不能回落到 v2/v1 把旧记录复活。
+          // 而没有 writtenAt 的空信封（旧版本写的 / 迁移中途留下的）或损坏的
+          // JSON 必须继续向下探测 —— 否则 v1、v2 的数据会被永久挡住。
+          if (raw !== null && raw !== undefined && isOwnedEmptyEnvelope(raw)) return v3
           // v2 → v3: v2 entries have no `versions`, so the field is seeded empty.
           let v2raw = null
           try {
@@ -5813,7 +5934,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           let lastError = null
           for (;;) {
             try {
-              window.localStorage?.setItem(PERSIST_KEY, JSON.stringify({ version: 3, cards: remaining }))
+              window.localStorage?.setItem(PERSIST_KEY, JSON.stringify({ version: 3, cards: remaining, writtenAt: Date.now() }))
               return remaining
             } catch (error) {
               lastError = error
@@ -5839,7 +5960,6 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             .filter(card => card.carrier === 'side'
               && (card.status === 'done' || card.status === 'stopped')
               && card.text !== '')
-            .slice(0, cap)
             .map(card => ({
               id: card.id,
               question: card.question,
@@ -5855,7 +5975,10 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               createdAt: Number.isFinite(card.createdAt) ? card.createdAt : Date.now(),
               provider: typeof card.provider === 'string' ? card.provider : '',
               elapsedMs: Number.isFinite(card.elapsedMs) ? card.elapsedMs : null,
-              history: Array.isArray(card.history) ? card.history.slice(-12) : [],
+              // 持久化的历史轮次与上下文预算同一个上限（HISTORY_TURNS）：
+              // 这里曾经写死 `slice(-12)`，而 followUp 只发 6 轮，多出来的
+              // 6 轮永远不会被读，是纯死重量。
+              history: Array.isArray(card.history) ? card.history.slice(-HISTORY_TURNS) : [],
               // P2-2: kept so a replayed rewrite card still offers "insert".
               actionId: typeof card.actionId === 'string' ? card.actionId.slice(0, 60) : null,
               // P2-5b: bounded, text-capped older answers. `question` is short
@@ -5879,7 +6002,24 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             store.set({ history: [] })
             return
           }
-          const persisted = writePersisted(finished)
+          // #6（2026-10-26 修复）：关闭一张卡片只把它从「活跃区」移除，
+          // durable 快照仍然留在 store.history 里。这里过去只从活跃卡片
+          // 重建整个集合再整键覆盖，于是「关掉的那张」会在下一次答题完成
+          // 时被静默抹掉（contract-test 把破坏后的结果当成了期望）。
+          // 现在写的是并集：活跃卡片 ∪ 尚未关闭的历史条目（按 id 去重，
+          // 活跃方优先），再按 newest-first 截到 cap。
+          // 删除路径（deleteCard / deleteHistoryCard / 改投主对话 /
+          // clearHistory）都是先改 store.history 再写盘，所以并集不会把它们
+          // 删掉的条目复活。
+          const liveIds = new Set(finished.map(entry => entry.id))
+          const kept = store.state.history.filter(entry => entry !== null
+            && typeof entry === 'object'
+            && typeof entry.id === 'string'
+            && !liveIds.has(entry.id))
+          const merged = [...finished, ...kept]
+            .sort((left, right) => (Number(right.createdAt) || 0) - (Number(left.createdAt) || 0))
+            .slice(0, cap)
+          const persisted = writePersisted(merged)
           store.set({ history: persisted })
         }
 
@@ -7429,6 +7569,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           renderRichText,
           pickSurface,
           floatPlacement,
+          floatBottom,
           railDock,
           compareVersions,
           electFamilyLeader,

package/index.js

@@ -45,7 +45,7 @@ export const name = 'dsh-sidecard-ask'
 export const inject = ['webServer']
 
 /** Version of this plugin (kept in step with package.json by test/verify.mjs). */
-export const PLUGIN_VERSION = '2.1.2'
+export const PLUGIN_VERSION = '2.1.4'
 
 /** Route prefix of the plugin's own API. */
 export const ROUTE_PREFIX = '/sidecard-ask/api'
@@ -1541,7 +1541,7 @@ function openSse(res) {
  * Build the engine that owns every side-card run.
  * @param {import('@deepseek-ai/cordis').Context} ctx - host plugin context.
  * @param {() => Record<string, unknown>} configOf - live config reader.
- * @returns {{ask: Function, cancel: Function, activeIds: Function, dispose: Function, capabilities: Function}}
+ * @returns {{ask: Function, cancel: Function, dispose: Function, capabilities: Function}}
  */
 function createSideEngine(ctx, configOf) {
   /** id → run record. */
@@ -1630,6 +1630,11 @@ function createSideEngine(ctx, configOf) {
         parent: fields.parent,
         ...(fields.persona === undefined ? {} : { persona: fields.persona }),
         ...(fields.toolFilter === undefined ? {} : { toolFilter: fields.toolFilter }),
+        // 0.2.1-alpha.2+ 的 `request` 与旧 `start(provider, request)` 是同一个
+        // SubagentStartRequest 形状，`agentPreset` 必须一起转发。漏掉这一项
+        // 会让子代理拿到默认全套工具，而 start 帧仍按配置上报
+        // `toolFilter: 'preset'`，卡片于是对用户谎报"工具集由 preset 决定"。
+        ...(fields.agentPreset === undefined ? {} : { agentPreset: fields.agentPreset }),
       },
     })
     return {
@@ -1893,7 +1898,6 @@ function createSideEngine(ctx, configOf) {
     /** Which source produced deltas: process-local frames or durable chunks. */
     let framesSeen = false
     let chunksSeen = false
-    let finished = false
 
     /** Detach this run's stream listener (frames are per attempt). */
     let detach = () => {}
@@ -2078,7 +2082,6 @@ function createSideEngine(ctx, configOf) {
         })
         return
       }
-      finished = true
       sink.send('done', {
         id,
         text,
@@ -2140,9 +2143,12 @@ function createSideEngine(ctx, configOf) {
     }
     runs.clear()
     streamListeners.clear()
+    // 第二个流来源的订阅者也要清：只清 streamListeners 会在插件卸载后
+    // 留下仍被 `session/event` 桥持有的闭包（它捕获了整个 engine 状态）。
+    chunkListeners.clear()
   }
 
-  return { ask, cancel, dispose, capabilities, activeIds: () => [...runs.keys()] }
+  return { ask, cancel, dispose, capabilities }
 }
 
 // ────────────────────────────────────────────────────────────────────────────
@@ -2594,7 +2600,10 @@ export function apply(ctx, patchConfig) {
       writeError(res, 400, 'bad-request', '缺少 id')
       return
     }
-    writeOk(res, { cancelled: engine.cancel(id), active: engine.activeIds() })
+    // 只回本次取消的结果：`runs` 是跨会话的全局表，把它的 id 列表回给
+    // 任意可信页面等于泄露别的会话正在追问的卡片 id（而 cancel 本身也不
+    // 校验归属），Client 侧也没有任何地方消费这个字段。
+    writeOk(res, { cancelled: engine.cancel(id) })
   }
 
   /** `/config` — merge a partial config into the user layer and persist it. */
@@ -2707,7 +2716,16 @@ export function apply(ctx, patchConfig) {
   /** One request → one response; the dispatcher owns path parsing and the fence. */
   const routeHandler = async (req, res) => {
     if (!isTrustedRequest(req, trustedHostsOf())) {
-      writeError(res, 403, 'forbidden', 'forbidden')
+      // 说明"为什么被拒 + 怎么放行"：这条 403 只会出现在 DSH 被绑到非回环
+      // 地址、或经反向代理访问时（Host 既不是 loopback，也不在 trustedHosts
+      // 里）。有意不自动信任绑定地址：插件读不到宿主的 bind 配置，猜一个就等于
+      // 自己把 DNS-rebinding 防线拆掉。
+      writeError(
+        res,
+        403,
+        'forbidden',
+        'Host 不在信任范围：请用 http://127.0.0.1:<端口> 访问，或把该地址写进 trustedHosts 配置',
+      )
       return
     }
     // Path parsing runs BEFORE the session gate now, because `ping` must be

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-sidecard-ask",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "DSH 划词追问（侧边卡片作答）：在聊天区与任务区选中文本就地追问，答案由独立子代理在侧边卡片里流式呈现，也可选择落回主对话。",
   "type": "module",
   "main": "index.js",