dsh-sidecard-ask 2.1.5 → 2.1.7

package/CHANGELOG.md

@@ -1,5 +1,85 @@
 # Changelog
 
+## 2.1.7
+
+**主题：修复「技术方案评审团」在 0.2.1-rc.5（桌面 Electron 44.7.0 / 网页端同源）上复核出的 8 条缺陷。**
+
+### 修复
+
+- **A1（中）页面重载后右侧栏留下关不掉的「幽灵面板」**。宿主会持久化栏布局，重载
+  后把插件的 tab 还原出来；而「哪张卡拥有它」（`surfaces.native.cardId`）是进程内存，
+  卡片本身也不持久化。旧归属门是「`cardId !== card.id` 就拒绝」，于是没有卡片认领、
+  也永远关不掉，面板长期渲染「该卡片已关闭」。现在归属门改为**已知别的卡拥有才拒绝，
+  无主时按 kind + 会话定位**；并在注册完成时、以及 900 ms 后各清扫一次无主的同 kind
+  tab（绝不碰其它插件的 kinds）。
+- **A2（中）删除历史条目时孤儿 tab 不关**。`deleteRailTab` 与 `surfaces.better.close`
+  在 `cardId === null` 时直接 return，删除后栏里留一块空面板。改为无主放行后，删除
+  路径能真正清掉那张 tab。
+- **A4（低）承载面标签标错宿主**。`CardHost` 过去读全局 `state.surface`；原生栏与
+  better 镜像同时存在时，better 栏里的卡会被标成「原生右栏」。两个宿主槽现在都显式
+  传自己的 `surface`，标签优先采用它。
+- **A8（低）设置页文案仍写死 `0.2.1-rc.3`**。只读开关与 preset 提示改为「0.2.x 宿主
+  均不支持（`0.2.1-rc.3` 实测、`rc.5` 复核）」。
+- **CANCEL（中）`/cancel` 接受不带 sessionId 的调用**。run 有归属会话时，旧逻辑只在
+  「两边都非空且不等」才拒绝，于是不带 sessionId 的调用能中止任意会话的子代理。现在
+  只要 run 知道归属，就要求调用方给出**相等**的 sessionId，否则拒绝；老客户端一直带
+  sessionId，不受影响。
+- **AUTH-EDGE（低）`requestRejection` 的意外返回值被当成放行**。旧实现把任何非
+  401/403 的值都当通过。现在只有 `undefined / null / false / 200` 算放行，其余按未
+  认证（403）处理并留一条 warn；`connection` 服务缺失时的日志由 info 改为 warn
+  （网页端就是这个形态，等于「没有宿主级认证」，不该静音）。
+- **MULTITAB（低）跨页历史被「最后写者」复活**。桌面窗口与浏览器各持一份 store、每次
+  写整个数组：A 删掉一条后，B 的下一次同步会把它写回来。现在监听 `storage` 事件，
+  别的页面写盘后立即采用磁盘上的权威集合。
+- **承载面未证实的空面板（低）**。卡被判定「承载面未证实」迁回浮层时，栏里那张 tab
+  没有关闭，留下「已移到浮层」的空面板。迁移时同时请求两个宿主关掉自己的 tab。
+
+### 评估后不改
+
+- **run 没有归属会话时 `/cancel` 仍允许取消**。这类 run（宿主没给 sessionId、脚本
+  直调）若一并拒绝，就只能等 120 s 超时才结束；归属会话已知时已经收紧，故保留。
+
+### 验证
+
+`verify 57 / contract 1487 / float-placement 100 / smoke 283 = 1927 全绿`。本轮净增
+16 条断言：无主 tab 在注册时即被清扫且不碰其它 kind、删除历史条目时无主 tab 仍被
+关闭、承载面标签跟随宿主而非全局偏好、`/cancel` 拒绝错会话与缺会话。
+
+## 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 条缺陷。**

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.5'
+    const CLIENT_VERSION = '2.1.7'
 
     /**
      * Tab kind served by the DSH native right rail (also its implementation id).
@@ -707,9 +707,9 @@ window.__ModuleLoader__.load({
         setMinChars: '最小触发字符数',
         setConcurrency: '并发作答上限',
         setSideTools: '侧边作答工具权限',
-        setSideToolsReadonly: '只读（需宿主支持，0.2.1 无效）',
+        setSideToolsReadonly: '只读（需宿主支持，0.2.x 无效）',
         setSideToolsInherit: '继承当前会话',
-        setSideToolsHint: '这个开关只在宿主支持工具白名单时才生效；0.2.1-rc.3 不支持，侧边作答会继承当前会话的全部工具。要真正收窄，请填写下面的 preset（0.2.1-rc.3 已支持）。',
+        setSideToolsHint: '这个开关只在宿主支持工具白名单时才生效；0.2.x 宿主（0.2.1-rc.3 实测、rc.5 复核）都不支持，侧边作答会继承当前会话的全部工具。要真正收窄，请填写下面的 preset（0.2.1 起支持）。',
         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 (needs host support; no-op on 0.2.1)',
+        setSideToolsReadonly: 'Read-only (needs host support; no-op on 0.2.x)',
         setSideToolsInherit: 'Inherit from the session',
-        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).',
+        setSideToolsHint: 'This switch only works when the host supports a tool allow-list; no 0.2.x host does (verified on 0.2.1-rc.3 and re-checked on rc.5), so the side answerer inherits every tool of the session. To really narrow it, set the preset below (supported since 0.2.1).',
         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
@@ -2347,10 +2364,20 @@ 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 关是对的。
+          // 归属校验：只有"本卡就是适配器最后打开的那张"才能关。宿主的 page
+          // tab 把 contentId 固定写成 `sidebar://<kind>`（不是卡片 id），所以
+          // 过去用 `contentId === card.id` 判归属永远匹配失败、关闭恒失效
+          // （2.1.5 R2 的回归）。kind 单地址模型下 `cardId` 才是唯一归属信号。
+          // 严格归属（只认 `cardId === card.id`）治好了 2.1.5 R2 的"串卡"，
+          // 却把另一种真实场景关在门外：页面重载后宿主会从布局里恢复出这张
+          // tab，而 `cardId` 是内存态、必然是 null —— 此时没有卡片认领它，
+          // 删除历史条目也永远关不掉，就是专家复现的"幽灵面板"。
+          // 规则改为：**已知别的卡拥有它才拒绝**；无主时按 kind + 会话定位。
           if (this.cardId !== null && 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'
@@ -2360,18 +2387,11 @@ 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))
+              // 该 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 {
@@ -2397,6 +2417,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.
@@ -2421,20 +2449,58 @@ 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。
+          // 同 native.close：无主（cardId 为 null，页面重载后）也要放行，
+          // 否则在历史管理器里删掉一条 better 卡，栏里那张 tab 永远留空。
+          if (this.cardId !== null && 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
         },
       },
@@ -2520,6 +2586,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.
@@ -5980,6 +6057,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）：
@@ -6073,6 +6152,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,
@@ -6123,6 +6204,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,
@@ -6136,6 +6219,82 @@ 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；释放一张
+          // 不是当前所有者的历史条目，会把现在真正在栏里的卡片连带关掉。
+          // 无主（null）时也放行：理由见 better.close。
+          if (better.cardId !== null && 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.
          *
@@ -6145,17 +6304,50 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
          * 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) {
+        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
+          // 无主（null）时也放行：理由见 native.close。
+          if (native.cardId !== null && native.cardId !== id) return
           try {
-            native.close({ id })
+            native.close({ id, sessionId })
           } catch { /* the rail owns its tab's lifetime */ }
         }
 
+        /**
+         * Close rail tabs that no live card can claim.
+         *
+         * The host persists the rail layout, so after a page reload our tab is
+         * restored — but "which card owns it" (`surfaces.native.cardId` /
+         * `surfaces.better.cardId`) is process memory, and cards themselves are
+         * not persisted. The result is a panel that renders "card closed" and
+         * that the old build could not even close (expert A1). When no card of
+         * this page owns the address, the tab is provably orphaned: close it.
+         */
+        function sweepOrphanRailTabs() {
+          const native = surfaces.native
+          if (native !== null && native !== undefined && native.cardId === null
+            && native.controller !== null && native.controller !== undefined) {
+            let rows = []
+            try {
+              rows = typeof native.controller.openTabs?.getSnapshot === 'function'
+                ? native.controller.openTabs.getSnapshot()
+                : []
+            } catch { rows = [] }
+            for (const row of Array.isArray(rows) ? rows : []) {
+              if (row?.kind !== CARD_KIND) continue
+              if (typeof row.sessionId !== 'string' || typeof row.tabId !== 'string') continue
+              try { native.controller.closeIn(row.sessionId, row.tabId) } catch { /* rail owns it */ }
+            }
+          }
+          // better 栏刻意不在这里扫：插件的 tab 只有在宿主真的 mount 它时才
+          // 存在，而 mount 是“当前页面有卡片”的证明；多窗口下另一个窗口的
+          // 活跃卡片与本页共享同一个 session，盲扫会替它关掉 tab。
+        }
+
         const actions = {
           openPopover(candidate) {
             // P2-2: the composer must be remembered BEFORE the popover's
@@ -6191,12 +6383,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.
-            releaseNativeTab(id)
+            // 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,
@@ -6224,7 +6425,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, sessionId: store.state.sessionId }).catch(() => {})
+              void postJson('cancel', { id, sessionId: cardSessionId(card, ctx) }).catch(() => {})
             }
             controllers.delete(id)
             pendingDeltas.delete(id)
@@ -6244,7 +6445,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             // 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)
+            releaseNativeTab(id, card.sessionId)
             const next = store.state.history
               .filter(item => item.id !== id)
               .slice(0, historyCap())
@@ -6278,7 +6479,14 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             const railCard = surfaces.native?.cardId
             if (typeof railCard === 'string' && railCard !== ''
               && !store.state.cards.some(card => card.id === railCard)) {
-              releaseNativeTab(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]) {
@@ -6303,6 +6511,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: '',
@@ -6330,7 +6540,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,
@@ -6384,6 +6594,10 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
                   if (renderedCardId === card.id) return
                   store.set({ surface: 'flow', surfaceNote: t('surfaceUnproven') })
                   patchCard(card.id, { surface: 'flow' })
+                  // 卡已经回到浮层，栏里那张 tab 就没有内容了；不关掉会留下
+                  // 一块"已移到浮层"的空面板，用户还得自己找它（专家 E）。
+                  try { surfaces.native.close(card) } catch { /* rail owns it */ }
+                  try { surfaces.better.close(card) } catch { /* host may be gone */ }
                   toast(t('surfaceUnproven'))
                   scheduleReport(0)
                 }, 600)
@@ -6517,7 +6731,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,
@@ -6585,7 +6799,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, sessionId: store.state.sessionId }).catch(() => {})
+              void postJson('cancel', { id: card.id, sessionId: cardSessionId(card, ctx) }).catch(() => {})
             }
             patchCard(card.id, { status: 'stopped' })
           },
@@ -6593,7 +6807,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,
@@ -6634,7 +6848,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, sessionId: store.state.sessionId }).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:
@@ -6767,6 +6981,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
@@ -6788,7 +7009,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),
@@ -7209,6 +7430,8 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               if (registry === null || registry === undefined) return
               surfaces.native.registry = registry
               surfaces.native.controller = controller ?? null
+              // 布局恢复出来的 tab 没有卡片认领，注册完立刻清一次。
+              try { sweepOrphanRailTabs() } catch { /* best effort */ }
               // Register the tab TYPE first, then its body/title slots — and
               // roll the type back if a slot refuses to register.
               //
@@ -7241,7 +7464,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
                 slotDisposers.push(ctx.slots.inject('sidebar.right.pane.tab', () => ctx.slots.register({
                   name: 'sidebar.right.pane.tab',
                   key: CARD_KIND,
-                }, props => h(CardHost, { props, actions }))))
+                }, props => h(CardHost, { props, actions, surface: 'native-rightbar' }))))
                 slotDisposers.push(ctx.slots.inject('sidebar.right.pane.tab.title', () => ctx.slots.register({
                   name: 'sidebar.right.pane.tab.title',
                   key: CARD_KIND,
@@ -7317,9 +7540,12 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
                 component: props => h(CardHost, {
                   props: { tab: props?.tab, sessionId: props?.scope?.sessionId },
                   actions,
+                  surface: 'better-sidebar',
                 }),
               })
               surfaces.better.service = service
+              // 同 native：注册完清掉无主的 better 栏 tab。
+              try { sweepOrphanRailTabs() } catch { /* best effort */ }
               surfaces.better.dispose = typeof off === 'function' ? off : null
               disposers.push(() => {
                 try { surfaces.better.dispose?.() } catch { /* already disposed */ }
@@ -7348,20 +7574,29 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           const navigation = props?.tab?.navigation ?? props?.navigation
           const fromParams = navigation?.params?.cardId
           if (typeof fromParams === 'string' && fromParams !== '') return fromParams
+          // 回退只对"宿主不给 tab 对象"的内置右栏成立（它本来就这么设计：
+          // 导航参数不进 tab 记录）。better-sidebar 一定给 tab；它的 meta 里
+          // 没有 cardId 时，这张 tab 不是卡片的，拿原生适配器的地址顶替会
+          // 渲染出**另一张卡**（专家 A1-host 的跨面误伤）。
+          if (props?.tab !== undefined && props.tab !== null) return undefined
           const recorded = surfaces.native.cardId
           return typeof recorded === 'string' && recorded !== '' ? recorded : undefined
         }
 
         /** Embedded card body used by both external hosts. */
-        function CardHost({ props }) {
+        function CardHost({ props, surface }) {
           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.
@@ -7372,8 +7607,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),
@@ -7394,7 +7632,10 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             h(Styles, null),
             h(MemoAnswerCard, {
               card,
-              surfaceLabel: state.surface === 'better-sidebar' ? t('surfaceBetter') : t('surfaceNative'),
+              // 标签说的是"这张卡现在挂在哪个承载面"，与用户选的全局
+              // 偏好无关：两个宿主可能同时存在（原生栏 + better 镜像），
+              // 读 state.surface 会把 better 栏里的卡标成"原生右栏"（专家 A4）。
+              surfaceLabel: (surface ?? state.surface) === 'better-sidebar' ? t('surfaceBetter') : t('surfaceNative'),
               onCopy: element => actions.copy(card, element),
               onFollowUp: text => actions.followUp(card, text),
               onRetry: () => actions.retry(card),
@@ -7418,6 +7659,35 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           console.warn(`[${PLUGIN_ID}] card history restore failed:`, error)
         }
 
+        // The adapters register asynchronously (ctx.inject callbacks), so the
+        // sweep above may run before the rail data exists; one delayed retry
+        // covers a layout that is restored after this line.
+        const orphanSweepTimer = setTimeout(() => {
+          try { sweepOrphanRailTabs() } catch { /* best effort */ }
+        }, 900)
+        disposers.push(() => clearTimeout(orphanSweepTimer))
+
+        // Cross-tab history sync. Two pages (desktop window + browser) each
+        // hold their own store and write the WHOLE array, so the last writer
+        // wins: A deletes an entry, B still has it in memory, B's next write
+        // resurrects it (expert MULTITAB). Adopting the on-disk envelope
+        // whenever another page writes makes B's next sync start from the
+        // authoritative set instead of its stale memory.
+        let storageListener = null
+        try {
+          if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+            storageListener = event => {
+              if (event !== null && event !== undefined && typeof event.key === 'string'
+                && event.key !== PERSIST_KEY) return
+              try { store.set({ history: readPersisted() }) } catch { /* read defensively */ }
+            }
+            window.addEventListener('storage', storageListener)
+            disposers.push(() => {
+              try { window.removeEventListener('storage', storageListener) } catch { /* gone */ }
+            })
+          }
+        } catch { /* a host without storage events simply has no cross-tab sync */ }
+
         // §4.5 family singleton: register this copy, (re)elect on every join
         // or leave, and gate the interaction surface on the verdict.
         const family = familyTable(window)

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.5'
+export const PLUGIN_VERSION = '2.1.7'
 
 /** Route prefix of the plugin's own API. */
 export const ROUTE_PREFIX = '/sidecard-ask/api'
@@ -2172,10 +2172,12 @@ function createSideEngine(ctx, configOf) {
     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
+    if (typeof owner === 'string' && owner !== '') {
+      // 归属判定必须是"两边都在且相等"：只要这个 run 知道自己在哪个会话，
+      // 没带 sessionId（或带错）的调用方一律拒绝 —— 否则任何拿到 run id 的
+      // 页面都能中止别的会话的子代理（专家 CANCEL）。老客户端一直带
+      // sessionId，因此这条收紧不会打断既有调用方。
+      if (typeof sessionId !== 'string' || sessionId === '' || owner !== sessionId) return false
     }
     record.abort()
     return true
@@ -2752,15 +2754,27 @@ export function apply(ctx, patchConfig) {
   const authRejection = req => {
     const connection = connectionService()
     if (connection === undefined) {
+      // 专家 AUTH-EDGE：这是 WEB 端的正常形态（宿主没把 connection 服务
+      // 暴露给插件），但它同时意味着"没有宿主级认证"—— 单条 info 等于把
+      // 风险静音，改成 warn，且每个进程仍只记一次。
       if (!authGateNoted) {
         authGateNoted = true
-        ctx.logger?.info?.('[sidecard-ask] 未挂载 connection 服务：API 仅保留 loopback/Origin 围栏')
+        ctx.logger?.warn?.('[sidecard-ask] 未挂载 connection 服务：API 仅保留 loopback/Origin 围栏，无宿主级认证')
       }
       return undefined
     }
     try {
       const rejection = connection.requestRejection(req)
-      return rejection === 401 || rejection === 403 ? rejection : undefined
+      if (rejection === 401 || rejection === 403) return rejection
+      // 旧实现把"任何非 401/403 的值"都当放行，包括对象/字符串这类仲裁器
+      // 可能用来表示"拒绝"的返回值（专家 AUTH-EDGE）。契约未公开，所以
+      // 只在明确表示放行时放行：undefined/null/false/200；其余按未认证
+      // 处理并留一条 warn，万一是契约误判能立刻被看见。
+      if (rejection === undefined || rejection === null || rejection === false || rejection === 200) {
+        return undefined
+      }
+      ctx.logger?.warn?.('[sidecard-ask] requestRejection 返回了意外的值，按未认证处理：', rejection)
+      return 403
     } catch (error) {
       // Fail closed: an unreadable auth service must not widen the surface.
       ctx.logger?.warn?.('[sidecard-ask] 鉴权校验异常，按未认证处理：', error?.message ?? error)

package/package.json

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