dsh-sidecard-ask 2.1.4 → 2.1.6

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # Changelog
 
+## 2.1.6
+
+**主题：修复桌面端 0.2.1-rc.3 / 网页端 0.2.1-rc.4 与 0.2.2-alpha.2 上的 4 个承载面与会话归属缺陷。**
+
+### 修复
+
+- **S1（高）默认 better 承载面开第二张卡时第一张消失**。better-sidebar 0.28.2 把每个
+  描述符镜像到 DSH 原生右栏，而该 tab 类型没有 `multiple`：同一 kind、同一会话只有
+  一个 page 地址，第二次 `openTab` 会把这个地址导航到新卡。插件过去只在 native
+  适配器做「迁回浮层」，better 适配器没有，于是第一张卡既不在栏里也不在浮层上，
+  流式输出继续写进看不见的卡片。现在 `surfaces.better.open()` 与 native 一样，先把
+  同会话其它 better 卡片迁回浮层并置 `open:true`。覆盖原生右栏为唯一地址的 0.28.x。
+- **S2（高）关闭/删除卡片不会关闭 better 承载面的 tab**。0.28.x 的原生 tab id 由宿主
+  mint（`tab1`…），插件传入的 seed id 被忽略，`closeTab(seed.id)` 是严格 no-op。
+  `CardHost` 现在从宿主传入的 `props.tab.id` 记录真实 tab id，关闭/删除用它；未挂载
+  过的卡片（刷新后恢复的栏 tab）按 kind + 会话在 `sidebarRight.openTabs` 清单里定位。
+  `deleteHistoryCard` / `clearHistory` 也会释放没有活跃卡片的 better tab。
+- **S3（中）显式 `native-rightbar` 下关闭/删除失效（2.1.5 R2 回归）**。宿主的 page tab
+  把 `contentId` 固定写成 `sidebar://<kind>`，不是卡片 id；R2 用
+  `entry.contentId === card.id` 判归属，匹配恒失败，关闭流程永远返回 false。现在
+  归属只看适配器持有的 `surfaces.native.cardId`，定位按 kind + 会话；`releaseNativeTab`
+  与删除路径随之恢复生效。测试替身也改为真实 `contentId` 语义。
+- **S4（中）切会话后停止/改投用错会话**。卡片过去不记录发起会话；用户在会话 A 追问、
+  切到 B 后点停止，`/cancel` 带的是 B，宿主 R6 归属校验按「没找到」处理，子代理继续
+  跑到超时；「改到主对话」也会投进 B。卡片现在在创建时记录 `sessionId`，停止、关闭、
+  删除、追问、重试、改投全部使用卡片自己的会话，并随 v3 历史持久化（旧条目无该字段
+  时回退当前会话）。
+
+### 验证
+
+`verify 57 / contract 1475 / float-placement 100 / smoke 279 = 1911 全绿`。净增 21 条
+回归断言：better 第二张卡迁移、真实宿主 tab id 关闭、非所有者不得替他人关 tab、
+未挂载 tab 的删除释放、原生 `contentId=sidebar://kind` 下的关闭与删除、切会话后
+`/cancel` 仍带原会话、v3 条目持久化与重放 `sessionId`。
+
+## 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 条回归断言。**

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.4'
+    const CLIENT_VERSION = '2.1.6'
 
     /**
      * 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',
@@ -2264,6 +2264,23 @@ window.__ModuleLoader__.load({
       throw Object.assign(new Error(t('noMainCarrier')), { code: 'no-main-carrier' })
     }
 
+    /**
+     * The session a card belongs to, falling back to the active one.
+     *
+     * Cards outlive session switches (the overlay is root-scoped), so every
+     * follow-up transport must name the card's own session: the Host's `/cancel`
+     * treats a known-but-different session as "not found", and a prompt sent to
+     * the wrong session quotes the wrong conversation.
+     * @param {object|undefined} card - the card being acted on.
+     * @param {object} ctx - the client context (for the active-session fallback).
+     * @returns {string|null} the owning session, or the active one.
+     */
+    function cardSessionId(card, ctx) {
+      const own = card?.sessionId
+      if (typeof own === 'string' && own !== '') return own
+      return currentSessionId(ctx)
+    }
+
     /** Best-effort active session id from every sanctioned source. */
     function currentSessionId(ctx) {
       const captured = store.state.sessionId
@@ -2322,7 +2339,11 @@ window.__ModuleLoader__.load({
           // 继续往一张看不见的卡片里写。
           for (const other of store.state.cards) {
             if (other.id !== card.id && other.surface === 'native-rightbar') {
-              patchCard(other.id, { surface: 'flow' })
+              // `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
@@ -2343,10 +2364,15 @@ 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
+          // 归属校验：只有"本卡就是适配器最后打开的那张"才能关。宿主的 page
+          // tab 把 contentId 固定写成 `sidebar://<kind>`（不是卡片 id），所以
+          // 过去用 `contentId === card.id` 判归属永远匹配失败、关闭恒失效
+          // （2.1.5 R2 的回归）。kind 单地址模型下 `cardId` 才是唯一归属信号。
+          if (this.cardId !== card.id) return false
+          // 卡片自己的会话优先：用户切走会话后关闭 A 的 tab，仍应落在 A。
+          const ownerSession = typeof card.sessionId === 'string' && card.sessionId !== ''
+            ? card.sessionId
+            : store.state.sessionId
           let rows = []
           try {
             rows = typeof controller.openTabs?.getSnapshot === 'function'
@@ -2356,15 +2382,11 @@ 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)
+              // 该 kind 只有一个 page 地址（不是 multiple），所以 kind +
+              // 会话就唯一定位本卡那张 tab；归属由上面的 adapter.cardId 保证。
               && (typeof entry?.sessionId !== 'string'
-                || store.state.sessionId === null
-                || entry.sessionId === store.state.sessionId))
+                || ownerSession === null
+                || entry.sessionId === ownerSession))
             : undefined
           if (row === undefined) return false
           try {
@@ -2390,6 +2412,14 @@ window.__ModuleLoader__.load({
         error: null,
         dispose: null,
         features: [],
+        /**
+         * The card whose open last took the single better tab.
+         *
+         * 0.28.x hosts every better tab in the native rail under one page
+         * address per kind, so only the newest open owns it. Closing a card
+         * that is not this owner must not close someone else's tab.
+         */
+        cardId: null,
         /**
          * Why this adapter is (not) usable, in the settings page's own words.
          * `null` means "usable"; a string explains the refusal.
@@ -2414,20 +2444,56 @@ window.__ModuleLoader__.load({
         },
         open(card) {
           if (!this.available() || typeof this.service.openTab !== 'function') return false
+          // 0.28.x 把 better 的每个描述符镜像成原生右栏类型，而该类型没有
+          // `multiple`：同一 kind 在一个会话里只有一个 page 地址。再开一张卡
+          // 会把这个地址导航到新卡，上一张既不在栏里也没有回到浮层 —— 和
+          // native 适配器 2.1.5 R1 修的是同一个缺陷。这里同样先把同会话的
+          // 其它 better 卡片迁回浮层。
+          const targetSession = card.sessionId ?? store.state.sessionId ?? null
+          for (const other of store.state.cards) {
+            if (other.id === card.id || other.surface !== 'better-sidebar') continue
+            const otherSession = typeof other.sessionId === 'string' && other.sessionId !== ''
+              ? other.sessionId
+              : null
+            if (targetSession !== null && otherSession !== null && otherSession !== targetSession) continue
+            patchCard(other.id, { surface: 'flow', open: true })
+          }
           const tabId = `${CARD_KIND_BETTER}:${card.id}`
           // `meta` is the transport for the card id (feature `tabMeta`), and
           // `dedupeKey` on our descriptor is what collapses repeat opens onto
-          // the same tab; both are part of the stable consumer contract
-          // (`lib/types/client/service.d.ts`, unchanged across 0.22.0 → 0.22.1).
+          // the same tab; both are part of the stable consumer contract.
           this.service.openTab(
             { type: CARD_KIND_BETTER, id: tabId, title: card.question.slice(0, 32), meta: { cardId: card.id } },
-            store.state.sessionId === null ? undefined : { sessionId: store.state.sessionId },
+            typeof targetSession === 'string' && targetSession !== '' ? { sessionId: targetSession } : undefined,
           )
+          this.cardId = card.id
           return true
         },
         close(card) {
           if (!this.available() || typeof this.service.closeTab !== 'function') return false
-          this.service.closeTab(`${CARD_KIND_BETTER}:${card.id}`)
+          // 单一 page 地址：只有最后 open 的那张卡拥有栏里的 tab。
+          if (this.cardId !== card.id) return false
+          const sessionId = typeof card.sessionId === 'string' && card.sessionId !== ''
+            ? card.sessionId
+            : (store.state.sessionId ?? undefined)
+          const scope = typeof sessionId === 'string' && sessionId !== '' ? { sessionId } : undefined
+          // 0.28.x 的原生 tab id 由宿主 mint（tab1…），不是我们传入的 seed id；
+          // CardHost 挂载时把真实 id 记进 embeddedTabIds。
+          const mountedId = embeddedTabIds.get(card.id)
+          if (typeof mountedId === 'string' && mountedId !== '') {
+            this.service.closeTab(mountedId, scope)
+            this.cardId = null
+            return true
+          }
+          // 卡片还没挂载过（或已从 store 移除）：按 kind + 会话在栏的清单里
+          // 找到唯一那张 tab，经原生控制器关闭。
+          if (closeRailRow(CARD_KIND_BETTER, sessionId)) {
+            this.cardId = null
+            return true
+          }
+          // 0.19 之前的 bottom workbench：seed id 就是 tab id。
+          this.service.closeTab(`${CARD_KIND_BETTER}:${card.id}`, scope)
+          this.cardId = null
           return true
         },
       },
@@ -2513,6 +2579,17 @@ window.__ModuleLoader__.load({
      */
     let renderedCardId = null
 
+    /**
+     * Host tab ids for cards mounted by an external embedder, keyed by card id.
+     *
+     * better-sidebar's descriptor component receives the host `SidebarTab`, whose
+     * `id` is the tab id the native rail minted (`tab1`, …) — NOT the internal
+     * `sidecard-ask-better:<cardId>` seed id. Since 0.28.x every better-sidebar
+     * open lands in DSH's native rail, so `closeTab(seed.id)` is a strict no-op.
+     * The body records the real id here and `surfaces.better.close` uses it.
+     */
+    const embeddedTabIds = new Map()
+
     /**
      * Pick the surface for a new card.
      * @param {string} wanted - `auto` | adapter kind.
@@ -5973,6 +6050,8 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               truncated: card.truncated === true,
               droppedChars: Number(card.droppedChars ?? 0),
               createdAt: Number.isFinite(card.createdAt) ? card.createdAt : Date.now(),
+              // 卡片归属的会话，随历史一起持久化；旧条目没有该字段时按 null 读。
+              sessionId: typeof card.sessionId === 'string' && card.sessionId !== '' ? card.sessionId : null,
               provider: typeof card.provider === 'string' ? card.provider : '',
               elapsedMs: Number.isFinite(card.elapsedMs) ? card.elapsedMs : null,
               // 持久化的历史轮次与上下文预算同一个上限（HISTORY_TURNS）：
@@ -6066,6 +6145,8 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               provider: typeof entry.provider === 'string' && entry.provider !== '' ? entry.provider : null,
               elapsedMs: Number.isFinite(entry.elapsedMs) ? entry.elapsedMs : null,
               createdAt: Number.isFinite(entry.createdAt) ? entry.createdAt : 0,
+              // 刷新后仍要能把追问/改投送回原来的会话；旧条目没有该字段。
+              sessionId: typeof entry.sessionId === 'string' && entry.sessionId !== '' ? entry.sessionId : null,
               // P2-5b: replayed versions stay switchable after a reload.
               versions: replayVersions(entry.versions),
               viewingVersion: null,
@@ -6116,6 +6197,8 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           provider: typeof entry.provider === 'string' && entry.provider !== '' ? entry.provider : null,
           elapsedMs: Number.isFinite(entry.elapsedMs) ? entry.elapsedMs : null,
           createdAt: Number.isFinite(entry.createdAt) ? entry.createdAt : 0,
+          // 旧历史没有这个字段：留 null，调用方回退到当前会话。
+          sessionId: typeof entry.sessionId === 'string' && entry.sessionId !== '' ? entry.sessionId : null,
           notified: true,
           versions: replayVersions(entry.versions),
           viewingVersion: null,
@@ -6129,6 +6212,102 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             : [],
         })
 
+        /**
+         * Close the one rail tab a kind owns in one session.
+         *
+         * The rail keeps one page tab per kind (no `multiple`), and its
+         * `contentId` is `sidebar://<kind>` rather than any card id. Both
+         * external surfaces therefore locate a tab by kind + session, never by
+         * the id a body was opened with.
+         * @param {string} kind - the tab kind registered with the rail.
+         * @param {string|null|undefined} sessionId - the owning session, when known.
+         * @returns {boolean} whether a tab was found and the rail accepted the close.
+         */
+        function closeRailRow(kind, sessionId) {
+          const controller = surfaces.native === null ? null : surfaces.native.controller
+          if (controller === null || controller === undefined) return false
+          let rows = []
+          try {
+            rows = typeof controller.openTabs?.getSnapshot === 'function'
+              ? controller.openTabs.getSnapshot()
+              : []
+          } catch { return false }
+          if (!Array.isArray(rows)) return false
+          const candidates = rows.filter(entry => entry?.kind === kind
+            && typeof entry?.tabId === 'string' && entry.tabId !== '')
+          // 会话已知时按会话匹配；会话未知（旧历史没有 sessionId）时只有
+          // 全进程恰好一张该 kind 的 tab 才敢关，否则可能误关别的会话。
+          const row = typeof sessionId === 'string' && sessionId !== ''
+            ? candidates.find(entry => typeof entry?.sessionId !== 'string'
+              || entry.sessionId === sessionId)
+            : (candidates.length === 1 ? candidates[0] : undefined)
+          if (row === undefined) return false
+          try {
+            if (typeof controller.closeIn === 'function' && typeof row.sessionId === 'string') {
+              controller.closeIn(row.sessionId, row.tabId)
+            } else if (typeof controller.close === 'function') {
+              controller.close(row.tabId)
+            } else {
+              return false
+            }
+            return true
+          } catch {
+            return false
+          }
+        }
+
+        /**
+         * Release a better-sidebar tab that no longer has a live card body.
+         *
+         * The descriptor component records the host's real tab id on mount;
+         * without that (a tab restored from a previous page load, or a delete
+         * before the body mounted) the rail inventory locates it by kind.
+         * @param {string} id - the card id whose tab should go away.
+         * @param {string|null|undefined} sessionId - the card's own session.
+         */
+        function releaseBetterTab(id, sessionId) {
+          const better = surfaces.better
+          if (better === null || better === undefined) return
+          if (better.service === null || typeof better.service?.closeTab !== 'function') return
+          // 单一 page 地址：只有最后 open 的那张卡拥有栏里的 tab；释放一张
+          // 不是当前所有者的历史条目，会把现在真正在栏里的卡片连带关掉。
+          if (better.cardId !== id) return
+          const scope = typeof sessionId === 'string' && sessionId !== '' ? { sessionId } : undefined
+          const mountedId = embeddedTabIds.get(id)
+          if (typeof mountedId === 'string' && mountedId !== '') {
+            try { better.service.closeTab(mountedId, scope) } catch { /* the host may already be gone */ }
+            better.cardId = null
+            return
+          }
+          if (closeRailRow(CARD_KIND_BETTER, sessionId)) {
+            better.cardId = null
+            return
+          }
+          try { better.service.closeTab(`${CARD_KIND_BETTER}:${id}`, scope) } catch { /* legacy no-op */ }
+          better.cardId = null
+        }
+
+        /**
+         * 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.
+         * @param {string|null|undefined} sessionId - the card's own session.
+         */
+        function releaseNativeTab(id, sessionId) {
+          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, sessionId })
+          } catch { /* the rail owns its tab's lifetime */ }
+        }
+
         const actions = {
           openPopover(candidate) {
             // P2-2: the composer must be remembered BEFORE the popover's
@@ -6164,9 +6343,21 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           },
           /** Delete one entry from durable history (and its live card). */
           deleteHistoryCard(id) {
+            const entry = store.state.history.find(item => item.id === id)
             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.
+            // The live card (when the manager is deleting one) carries the
+            // session the entry itself may predate.
+            const live = entry === undefined
+              ? store.state.cards.find(card => card.id === id)
+              : undefined
+            if (entry !== undefined || live !== undefined) {
+              releaseBetterTab(id, entry?.sessionId ?? live?.sessionId)
+            }
+            releaseNativeTab(id, entry?.sessionId ?? live?.sessionId)
             writePersisted(next)
             store.set({
               history: next,
@@ -6194,7 +6385,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: cardSessionId(card, ctx) }).catch(() => {})
             }
             controllers.delete(id)
             pendingDeltas.delete(id)
@@ -6211,6 +6402,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, card.sessionId)
             const next = store.state.history
               .filter(item => item.id !== id)
               .slice(0, historyCap())
@@ -6237,6 +6432,22 @@ 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)) {
+              const railSession = store.state.history.find(item => item.id === railCard)?.sessionId
+              releaseNativeTab(railCard, railSession)
+            }
+            // better 承载面同理：历史条目被清空后，只为「没有活跃卡片」的
+            // 条目释放它可能留下的栏 tab。
+            for (const entry of store.state.history) {
+              if (store.state.cards.some(card => card.id === entry.id)) continue
+              releaseBetterTab(entry.id, entry.sessionId)
+            }
             try {
               for (const key of [PERSIST_KEY, PERSIST_V2_KEY, PERSIST_LEGACY_KEY]) {
                 window.localStorage?.removeItem(key)
@@ -6260,6 +6471,8 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               droppedChars: cut.droppedChars,
               zone: candidate.zone,
               carrier: payload.carrier,
+              // 发起会话：卡片可能活过会话切换，停止/改投/追问必须回到它。
+              sessionId: currentSessionId(ctx),
               status: 'pending',
               text: '',
               reasoning: '',
@@ -6287,7 +6500,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               try {
                 const result = await askInMainConversation({
                   ctx,
-                  sessionId: currentSessionId(ctx),
+                  sessionId: cardSessionId(card, ctx),
                   selection: candidate.text,
                   question: payload.question,
                   zone: candidate.zone,
@@ -6474,7 +6687,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             else {
               void askInMainConversation({
                 ctx,
-                sessionId: currentSessionId(ctx),
+                sessionId: cardSessionId(next, ctx),
                 selection: next.selection,
                 question: text,
                 zone: next.zone,
@@ -6542,7 +6755,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: cardSessionId(card, ctx) }).catch(() => {})
             }
             patchCard(card.id, { status: 'stopped' })
           },
@@ -6550,7 +6763,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             try {
               const result = await askInMainConversation({
                 ctx,
-                sessionId: currentSessionId(ctx),
+                sessionId: cardSessionId(card, ctx),
                 selection: card.selection,
                 question: card.question,
                 zone: card.zone,
@@ -6591,7 +6804,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: cardSessionId(card, ctx) }).catch(() => {})
             }
             controllers.delete(card.id)
             // A closed card's buffered-but-unflushed deltas belong to nobody:
@@ -6724,6 +6937,13 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
         const runSideCard = async (cardId) => {
           const card = store.state.cards.find(item => item.id === cardId)
           if (card === undefined) return
+          // 追问/重试沿用卡片自己的会话，而不是用户此刻切到的会话。
+          const ownerSession = typeof card.sessionId === 'string' && card.sessionId !== ''
+            ? card.sessionId
+            : currentSessionId(ctx)
+          if (typeof ownerSession === 'string' && ownerSession !== '' && card.sessionId !== ownerSession) {
+            patchCard(cardId, { sessionId: ownerSession })
+          }
           const controller = new AbortController()
           controllers.set(cardId, controller)
           // #9: wall time from the (re)start of THIS attempt to its terminal
@@ -6745,7 +6965,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             selection: card.selected,
             zone: card.zone,
             carrier: 'side',
-            sessionId: currentSessionId(ctx),
+            sessionId: ownerSession,
             history: card.history.slice(-HISTORY_TURNS).map(turn => ({
               question: String(turn?.question ?? '').slice(0, HISTORY_TURN_Q_CHARS),
               answer: String(turn?.answer ?? '').slice(0, HISTORY_TURN_A_CHARS),
@@ -7314,11 +7534,15 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           const state = useStoreState()
           const cardId = hostCardIdOf(props)
           const card = state.cards.find(item => item.id === cardId)
+          // The embedder's REAL tab id (better-sidebar 0.28.x mints it and
+          // ignores the seed id we passed), recorded for close/delete.
+          const hostTabId = typeof props?.tab?.id === 'string' && props.tab.id !== '' ? props.tab.id : null
           // The proof hook MUST run before any early return (hook order), and
           // it is what lets `submit` detect a host that never rendered us.
           React.useEffect(() => {
             if (typeof cardId !== 'string' || cardId === '') return undefined
             renderedCardId = cardId
+            if (hostTabId !== null) embeddedTabIds.set(cardId, hostTabId)
             // Mounting settles the render proof, even when this host mounted
             // late (a lazy tab panel slower than the 600ms timer) — the proof
             // must never fire after the card is demonstrably on screen.
@@ -7329,8 +7553,11 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             }
             return () => {
               if (renderedCardId === cardId) renderedCardId = null
+              if (hostTabId !== null && embeddedTabIds.get(cardId) === hostTabId) {
+                embeddedTabIds.delete(cardId)
+              }
             }
-          }, [cardId])
+          }, [cardId, hostTabId])
           if (card === undefined) {
             return h('div', { className: 'dsa-settings', 'data-dsa-root': '', 'data-dsa-rail-host': '' },
               h(Styles, null),

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.4'
+export const PLUGIN_VERSION = '2.1.6'
 
 /** 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) }
 }
@@ -1901,7 +1924,16 @@ function createSideEngine(ctx, configOf) {
 
     /** 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 {
@@ -2123,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
   }
@@ -2603,7 +2653,12 @@ export function apply(ctx, patchConfig) {
     // 只回本次取消的结果：`runs` 是跨会话的全局表，把它的 id 列表回给
     // 任意可信页面等于泄露别的会话正在追问的卡片 id（而 cancel 本身也不
     // 校验归属），Client 侧也没有任何地方消费这个字段。
-    writeOk(res, { cancelled: engine.cancel(id) })
+    // 归属校验：请求方必须带上自己的 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. */

package/package.json

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