dsh-sidecard-ask 2.1.3 → 2.1.5

package/CHANGELOG.md

@@ -1,5 +1,96 @@
 # Changelog
 
+## 2.1.5
+
+**主题：修完「技术方案评审团」在 0.2.1-rc.3（桌面 Electron 44.7.0 / 网页端同源）上复核出的 8 条缺陷。**
+四套脚本全绿（57 / 1454 / 100 / 279 = 1890），新增 10 条回归断言。
+
+### 修复
+
+- **R1（中）原生栏把卡迁回浮层时没展开，卡在两端同时不可见**。`surfaces.native.open()` 只把
+  被挤出的卡 `surface` 改回 `'flow'`，但浮层只挂载 `surface === 'flow' && open` 的卡
+  （`FloatingLayer`），于是那张卡既不在栏里、也不在屏幕上，流式输出还继续往它里面写。
+  现在迁移时一并置 `open: true`。
+- **R2（中）关 A 卡片会关掉 B 的 tab**。`close()` 认领 tab 的判据是"`contentId` 为空就算我的"，
+  而单地址模型下栏里那条 tab 可能正显示另一张卡；`this.cardId` 已被清空时（页面重载后）
+  就会误关别人的 tab，连带把别人的正文一起关掉。现在要求 `contentId === 本卡 id`，或
+  宿主没报 `contentId` 且适配器仍持有本卡地址。
+- **R3（中）删历史 / 删卡片不释放原生栏的 tab**。tab 是宿主自己的状态，不随 `store.cards`
+  变化；删掉卡片后页面里留着一张渲染"已不存在卡片"的空壳，直到用户手动关。新增
+  `releaseNativeTab(id)`，`deleteHistoryCard` / `deleteCard` / `clearHistory`（仅历史态卡）都会调用。
+- **R4（中）设置页把只读开关标成"只读（推荐）"，而 0.2.1-rc.3 上它根本不生效**。
+  宿主的 `SubagentCapabilities` 没有 `toolFilter`，`readOnlyToolFilter()` 返回的白名单会被丢弃，
+  侧边作答实际继承会话全部工具——卡片上的 `toolFilter: 'unsupported'` 是对的，但设置页的
+  "推荐"是假的。标签改为「只读（需宿主支持，0.2.1 无效）」。
+- **R5（低）`setSideToolsHint` 谎称"只读靠探针自动拒写"**。代码里没有任何"拒写探针"，
+  真实机制是 `toolFilter`（宿主不支持即失效）或 `agentPreset`（0.2.1-rc.3 支持）。文案改为
+  指向 preset，并写明版本前提。
+- **R6（中）`/cancel` 不校验归属**。`runs` 是进程级全局表，任何已认证页面拿到（或猜到）一个
+  run id 就能打断别的会话的追问。run 记录现在带 `sessionId`，`cancel(id, sessionId)` 在双方
+  都已知且不一致时按"没找到"处理；不带 `sessionId` 的老客户端保持可用。
+- **R8（低）写盘失败的报错只有 errno 原文**。`toWireError()` 现按 `EACCES` / `EPERM` / `EROFS` /
+  `ENOSPC` / `EBUSY` / `ENOENT` 追加中文处置提示，`error.code` 不变（程序分支仍按码判断）。
+
+### 评估后不改
+
+- **R7 `/state` 回配置文件的绝对路径**：该接口要求宿主登录（页面外是 `401 unauthorized`），
+  且这个字段是设置页"到底读的哪个文件"的唯一依据。已写进 README §隐私与安全第 16 条，
+  说明暴露面边界与转发时的处置办法。
+
+## 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 实拍报告）。**

package/README.md

@@ -1088,4 +1088,12 @@ npm deprecate "<旧包名>@*" "Renamed to <新包名> - <原因>"       # 旧名
 15. **部署前缀不带尾斜杠时（2.1.0）**：`API` 基址会先按 `document.baseURI` 猜一次，若得到 404
     则回退到根绝对路径重试一次。这是唯一安全的判别方式（401/403 都不能用来改基址），
     代价是每次页面加载最多多一次 404 往返——正常部署下不会触发。
+16. **`/state` 会回配置文件的绝对路径（`provenance.persistedPath`，2.1.5 复核后保留）**：这是设置页
+    用来说明"到底读的是哪个文件"的诊断字段，且该接口要求宿主登录（页面外拿到的是
+    `401 unauthorized`）。它**不是**无鉴权暴露面；如果你把 `/state` 的响应转发到别处，请自行删掉
+    这个字段。同一响应里的 `persistedError` 会带上 errno 的中文提示（`EACCES` / `EPERM` /
+    `ENOSPC` / `EBUSY` 等），原始错误码仍保留在 `error.code` 上供程序分支。
+17. **`/cancel` 校验归属（2.1.5）**：请求体带 `sessionId` 且与 run 的发起会话不一致时，按"没找到"
+    返回 `cancelled: false`（不回 403，避免把别的会话的 run id 是否存在当成探测面）。不带
+    `sessionId` 的老客户端仍然可以取消——向后兼容优先于收紧。
 

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.3'
+    const CLIENT_VERSION = '2.1.5'
 
     /**
      * Tab kind served by the DSH native right rail (also its implementation id).
@@ -707,9 +707,9 @@ window.__ModuleLoader__.load({
         setMinChars: '最小触发字符数',
         setConcurrency: '并发作答上限',
         setSideTools: '侧边作答工具权限',
-        setSideToolsReadonly: '只读（推荐）',
+        setSideToolsReadonly: '只读（需宿主支持，0.2.1 无效）',
         setSideToolsInherit: '继承当前会话',
-        setSideToolsHint: '在 0.2.1 上，只读靠探针自动拒写，不依赖此开关；要彻底收窄工具，请填写下面的 preset',
+        setSideToolsHint: '这个开关只在宿主支持工具白名单时才生效；0.2.1-rc.3 不支持，侧边作答会继承当前会话的全部工具。要真正收窄，请填写下面的 preset（0.2.1-rc.3 已支持）。',
         setSideAgentPreset: '只读 preset（可选）',
         setSideAgentPresetPlaceholder: '留空则不启用',
         setSideAgentPresetHint: '子代理以该 agent preset 启动，工具集由 preset 决定（0.2.1 唯一可靠的收窄通道）；留空时退回探针拒写',
@@ -982,9 +982,9 @@ window.__ModuleLoader__.load({
         setMinChars: 'Minimum selection length',
         setConcurrency: 'Max concurrent answers',
         setSideTools: 'Side answerer tool access',
-        setSideToolsReadonly: 'Read-only (recommended)',
+        setSideToolsReadonly: 'Read-only (needs host support; no-op on 0.2.1)',
         setSideToolsInherit: 'Inherit from the session',
-        setSideToolsHint: 'On 0.2.1 read-only is enforced by the write-refusing probe, not by this switch; set a preset below to narrow the tool set itself',
+        setSideToolsHint: 'This switch only works when the host supports a tool allow-list; 0.2.1-rc.3 does not, so the side answerer inherits every tool of the session. To really narrow it, set the preset below (supported on 0.2.1-rc.3).',
         setSideAgentPreset: 'Read-only preset (optional)',
         setSideAgentPresetPlaceholder: 'Leave empty to disable',
         setSideAgentPresetHint: 'Starts the subagent with this agent preset, so the preset decides the tool set — the only reliable narrowing channel on 0.2.1; when empty the write-refusing probe is the fallback',
@@ -2178,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,
@@ -2307,8 +2317,26 @@ 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') {
+              // `open: true` is load-bearing: the floating layer only mounts a
+              // card whose `surface === 'flow'` AND `open` is true, so migrating
+              // a card back to the flow while leaving it folded hid it on BOTH
+              // surfaces — not in the rail, not on screen, still streaming.
+              patchCard(other.id, { surface: 'flow', open: true })
+            }
+          }
           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) {
@@ -2319,6 +2347,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'
@@ -2328,6 +2360,15 @@ window.__ModuleLoader__.load({
           const row = Array.isArray(rows)
             ? rows.find(entry => entry?.kind === CARD_KIND
               && typeof entry?.tabId === 'string' && entry.tabId !== ''
+              // Ownership, not just kind. The tab belongs to this card when the
+              // host echoes the id it was opened with (`openTab` carries it in
+              // `params.cardId`, which the rail publishes as `contentId`), or
+              // when the host reported no id at all AND this adapter still holds
+              // that card's address. Claiming a tab merely because `contentId`
+              // was empty made "close A" close B's tab — and with it B's body.
+              && (entry.contentId === card.id
+                || ((entry.contentId === undefined || entry.contentId === null || entry.contentId === '')
+                  && this.cardId === card.id))
               && (typeof entry?.sessionId !== 'string'
                 || store.state.sessionId === null
                 || entry.sessionId === store.state.sessionId))
@@ -5841,13 +5882,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 {
@@ -5881,7 +5941,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
@@ -5907,7 +5967,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,
@@ -5923,7 +5982,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
@@ -5947,7 +6009,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 })
         }
 
@@ -6057,6 +6136,26 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             : [],
         })
 
+        /**
+         * Close the right-rail tab when it is showing this card.
+         *
+         * The rail's tab is not derived from `store.cards`: deleting a card (or
+         * a history entry) only removed it from the stores, so a card that lived
+         * in the native rail left its tab behind — a body rendering an id that
+         * no longer exists, until the user closed it by hand. Only the tab this
+         * adapter actually opened is touched; `close` re-checks ownership.
+         * @param {string} id - the card id that is going away.
+         */
+        function releaseNativeTab(id) {
+          const native = surfaces.native
+          if (native === null || native === undefined) return
+          if (native.controller === null || native.controller === undefined) return
+          if (native.cardId !== id) return
+          try {
+            native.close({ id })
+          } catch { /* the rail owns its tab's lifetime */ }
+        }
+
         const actions = {
           openPopover(candidate) {
             // P2-2: the composer must be remembered BEFORE the popover's
@@ -6095,6 +6194,9 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             const next = store.state.history
               .filter(item => item.id !== id)
               .slice(0, historyCap())
+            // A deleted entry must not keep a right-rail tab alive: the tab is
+            // not part of the store, so nothing else would ever close it.
+            releaseNativeTab(id)
             writePersisted(next)
             store.set({
               history: next,
@@ -6122,7 +6224,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             const controller = controllers.get(id)
             if (controller !== undefined) {
               controller.abort()
-              void postJson('cancel', { id }).catch(() => {})
+              void postJson('cancel', { id, sessionId: store.state.sessionId }).catch(() => {})
             }
             controllers.delete(id)
             pendingDeltas.delete(id)
@@ -6139,6 +6241,10 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
                 surfaces.native.close(card)
               } catch { /* the right rail owns its lifecycle */ }
             }
+            // A card restored from durable history has no live `surface`, so the
+            // branch above cannot see its tab; this checks the adapter's own
+            // address instead and is a no-op when nothing is on the rail.
+            releaseNativeTab(id)
             const next = store.state.history
               .filter(item => item.id !== id)
               .slice(0, historyCap())
@@ -6165,6 +6271,15 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
            * by definition: it is the one action allowed to drop the old keys.
            */
           clearHistory() {
+            // A history-only card that happens to sit on the rail loses its
+            // durable entry here; leaving the tab up would show a body for an
+            // entry the manager no longer has. A card that is still live keeps
+            // its tab — this action does not touch running cards.
+            const railCard = surfaces.native?.cardId
+            if (typeof railCard === 'string' && railCard !== ''
+              && !store.state.cards.some(card => card.id === railCard)) {
+              releaseNativeTab(railCard)
+            }
             try {
               for (const key of [PERSIST_KEY, PERSIST_V2_KEY, PERSIST_LEGACY_KEY]) {
                 window.localStorage?.removeItem(key)
@@ -6470,7 +6585,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               // so POST /cancel too. Fire-and-forget on purpose — the card is
               // already stopped locally, and a dead host must not turn the
               // Stop button into a failure.
-              void postJson('cancel', { id: card.id }).catch(() => {})
+              void postJson('cancel', { id: card.id, sessionId: store.state.sessionId }).catch(() => {})
             }
             patchCard(card.id, { status: 'stopped' })
           },
@@ -6519,7 +6634,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               controller.abort()
               // Same host-side release as the Stop button: closing a card
               // mid-stream must not leave the child running server-side.
-              void postJson('cancel', { id: card.id }).catch(() => {})
+              void postJson('cancel', { id: card.id, sessionId: store.state.sessionId }).catch(() => {})
             }
             controllers.delete(card.id)
             // A closed card's buffered-but-unflushed deltas belong to nobody:

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.3'
+export const PLUGIN_VERSION = '2.1.5'
 
 /** Route prefix of the plugin's own API. */
 export const ROUTE_PREFIX = '/sidecard-ask/api'
@@ -1248,6 +1248,21 @@ export async function sendSmtpMessage(endpoint, mail, { timeoutMs = 20_000, now
   }
 }
 
+/**
+ * Plain-language hints for the filesystem errnos that actually reach a save on
+ * Windows/macOS/Linux. The raw `EACCES: permission denied, open '…'` line is
+ * accurate but tells a user nothing about what to do; the code stays on the
+ * wire (clients branch on it) and the hint is appended to the message.
+ */
+const ERRNO_HINTS = {
+  EACCES: '（没有写权限：检查文件是否被其它程序占用，或改用可写目录）',
+  EPERM: '（系统拒绝写入：文件可能被占用或只读）',
+  EROFS: '（所在磁盘是只读的）',
+  ENOSPC: '（磁盘空间不足，设置未保存）',
+  EBUSY: '（文件正被其它进程占用，请稍后重试）',
+  ENOENT: '（目标目录不存在）',
+}
+
 /**
  * Reduce any thrown value to a wire error the Client can present.
  * @param {unknown} error - the thrown value.
@@ -1258,7 +1273,15 @@ export function toWireError(error, fallbackCode = 'internal') {
   if (error !== null && typeof error === 'object') {
     const code = typeof error.code === 'string' && error.code !== '' ? error.code : undefined
     const message = typeof error.message === 'string' && error.message !== '' ? error.message : undefined
-    if (message !== undefined) return { code: code ?? fallbackCode, message }
+    if (message !== undefined) {
+      const hint = code !== undefined && Object.prototype.hasOwnProperty.call(ERRNO_HINTS, code)
+        ? ERRNO_HINTS[code]
+        : undefined
+      return {
+        code: code ?? fallbackCode,
+        message: hint === undefined || message.includes(hint) ? message : `${message}${hint}`,
+      }
+    }
   }
   return { code: fallbackCode, message: String(error) }
 }
@@ -1541,7 +1564,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 +1653,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,11 +1921,19 @@ 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 = () => {}
-    const runRecord = { abort: () => controller.abort(), dispose: undefined }
+    const runRecord = {
+      abort: () => controller.abort(),
+      dispose: undefined,
+      // Which session asked. `runs` is process-global, so `/cancel` needs an
+      // owner to check against: without it any trusted page could abort any
+      // other session's run by guessing (or sniffing) a run id.
+      sessionId: typeof request.sessionId === 'string' && request.sessionId !== ''
+        ? request.sessionId
+        : null,
+    }
     runs.set(id, runRecord)
 
     try {
@@ -2078,7 +2114,6 @@ function createSideEngine(ctx, configOf) {
         })
         return
       }
-      finished = true
       sink.send('done', {
         id,
         text,
@@ -2120,10 +2155,28 @@ function createSideEngine(ctx, configOf) {
     }
   }
 
-  /** Abort one in-flight run. */
-  function cancel(id) {
+  /**
+   * Abort one in-flight run.
+   *
+   * `runs` is process-global: every session shares it. When both sides know the
+   * owning session and they differ, this is a cross-session cancel and is
+   * refused (it reports `false`, exactly like an unknown id, so it does not
+   * confirm that the id exists elsewhere). A request that cannot name its
+   * session is still honoured — older clients and scripted calls must keep
+   * working.
+   * @param {string} id - the run id.
+   * @param {string|null} [sessionId] - the session asking for the cancel.
+   * @returns {boolean} whether a run was aborted.
+   */
+  function cancel(id, sessionId = null) {
     const record = runs.get(id)
     if (record === undefined) return false
+    const owner = record.sessionId
+    if (typeof owner === 'string' && owner !== ''
+      && typeof sessionId === 'string' && sessionId !== ''
+      && owner !== sessionId) {
+      return false
+    }
     record.abort()
     return true
   }
@@ -2140,9 +2193,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 +2650,15 @@ 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 侧也没有任何地方消费这个字段。
+    // 归属校验：请求方必须带上自己的 sessionId，与 run 记录不一致时按"没
+    // 找到"处理（不回 403，避免把别的会话的 id 是否存在当成探测面）。
+    const sessionId = typeof body?.sessionId === 'string' && body.sessionId !== ''
+      ? body.sessionId
+      : null
+    writeOk(res, { cancelled: engine.cancel(id, sessionId) })
   }
 
   /** `/config` — merge a partial config into the user layer and persist it. */
@@ -2707,7 +2771,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.3",
+  "version": "2.1.5",
   "description": "DSH 划词追问（侧边卡片作答）：在聊天区与任务区选中文本就地追问，答案由独立子代理在侧边卡片里流式呈现，也可选择落回主对话。",
   "type": "module",
   "main": "index.js",