dsh-sidecard-ask 1.8.2 → 1.8.3

package/CHANGELOG.md

@@ -1,5 +1,81 @@
 # Changelog
 
+## 1.8.3
+
+**主题：右侧栏打开时，答案卡直接铺满它、读成栏内的一页——而不是 340px 的浮层压在右栏正文上。**
+
+起因是用户截图：右栏开着「团队任务板」，答案卡浮在它上面，正文被挤成一条窄缝，标题与操作行占掉大半。
+
+- **`dockRail`（默认 `true`）**：右栏可见且已展开时，把卡片铺到**标签条下方**的内容区——宽度取右栏宽，
+  高度取到帧底；右栏自己的标签条仍然露出可点。这个形态下卡片去掉圆角、描边与阴影，只留一条左边线
+  与右栏内容区分界；标题栏（追问 + 徽标 + ⇥/×）与底部操作行固定上下两端，`AnswerBody` 独立滚动，
+  长答案不再把操作行推出视野。收起为胶囊（⇥）、关闭（×）或关掉本项，立即回到常规浮层。
+- **几何是量出来的，不是猜的**：`dockedBodyRect(node)` 取右栏面板的 `getBoundingClientRect()`，若它在
+  `[data-dockkit-pane]` 里，再把顶边抬到所有 `[data-dockkit-tab]` 的底边——否则卡片会盖住右栏自己的标签条。
+  `findRail(scope)` 按世代尝试选择器（最具体的在前）：
+  `[data-dsa-rail-host]`（本插件自己渲染在右栏里的 `CardHost` 节点——它所在的位置就是「一页正文」）→
+  `[data-sidebar-right-panel][data-sidebar-right-open] [data-dockkit-pane]` → 面板本身 →
+  `[data-sidebar-right-session][data-sidebar-right-open]` → `[data-dockkit-pane]` / `[data-dockkit-column]`
+  （只渲染 dockkit 标记的构建）→ `.rightbar` → `[data-slot^="sidebar.right"]`；
+  **只接受展开态**（折叠的面板会滑出帧外，它的 rect 不能用；`railOnScreen` 负责拒绝），量不到、
+  宽 < 280px 或高 < 240px 一律回退浮层。
+  这些标记不是文档给的，是从安装包里的 `@deepseek-ai/dsh-client-ui-sidebar-right/lib/client.js` 读出来的。
+- **纯函数 `railDock`**：`enabled` 为假、坐标非有限、宽高低于 280/240 → `null`（= 不 dock）；矩形夹进
+  `[0,frameWidth] × [0,frameHeight]`，夹完仍不足最小尺寸也返回 `null`；`clipped` 表示「画出来的不是量到的」——
+  尺寸被夹小，或原点被拉回帧内（右栏入场动画期间可能量到负坐标）。已导出到 `api.pure`，测试与运行时共用一份实现。
+- **渲染**：`docked = mode === 'full' && dock !== null`；容器改 `data-dsa-float-mode="dock"` 并写 inline
+  `left/top/width/height`（同时释放基类的 `right/bottom`，否则会过约束），`.dsa-stack` 带
+  `data-dsa-dock-body="<px>"` 供对照；三种形态复用同一份 `cardNodes`，没有分叉出第二套卡片。
+- **设置页**新增「右侧栏打开时占满它」复选框（只写草稿，点保存才落盘），并给出「收起为胶囊或关闭即恢复原状；
+  右侧栏不在时不生效」的说明；三个 i18n 键（zh/en 各三条）。
+- **为什么不做成"真的注册右栏的一页"（如实）**：`sidebarRightTabs` / `sidebarRight` 两个服务在当前构建里
+  **确实存在**（从 `app.asar` 里读到 `ctx.reflect.provide("sidebarRightTabs", tabs)`），注册形状
+  （`register({id, kind, guide, …})`）与槽派发键（`entryKey = definition?.id ?? tab.kind`，本插件两处都是
+  `sidecard-ask:card`）也逐一核对过；但实测 `controller.openTab` 路径仍回落到浮层，且没定位到抛错点。
+  在它修好之前，`dockRail` 是**视觉等价、失败即回退**的兜底层——README §6.1 仍把它标为占位接口，没有说成官方能力。
+- **已知代价（如实）**：dock 期间会盖住右栏内容区里的其他面板（那些面板仍在下面），也会暂时压住右栏的
+  拖拽改宽手柄；这两点都写进了 README §4.2 与代码注释。
+- 测试：`float-placement` 新增 **40** 项（`railDock` 的夹取、最小尺寸、`clipped` 语义、不修改入参、非有限输入、
+  `dockRail` 默认值、源码钩子、上面三个缺陷的回归断言，以及承载面自动链的顺序断言）；`contract` 新增 **8** 项
+  （设置页复选框：唯一一行、单个 checkbox、默认勾选、带写草稿的 onChange、说明文案；承载面 `auto` 的
+  新偏好）；3 个新 i18n 键由既有词典用例自动覆盖。
+  总项数 1293 → **1350**。
+- **发布前的一次真实回合（用户截图 + 一个「？」）修掉的三个缺陷**——首次交付的 dock 在真机上**没有生效**：
+  卡片仍以约 505px 浮在右栏上，而右栏里留着一个正文写着「该卡片已关闭」的空 tab。
+  1. `apply()` 里残留 `rail` 变量：改用 `railBox` 后旧守卫没删干净，一旦 `ResizeObserver` 回调进来就抛
+     `ReferenceError: rail is not defined`，并且**右栏节点永远不会被 observe**。已删，并加回归断言
+     （源码里不得再出现 `observed.has(rail)`）。
+  2. **右栏开合不触发重算**：effect 依赖只有 `[maxWidth, total, mode, dockWanted]`，而被观察的是挂载时
+     就已存在的节点——右栏是后开的，量不到就永远不 dock。现在的触发源有四个：`window resize`、
+     `ResizeObserver`（对话区 + 当前被接受的那个右栏节点）、**只盯属性的 `MutationObserver`**
+     （`data-sidebar-right-open` / `data-dockkit-pane-active` / `style` / `class`；**不盯 childList**，
+     否则流式 token 每帧都会唤醒几何计算）、以及挂载后 `[80,200,420,800]ms` 四次重测（罩住右栏滑入动画）。
+  3. **不再靠猜右栏标记**：`CardHost` 自己渲染在右栏里的节点就是「一页正文」，它的矩形就是答案。三个
+     `CardHost` 包装节点加 `data-dsa-rail-host`，并作为 `RAIL_SELECTORS` 的**第一优先**锚点（设置页根节点
+     故意不加，否则浮层会停靠到设置面板上）；其后才是 `data-sidebar-right-*`、dockkit 世代、`.rightbar`
+     与 `sidebar.right` 槽。折叠态另由 `railOnScreen()` 拒绝（`left >= frameWidth - 1` 或
+     `top >= frameHeight - 1` 视为不在屏上），不会被 `railDock` 夹进视野。
+- **诊断属性**：浮层根节点新增 `data-dsa-dock`，取值 `dock` / `no-rail` / `rail-too-small` / `off` / `mode`，
+  一眼区分「没找到右栏」「找到了但太窄」「开关关了」「当前不是完整卡片形态」。
+- **承载面 `auto` 的顺序改了：dsh-better-sidebar → 内置浮层卡片；原生右侧栏退出自动链。**
+  原因是那个空 tab：卡片被塞进右栏只是一个 tab，tab 的生命周期不归插件管——卡片关掉后右栏仍留着一条
+  读作「该卡片已关闭」的标签，还和用户自己的右栏标签抢位置，落点又取决于我们不控制的宿主细节。
+  原生右侧栏保留为**强制选项**（下拉里标注「强制，不参与自动」，新增 `surfaceNativeForce` 文案），
+  显式 `sideSurface: 'native-rightbar'` 仍然走它。下拉顺序同步为 auto / 插件 / 内置卡片 / 强制右侧栏。
+  连带把三条依赖「auto 会挑原生」的既有用例改成显式指定 `native-rightbar`（它们测的是原生适配器本身，
+  不该再由 auto 顶上来）。
+- 版本号三处同步到 1.8.3。
+
+本机实测（四项均 exit 0）：verify **57** / contract **989** / float-placement **78** / smoke **226**
+= **1350 项全部通过**（1.8.2 为 1293；float-placement 由 38 → 78，含 `railDock` 用例、上面三个缺陷的回归钩子，
+以及「自动链里不出现原生右侧栏」的顺序断言；contract 972 → 989）。
+
+> 未验证（如实记录）：`design-preview/09-dock-{light,dark,narrow-light}.png` 三张图是**离屏渲染**——
+> 无头 Edge 加载"从 `client.js` 切出的真实样式表 + 本机 uiskin 皮肤令牌真值 + 按 `app.asar` 里读到的
+> 右栏标记搭的静态结构"的页面，**不是**运行中 DSH 窗口的截图。因此它证明的是"这套 CSS 在给定矩形里
+> 摆成什么样"，不证明真实页面里右栏的实测矩形、滚动性能，也不证明 dock 与右栏拖宽手柄的冲突手感。
+> 这些仍需刷新页面人工确认（README §9 A 路径第 9 条给了可执行的判据）。
+
 ## 1.8.2
 
 **主题：提问框底部的「作答位置」从"两枚看不出选中哪一侧的标签"改成一眼可辨的分段芯片；并把 1.8.1 之后写在本地、尚未提交的弹层对比度修补一并发布。**
@@ -17,10 +93,16 @@
   `--dsw-alias-brand-primary` 提亮到 `#5b9cf5`，白色 600 字在其上低于 4.5:1 正文下限、也低于 3:1 大字下限。
   改法：`[data-ds-dark-theme]` 下选中侧改用深墨 `#0a1428`（实测 6.57:1）；浅色保持白字
   （`#2563c0` 上 5.79:1）。令牌值取自本机 `uiskin-theme`，对比度按 WCAG 相对亮度公式实算，不是目测。
-- **弹层边框/阴影对比度修补（1.8.1 之后写在本地、未提交，本次一并发布）**：`.dsa-pop` 的 1px 边
-  改显式中灰 `rgba(127,127,127,.55)`（`border-l2` 落在弹层表面只量到 ≈1.3:1），阴影改两层衰减
+- **弹层边框/阴影修补（1.8.1 之后写在本地、未提交，本次一并发布；含一处数字更正）**：`.dsa-pop` 的 1px 边
+  改显式中灰 `rgba(127,127,127,.55)`，阴影改两层衰减
   `0 14px 36px rgba(0,0,0,.30), 0 3px 10px rgba(0,0,0,.14)`；`.dsa-pop` 内的次级文案改用
   `label-primary` 并保留 `.78` 不透明度。
+  **更正**：随该补丁一起写下的代码注释声称"外框用 `border-l2` 只量到 ≈1.3–1.7:1"，实测不成立——
+  按本机皮肤令牌复合（bg-base .55 over white → bg-overlay .98）后，`border-l2` 是 **1.95:1（浅）/ 2.88:1（深）**；
+  1.40:1 那个数字属于内层 `border-l1` 的 1px 边。换成中灰 .55 后测得 **1.96:1（浅）/ 2.12:1（深）**——
+  所以这一步是**色度修正（蓝对蓝 → 中性灰），不是亮度对比度提升**，深色下还略弱。
+  真正抬高可读性的是两层阴影与次级文案换成 `label-primary`（6.11:1）。
+  若需要更强的实体边框，中灰 .85 测得 ≈3.03:1，但视觉更硬，未擅自采用。
 - 测试：contract 新增 **16** 项钉住这个控件（唯一 `.dsa-seg`、恰好两个按钮、恰好一个
   `aria-pressed="true"`、每个选项带一枚内联 `svg`、`data-on` 只有一个真值、两个去向的标签不互换、
   品牌实底规则与深色覆盖规则必须出现在样式表里）。**点击切换本身仍然不可测**：harness 的

package/README.md

@@ -156,10 +156,11 @@ plugin_manager(action="install_bundle", target="D:\\Users\\34332\\AI\\dsh-sideca
 |---|---|---|---|---|
 | `trigger` | `selection` \| `shortcut` \| `both` | `selection` | **触发方式**：选中即浮出按钮 / 只用快捷键 / 两者都要 | 改后立即（客户端读 /state） |
 | `defaultCarrier` | `main` \| `side` | `side` | **默认作答位置**：提问框里仍可临时切换 | 立即 |
-| `sideSurface` | `auto` \| `native-rightbar` \| `better-sidebar` \| `flow` | `auto` | **窗口模式（侧边承载面）**：自动挑选 / 强制 DSH 原生右侧栏 / 强制 dsh-better-sidebar / 强制内置浮层卡片 | 立即 |
+| `sideSurface` | `auto` \| `native-rightbar` \| `better-sidebar` \| `flow` | `auto` | **窗口模式（侧边承载面）**：自动挑选（先 dsh-better-sidebar，再内置浮层卡片）/ 强制 DSH 原生右侧栏（不参与自动）/ 强制 dsh-better-sidebar / 强制内置浮层卡片 | 立即 |
 | `maxChars` | 200–60000 | `4000` | **最大字符数**：超出部分头尾保留、中间截断并标注 | 立即 |
 | `floatMode` | `capsule` \| `full` \| `off` | `capsule` | **内置浮层的默认形态**：胶囊（一行，最小遮挡）/ 完整卡片栈 / 只留一个计数圆点。运行时可即时收起、隐藏，但不写回本项——刷新后仍回到这里设的默认 | 立即 |
 | `floatMaxWidth` | 240–560 | `340` | **内置浮层宽度上限**（px）：实际宽度 = `min(本项, 对话区右侧可用带宽)`，可用带宽不足 240px 时才会压入对话区 | 立即 |
+| `dockRail` | 布尔 | `true` | **右侧栏打开时占满它**：答案卡铺满右栏标签条下方的内容区，读起来像栏内的一页，而不是 340px 的小浮层。收起为胶囊、关闭浮层、右栏宽度 < 280px 或高度 < 240px 时自动回到常规浮层；实现靠测量右栏 DOM 矩形，**没有**走 DSH 的右栏 API（见 §4.2 与 §6.1） | 立即 |
 | `shortcut` | 形如 `Alt+Q`、`Ctrl+Shift+K` | `Alt+Q` | **快捷键**：唤起提问框（`trigger` 允许时） | 立即 |
 | `captureZones` | `auto` \| `chat` \| `task` \| `chat+task` | `auto` | 只在哪些区域触发 | 立即 |
 | `showInUnclassified` | 布尔 | `true` | 无法归类的区域是否也触发 | 立即 |
@@ -202,6 +203,35 @@ bleeds = 对话区右边界 - left > 1          // 只有带宽 < 240px 时才
 - 挂载时、窗口 resize 时、右栏开合时（`ResizeObserver`）都会重算；流式刷新只重渲染，不动几何。
 - 浮层根节点带 `data-layer-width`（实际宽度）与 `data-dsa-float-mode`：报告问题时可直接读这两个值。
 
+### 4.2 右侧栏打开时「占满它」（`dockRail`，1.8.3）
+
+340px 的浮层在右栏打开时会同时压住两块内容：主对话的最后几行、以及右栏自己的正文。1.8.3 起默认
+（`dockRail: true`）把整张卡铺到右栏里，读起来像栏内的一页：
+
+- 位置 = 右栏**标签条之下**的内容区矩形，宽度取右栏宽度，高度取到底部；右栏自己的标签条仍然露出、可点。
+- 卡片在这个形态下没有圆角/描边/阴影（`.dsa-card` 的装饰被 `[data-dsa-float-mode="dock"]` 覆盖），只有一条左边线与右栏内容区分界。
+- 标题栏（追问 + 徽标 + ⇥ / ×）与底部操作行固定上下两端，中间 `AnswerBody` 独立滚动——长答案不再把操作行推出视野。
+- 收起为胶囊（⇥）、关闭（×）、或把 `dockRail` 关掉，都立即回到常规浮层；右栏宽度 < 280px 或高度 < 240px 时也回退（窄栏里铺满会把正文挤成每行 8–9 字）。
+- 折叠的右栏不会被误用：`railOnScreen()` 会拒绝停在帧外（`left >= frameWidth - 1`）或尺寸不足的面板，量不到就回退，绝不把卡片画到帧外。
+- 矩形从哪来：**优先量本插件自己渲染在右栏里的 `CardHost` 节点**（`[data-dsa-rail-host]`）——它所在的位置按定义就是「一页正文」，不依赖任何未被文档承诺的标记；找不到时再按 `data-sidebar-right-*`、dockkit 世代、`.rightbar`、`sidebar.right` 槽逐代回退。
+- 什么时候重算：窗口改宽、右栏开合（只盯属性的 `MutationObserver`）、右栏自身改宽（`ResizeObserver`），以及挂载后的四次延时重测（罩住右栏的滑入动画）。流式刷新不会触发几何重算。
+
+为什么是「测量」而不是「右栏内的一页」：DSH 的右栏服务确实存在（`sidebarRightTabs` / `sidebarRight`，
+见 §6.1），本插件也有完整注册代码，但在当前构建里 `openTab` 路径实测仍回落到浮层，且没定位到抛错点。
+在它修好之前，`dockRail` 是视觉上等价、失败即回退的兜底层——它盖住右栏内容区的其他面板（那些面板仍在
+下面，取消勾选或收起胶囊即恢复），也会暂时压住右栏的拖拽改宽手柄。
+
+诊断：`data-dsa-float-mode="dock"` 表示处于该形态；`.dsa-stack` 上的 `data-dsa-dock-body="<px>"` 是量到的
+宽度（与卡片宽度一致）。浮层根节点还有 `data-dsa-dock`，它的取值直接说明**为什么**没有铺满：
+
+| 值 | 含义 |
+|---|---|
+| `dock` | 正在铺满 |
+| `no-rail` | 没找到已展开的右栏（右栏关着，或这个构建的标记与预期不同） |
+| `rail-too-small` | 找到了，但宽 < 280px / 高 < 240px，或它停在帧外（折叠态被拒绝） |
+| `off` | 设置里的 `dockRail` 被关掉了 |
+| `mode` | 当前不是完整卡片形态（胶囊 / 隐藏），本来就不该铺满 |
+
 ---
 
 ## 五、侧边承载面与"侧边卡片插件"适配
@@ -210,15 +240,19 @@ bleeds = 对话区右边界 - left > 1          // 只有带宽 < 240px 时才
 
 | 顺序 | 承载面 | 依赖 | 失败时 |
 |---|---|---|---|
-| 1 | DSH 原生右侧栏 | `ctx.sidebarRightTabs`（注册 tab 类型）+ `ctx.sidebarRight`（`openTab`），并占用槽位 `sidebar.right.pane.tab` / `…tab.title` | 记 `surfaces.native.error`，落到下一层；**类型注册会回滚**（见下） |
-| 2 | **dsh-better-sidebar**（侧边卡片插件） | 客户端服务 `ctx.betterSidebar`：`registerTab` + `openTab(seed, scope)`；卡片 id 走 `tab.meta.cardId`，因此**要求其 `features` 含 `tabMeta`** | 同上（缺 `tabMeta` 时记 `no-tab-meta` 并跳过，而不是开一个空 tab） |
-| 3 | **内置浮层卡片**（默认兜底） | 只需要 `shell.overlay` 槽位 | ——（这是保底面，永远可用） |
+| 1 | **dsh-better-sidebar**（侧边卡片插件） | 客户端服务 `ctx.betterSidebar`：`registerTab` + `openTab(seed, scope)`；卡片 id 走 `tab.meta.cardId`，因此**要求其 `features` 含 `tabMeta`** | 记 `surfaces.better.error`（缺 `tabMeta` 时记 `no-tab-meta` 并跳过，而不是开一个空 tab），落到下一层 |
+| 2 | **内置浮层卡片**（兜底） | 只需要 `shell.overlay` 槽位 | ——（这是保底面，永远可用） |
+| — | DSH 原生右侧栏 | `ctx.sidebarRightTabs`（注册 tab 类型）+ `ctx.sidebarRight`（`openTab`），并占用槽位 `sidebar.right.pane.tab` / `…tab.title` | **不在 `auto` 链里**：只有显式 `sideSurface: 'native-rightbar'` 才用它；注册失败会回滚（见下） |
 
 - 装了 `dsh-better-sidebar`：卡片以它的 tab 形式出现在它的面板里，关闭卡片会同时 `closeTab`，不残留空 tab。
-- 没装：自动使用内置浮层卡片，功能完全一致——**这条路径是本插件的默认与保底路径**。
+  这是 `auto` 的**第一选择**。
+- 没装：自动使用内置浮层卡片，功能完全一致——**这条路径是第二选择，也是保底路径**。
   浮层默认是**贴帧右边缘的胶囊**（一行高，只有状态与问题首句），点击才展开成完整卡片，
   标题栏右侧的「收起 / 隐藏」可随时收回；它的宽度由 `floatPlacement` 计算，
   只会占用**对话区右侧那条预留带**，不会压住正文（细节见 §4.1）。
+- **原生右侧栏为什么退出 `auto`**：卡片被塞进右栏只是一个 tab，而这个 tab 的生命周期不归插件管——
+  卡片关闭后右栏仍留着一条读作「该卡片已关闭」的空标签，和你自己的右栏标签抢位置，
+  落点还取决于我们并不控制的宿主实现细节。它会保留成一个**强制选项**（下拉里标注「强制，不参与自动」）。
 - 强制指定了一个不可用的承载面：回退到内置浮层，并在卡片上标注「已回退」。
 
 ### 5.1 与 dsh-better-sidebar 0.22.1 的适配核对（2026-09-28）
@@ -280,7 +314,7 @@ better-sidebar 会把收到的每个 tab 描述符**镜像注册进同一个原
 | `sidecard-ask:card` | 本插件的**原生右侧栏**承载面（1.2.1 之前完全缺失） |
 | `dsh-better-sidebar:sidecard-ask:card:workbench` | 经 dsh-better-sidebar 镜像注册的承载面（独立 kind） |
 
-两者共存、均 `active: true` —— 即"同 kind 冲突"已被消除，`auto` 默认走原生右侧栏，强制 `sideSurface: better-sidebar` 仍可用。
+两者共存、均 `active: true` —— 即"同 kind 冲突"已被消除。`auto` 走的是 **dsh-better-sidebar → 内置浮层卡片**这条链（1.8.3 起原生右侧栏只在显式 `sideSurface: native-rightbar` 时使用），两个强制选项都仍可用。
 
 ### 5.3 与 DSH 桌面版（Electron）的适配核对（2026-09-30）
 
@@ -426,7 +460,7 @@ node tools/compat-probe.mjs --json tools/.cache/matrix.json
 
 | 缺口 | 适配实现 | 在真机/测试里的表现 |
 |---|---|---|
-| 0.1.2 / 0.1.3 没有原生右侧栏 | 承载面探测链：原生右侧栏 → `dsh-better-sidebar` → **内置浮层卡片**；不可用的一律不计入 `pickSurface` | `contract-test` 断言 `pickSurface('auto')` 在无插件组合下落到 `flow`；`auto` 在可用时优先原生 |
+| 0.1.2 / 0.1.3 没有原生右侧栏 | 承载面探测链：原生右侧栏 → `dsh-better-sidebar` → **内置浮层卡片**；不可用的一律不计入 `pickSurface` | `contract-test` 断言 `pickSurface('auto')` 在无插件组合下落到 `flow`、两端可用时选 `better-sidebar`；`float-placement` 钉住自动链里不出现原生右侧栏 |
 | ≤0.1.6-alpha.1 没有 `using`/`retain` | 主对话提交**四级阶梯**（调用时逐级探测，不查版本表）：`sessions.using` → `sessions.retain`+`release` → 槽位标准 prop `inputActions`（`setDraft` + `submit`）→ 仅写入输入框并明确提示"请按 Enter" | `contract-test` 逐级断言 `via`：`sessions.using` / `sessions.retain`（并断言 `release()` 被调用）/ `inputActions.submit` / `composer.draft` / 全无时抛 `no-main-carrier` |
 | ≤0.1.6-alpha.2 没有归档门 | 不再因"父会话已归档"直接拒绝：仍优先挑未归档代理，但只有归档候选时**照常尝试**，并在 `start` 事件里带 `parentArchived:true`；真被门拒绝时把空 turn 的 `refusal` 翻译成 `blocked-step` 并说明原因 | `smoke-test`：全归档组合仍能拿到答案；`refusal` 用例断言 `code=blocked-step` 且文案提到归档 |
 | 0.1.2-rc.1 没有进程内帧 | 增加**第二条流式源**：订阅 `session/event` 的持久化 `assistant/chunk`（`{turn,step,chunk}`，形状取自该版本自己的 `chunk-rows.js`），与帧源**互斥**（先说话的那个生效，绝不重复计一次文本） | `smoke-test`：`frameMode:'chunks'` 用例断言 delta 拼出完整答案、`streaming:true`、`streamSource:'chunks'`；同时断言两源并存时文本不重复 |
@@ -564,6 +598,14 @@ node tools/compat-probe.mjs --json tools/.cache/matrix.json
    **关键判据：胶囊/卡片的左边缘不得越过对话区（`[data-slot^="conversation"]`）的右边界**。
    把窗口从 1920px 拖到 900px、再开关一次右侧栏，浮层应随之变窄而不是往左压住正文；
    只有窗口窄到可用带宽不足 240px 时才允许压入（此时是设计内的降级，不是 bug）。
+9. **占满右侧栏（1.8.3，`dockRail`）**：先把右侧栏打开（任意面板，例如「团队任务板」），再追问一次 →
+   答案卡应铺满**标签条下方**的整块内容区：右边缘贴帧边、下边缘贴窗口底，右栏的标签条仍然露出可点。
+   点卡片标题栏的 ⇥（收起为胶囊）或 × → 卡片立即退出占满、回到常规浮层，右栏内容区恢复。
+   自检：F12 读浮层根节点，`data-dsa-float-mode` 应为 `dock`，`data-dsa-dock` 也应为 `dock`；
+   `.dsa-stack` 上的 `data-dsa-dock-body` 应等于卡片宽度（px）。**没铺满就看 `data-dsa-dock`**：
+   `no-rail` = 没找到右栏，`rail-too-small` = 找到了但太窄或在帧外，`off` = 开关关了，`mode` = 不是完整形态。
+   把右栏拖到 260px 宽 → 应自动回退成常规浮层（低于 280px 不铺满）；再拖回 400px → 应重新铺满。
+   设置页取消「右侧栏打开时占满它」并保存 → 同一操作不再铺满。
 
 **失败信号**：卡片停在「作答中…」不动 = SSE 帧没到达（看 console 是否有 `/sidecard-ask/api/ask` 报错）；`done.streaming=false` = 该版本没有流式帧（属预期降级，卡片会写明）。
 
@@ -604,10 +646,13 @@ node test/smoke-test.mjs        # 端到端：流式/截断/取消/持久化/失
 ```
 
 四个脚本都以 `process.exitCode` 反映结果，失败会列出具体条目；测试会把 `DSH_HOME` 指向临时目录，不会污染真实配置。
-当前规模（1.8.2 本机实测，四项均 exit 0）：verify **57** 项 + contract **972** 项 + float-placement **38** 项 +
-smoke **226** 项 = **1293 项全部通过**（1.8.1 为 1277 项，其中 contract 由 956 → 972：新增 16 项钉住提问框
-「作答位置」分段芯片——唯一 `.dsa-seg`、两个按钮、恰好一个 `aria-pressed`、各带一枚内联图标、
-品牌实底规则与深色覆盖规则；点击切换本身不可测，原因见 1.8.2 的 CHANGELOG）。
+当前规模（1.8.3 本机实测，四项均 exit 0）：verify **57** 项 + contract **989** 项 + float-placement **78** 项 +
+smoke **226** 项 = **1350 项全部通过**（1.8.2 为 1293 项：contract 972 → 989，新增 8 项钉住设置页的「占满
+右侧栏」复选框、3 个新 i18n 键，以及承载面 `auto` 的新顺序；float-placement 38 → 78，新增 40 项覆盖 `railDock` 的夹取/最小尺寸/
+`clipped` 语义、真机上 dock 没生效那次发现的三个缺陷（残留的 `rail` 变量、右栏开合不触发重算、
+右栏锚点必须优先用插件自己的 `[data-dsa-rail-host]` 节点），以及「自动链里不出现原生右侧栏」这条顺序断言）。更早的 1.8.1 为 1277 项，其中 contract
+由 956 → 972 是提问框「作答位置」分段芯片的 16 项——唯一 `.dsa-seg`、两个按钮、恰好一个
+`aria-pressed`、各带一枚内联图标、品牌实底规则与深色覆盖规则；点击切换本身不可测，原因见 1.8.2 的 CHANGELOG。
 
 **真机探针（不属于四套自测）**：`.compat-report/scripts/composer-probe.mjs` 需要
 `playwright-core` 与本机 Edge，对**真实 DSH 页面**回答 composer DOM / 哪条写入路径真能改变

package/client.js

@@ -47,7 +47,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 = '1.8.2'
+    const CLIENT_VERSION = '1.8.3'
 
     /**
      * Tab kind served by the DSH native right rail (also its implementation id).
@@ -98,6 +98,10 @@ window.__ModuleLoader__.load({
       sideProvider: 'auto',
       floatMode: 'capsule',
       floatMaxWidth: 340,
+      // Docked presentation (1.8.3): when the right rail is on screen, the
+      // answer paints inside the rail's rectangle instead of floating as a
+      // 340px card over it. See §1b `railDock`.
+      dockRail: true,
       // Mirrors the Host's DEFAULT_CONFIG.quickActions (contract-asserted):
       // `builtin:*` entries are resolved through QUICK_ACTION_BUILTINS, while
       // custom entries (no builtin prefix) carry their own label/question.
@@ -250,6 +254,163 @@ window.__ModuleLoader__.load({
       return { width, avail, capped: width < cap, bleeds: lane - left > 1 }
     }
 
+    const DOCK_MIN_WIDTH = 280
+    const DOCK_MIN_HEIGHT = 240
+
+    /**
+     * How the Client half recognizes the right rail in the live DOM, most
+     * specific generation first.
+     *
+     * The rail has no published DOM contract, so the markers were read out of
+     * the installed build (`@deepseek-ai/dsh-client-ui-sidebar-right`): its panel
+     * is a div carrying `data-sidebar-right-panel="push|fullscreen"` and, while
+     * expanded, `data-sidebar-right-open`; each session surface also carries
+     * `data-sidebar-right-session`. Two older spellings are kept behind those so
+     * a downgraded shell does not silently lose the dock: `.rightbar` (pre-rail
+     * builds) and the `sidebar.right` slot subtree. The OPEN marker matters: the
+     * panel slides off the frame while collapsed, so its rect is off-screen and
+     * must not be docked into.
+     */
+    const RAIL_SELECTORS = [
+      // The plugin's own nodes are the most reliable anchor there is: a tab body
+      // rendered by `CardHost` IS a page body, so wherever it sits is exactly
+      // where a page goes. It also works on builds whose rail markers we have
+      // never seen — including the leftover "card closed" tab, which still
+      // occupies a page body.
+      '[data-dsa-rail-host]',
+      '[data-sidebar-right-panel][data-sidebar-right-open] [data-dockkit-pane]',
+      '[data-sidebar-right-panel][data-sidebar-right-open]',
+      '[data-sidebar-right-session][data-sidebar-right-open]',
+      // Dockkit-only builds: the pane is the page body, and a build that renders
+      // no `data-sidebar-right-*` marker at all would otherwise never dock. These
+      // are last because they say "a pane exists", not "a pane is open" — the
+      // on-screen check in `findRail` is what keeps a collapsed (off-frame) rail
+      // from being docked into.
+      '[data-dockkit-pane]',
+      '[data-dockkit-column]',
+      '.rightbar',
+      '[data-slot^="sidebar.right"]',
+    ]
+
+    /**
+     * The box a tab's BODY occupies inside one rail node.
+     *
+     * The pane's tab strip sits at the top of the same box, so a raw pane rect
+     * would make the card cover the rail's own tabs. The strip's bottom edge is
+     * measured instead (every tab carries `data-dockkit-tab`), which keeps the
+     * rail navigable and places the card exactly where a page's content goes.
+     * Without any tab to measure, the node's own top edge is the answer.
+     */
+    function dockedBodyRect(node) {
+      const rect = node.getBoundingClientRect()
+      let top = rect.top
+      const pane = typeof node.closest === 'function' ? node.closest('[data-dockkit-pane]') : null
+      const tabs = pane !== null && typeof pane.querySelectorAll === 'function'
+        ? pane.querySelectorAll('[data-dockkit-tab]')
+        : null
+      if (tabs !== null) {
+        for (const tab of tabs) {
+          if (typeof tab.getBoundingClientRect !== 'function') continue
+          const tabRect = tab.getBoundingClientRect()
+          if (Number.isFinite(tabRect.bottom) && tabRect.bottom > top) top = tabRect.bottom
+        }
+      }
+      return { left: rect.left, top, width: rect.width, height: rect.bottom - top }
+    }
+
+    /**
+     * Whether a measured rail box is actually on screen.
+     *
+     * The collapsed rail is animated off the frame (its rect sits past the right
+     * edge, or is zero-sized), so "an element matched" is not the same as "the
+     * user can see it". A box that starts outside the frame or is thinner than
+     * the minimum is rejected here rather than clamped into view by `railDock`.
+     */
+    function railOnScreen(box) {
+      if (box === null || box === undefined) return false
+      const frameW = Number.isFinite(document.documentElement?.clientWidth)
+        ? document.documentElement.clientWidth
+        : (typeof window.innerWidth === 'number' ? window.innerWidth : 0)
+      const frameH = Number.isFinite(document.documentElement?.clientHeight)
+        ? document.documentElement.clientHeight
+        : (typeof window.innerHeight === 'number' ? window.innerHeight : 0)
+      if (!Number.isFinite(box.left) || !Number.isFinite(box.top)) return false
+      if (box.width < DOCK_MIN_WIDTH || box.height < DOCK_MIN_HEIGHT) return false
+      // `left >= frameW` is the collapsed-rail case (parked past the edge); a
+      // negative left with a visible body is a rail mid-animation and is fine.
+      if (box.left >= frameW - 1) return false
+      if (box.top >= frameH - 1) return false
+      return true
+    }
+
+    /**
+     * The on-screen rail's dockable box, plus the node it was measured from.
+     *
+     * Every candidate is measured before it is accepted: a hidden or zero-sized
+     * node (a collapsed rail, a slot wrapper that only holds styles) is skipped
+     * instead of being treated as a 0x0 rail. The node is returned because the
+     * caller keeps a ResizeObserver pointed at whatever it accepted — the rail is
+     * re-rendered (new node) on some open/close transitions.
+     *
+     * @returns {{node: Element, box: {left: number, top: number, width: number, height: number}}|null}
+     */
+    function findRail(scope) {
+      if (scope === null || scope === undefined || typeof scope.querySelector !== 'function') return null
+      for (const selector of RAIL_SELECTORS) {
+        let node = null
+        try { node = scope.querySelector(selector) } catch { node = null }
+        if (node === null || typeof node.getBoundingClientRect !== 'function') continue
+        let box = null
+        try { box = dockedBodyRect(node) } catch { box = null }
+        if (railOnScreen(box)) return { node, box }
+      }
+      return null
+    }
+
+    /**
+     * The rectangle a side card occupies when the right rail is on screen.
+     *
+     * Pure (no DOM) so the runtime and the tests share one implementation: the
+     * caller passes the rail's measured box. `null` means "do not dock" — the
+     * rail is missing, unmeasurable, or too small to be worth a page, and the
+     * caller keeps the floating presentation instead.
+     *
+     * Nothing is ever allowed to spill outside the frame: the rectangle is
+     * clamped to `[0, frameWidth] × [0, frameHeight]` and `clipped` reports
+     * whether that clamp actually bit (a rail straddling the frame edge).
+     *
+     * @param {{railLeft: number, railTop: number, railWidth: number, railHeight: number,
+     *   frameWidth?: number|null, frameHeight?: number|null, enabled?: boolean}} input
+     * @returns {{left: number, top: number, width: number, height: number,
+     *   clipped: boolean}|null}
+     */
+    function railDock({ railLeft, railTop, railWidth, railHeight, frameWidth = null, frameHeight = null, enabled = true }) {
+      if (enabled !== true) return null
+      if (!Number.isFinite(railLeft) || !Number.isFinite(railTop)) return null
+      const width = Number.isFinite(railWidth) ? Math.floor(railWidth) : 0
+      const height = Number.isFinite(railHeight) ? Math.floor(railHeight) : 0
+      if (width < DOCK_MIN_WIDTH || height < DOCK_MIN_HEIGHT) return null
+      const frameW = Number.isFinite(frameWidth) ? frameWidth : railLeft + width
+      const frameH = Number.isFinite(frameHeight) ? frameHeight : railTop + height
+      const left = Math.max(0, Math.min(Math.floor(railLeft), Math.floor(frameW)))
+      const top = Math.max(0, Math.min(Math.floor(railTop), Math.floor(frameH)))
+      const dockWidth = Math.max(0, Math.min(width, Math.floor(frameW - left)))
+      const dockHeight = Math.max(0, Math.min(height, Math.floor(frameH - top)))
+      if (dockWidth < DOCK_MIN_WIDTH || dockHeight < DOCK_MIN_HEIGHT) return null
+      // `clipped` means "what was painted is not what was measured": either the
+      // size shrank, or the origin had to be pulled back inside the frame (a rail
+      // still animating in can measure negative). Callers surface it so a
+      // surprising rectangle is explainable instead of mysterious.
+      return {
+        left,
+        top,
+        width: dockWidth,
+        height: dockHeight,
+        clipped: dockWidth < width || dockHeight < height
+          || left !== Math.floor(railLeft) || top !== Math.floor(railTop),
+      }
+    }
+
     // ─────────────────────────────────────────────────────────────────────
     // §2 i18n
     // ─────────────────────────────────────────────────────────────────────
@@ -327,8 +488,9 @@ window.__ModuleLoader__.load({
         setTriggerBoth: '按钮 + 快捷键',
         setCarrier: '默认作答位置',
         setSurface: '侧边卡片承载面',
-        setSurfaceAuto: '自动选择',
+        setSurfaceAuto: '自动选择（插件 → 内置卡片）',
         setSurfaceFlow: '内置浮层卡片',
+        surfaceNativeForce: '右侧栏卡片（强制，不参与自动）',
         setMaxChars: '最大字符数',
         setMaxCharsHint: '超过部分截断并在提问中标注',
         setFloatMode: '浮层默认形态',
@@ -338,6 +500,9 @@ window.__ModuleLoader__.load({
         setFloatModeHint: '浮层贴右侧边缘，只在空间不足时才可能压到对话区',
         setFloatMaxWidth: '浮层宽度上限（px）',
         setFloatMaxWidthHint: '空间不足时自动收窄，不会硬顶',
+        setDockRail: '右侧栏打开时占满它',
+        setDockRailHint: '答案直接铺满右侧栏（读得像栏内的一页），收起为胶囊或关闭即恢复原状；右侧栏不在时不生效',
+        floatDocked: '已占满右侧栏',
         floatExpand: '展开侧边卡片',
         floatCollapse: '收起为胶囊（不遮挡对话）',
         floatHide: '隐藏浮层（只留小圆点）',
@@ -564,8 +729,9 @@ window.__ModuleLoader__.load({
         setTriggerBoth: 'Button + shortcut',
         setCarrier: 'Default answer carrier',
         setSurface: 'Side-card surface',
-        setSurfaceAuto: 'Automatic',
+        setSurfaceAuto: 'Automatic (plugin, then built-in)',
         setSurfaceFlow: 'Built-in floating card',
+        surfaceNativeForce: 'Right rail (forced, excluded from automatic)',
         setMaxChars: 'Max characters',
         setMaxCharsHint: 'Longer selections are truncated and marked in the question',
         setFloatMode: 'Floating layer default',
@@ -575,6 +741,9 @@ window.__ModuleLoader__.load({
         setFloatModeHint: 'The layer is anchored to the right edge and only overlaps on very narrow frames',
         setFloatMaxWidth: 'Floating layer max width (px)',
         setFloatMaxWidthHint: 'Narrows automatically when there is not enough room',
+        setDockRail: 'Fill the right rail while it is open',
+        setDockRailHint: 'The answer fills the right rail (it reads as one of its pages) and comes back to normal when collapsed to the capsule or closed; ignored while no rail is on screen',
+        floatDocked: 'Filled the right rail',
         floatExpand: 'Expand the side cards',
         floatCollapse: 'Collapse to a capsule (stops covering the conversation)',
         floatHide: 'Hide the layer (leaves a small launcher)',
@@ -1839,12 +2008,20 @@ window.__ModuleLoader__.load({
      * @returns {{adapter: object, fellBack: boolean}}
      */
     function pickSurface(wanted) {
-      const order = [surfaces.native, surfaces.better, surfaces.flow]
+      // `auto` deliberately skips the shipped right rail. A card re-hosted as a
+      // rail tab is a tab the plugin does not own: it outlives the card (the
+      // rail keeps an empty tab reading "this card was closed"), it competes
+      // with the user's own rail tabs, and where it lands depends on a
+      // service-surface detail we do not control. The order asked for is: the
+      // side-card plugin first, the built-in card second. The rail stays
+      // reachable, but only by an explicit `native-rightbar` choice.
+      const autoOrder = [surfaces.better, surfaces.flow]
+      const all = [surfaces.native, surfaces.better, surfaces.flow]
       if (wanted === 'auto' || wanted === undefined) {
-        for (const adapter of order) if (adapter.available()) return { adapter, fellBack: false }
+        for (const adapter of autoOrder) if (adapter.available()) return { adapter, fellBack: false }
         return { adapter: surfaces.flow, fellBack: false }
       }
-      const match = order.find(adapter => adapter.kind === wanted || adapter === surfaces[wanted])
+      const match = all.find(adapter => adapter.kind === wanted || adapter === surfaces[wanted])
       if (match === undefined) return { adapter: surfaces.flow, fellBack: true }
       if (!match.available()) return { adapter: surfaces.flow, fellBack: true }
       return { adapter: match, fellBack: false }
@@ -1919,13 +2096,18 @@ window.__ModuleLoader__.load({
    trigger drops its own fixed positioning, chips join the row directly. */
 .dsa-trigger-embedded{position:static;box-shadow:0 2px 10px rgba(0,0,0,.18)}
 .dsa-quickbar-chips{display:contents}
-/* Contrast pass, driven by a light-theme reference screenshot: every 1px edge
-   inside the popover measured only ≈1.3–1.7:1 against the card surface, which
-   is why the card read as a translucent sticker instead of a framed popover.
-   The frame is therefore drawn explicitly here rather than through border-l2,
-   which the host resolves below that level; mid grey is used instead of a
-   black/white alpha so the stroke stays visible on both themes. The shadow is
-   a two-layer falloff so the card lifts off the page as well. */
+/* Contrast pass on the popover frame. Measured against the card surface with the
+   bundled skin's tokens (bg-base .55 over white → bg-overlay .98): the inner 1px
+   edges drawn with border-l1 sit at ≈1.40:1, which is why the card read as a
+   translucent sticker rather than a framed popover. The outer frame drawn with
+   border-l2 was already ≈1.95:1 (light) / ≈2.88:1 (dark), so swapping it for mid
+   grey is a *hue* choice, not a contrast gain: mid grey .55 measures ≈1.96:1
+   light / ≈2.12:1 dark — neutral instead of blue-on-blue, and slightly weaker in
+   dark. Explicit mid grey is still used over border-l2 because the host may
+   resolve that alias to the surrounding fill; if a genuinely stronger frame is
+   wanted, grey .85 measures ≈3.03:1. The two-layer shadow is what lifts the card
+   off the page; secondary text inside the popover uses label-primary (6.11:1)
+   rather than label-secondary. */
 .dsa-pop{pointer-events:auto;position:fixed;width:min(420px, 92vw);display:flex;flex-direction:column;gap:8px;
   padding:12px;border-radius:12px;border:1px solid rgba(127,127,127,.55);
   background:var(--dsw-alias-bg-overlay, #fff);color:var(--dsw-alias-label-primary, #111);
@@ -1990,6 +2172,12 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"],
 html[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover,
 body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
   color:#0a1428;text-shadow:0 1px 0 rgba(255,255,255,.25)}
+/* The same switch is reused on the settings page, inside a grid cell that can be
+   narrower than the popover: tighten the chips there, never let the pair spill out
+   of its cell, and keep the rail hugging the chips (dsa-field is a stretch
+   column, which would otherwise paint a 400px-wide rail around two small chips). */
+.dsa-field .dsa-seg{max-width:100%;align-self:flex-start}
+.dsa-field .dsa-seg button{padding:4px 10px}
 .dsa-card{pointer-events:auto;display:flex;flex-direction:column;gap:8px;padding:12px;border-radius:12px;
   border:1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.35));
   background:var(--dsw-alias-bg-overlay, #fff);color:var(--dsw-alias-label-primary, #111);
@@ -2001,6 +2189,19 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
 .dsa-float{pointer-events:none;position:fixed;right:var(--dsa-gap-right, 8px);bottom:16px;
   display:flex;flex-direction:column;gap:8px;width:var(--dsa-float-w, 340px);max-width:92vw}
 .dsa-float > *{pointer-events:auto}
+/* Docked presentation (1.8.3): the same container, but pinned to the right
+   rail's measured rectangle (inline left/top/width/height) instead of the
+   frame's bottom-right corner. Right/bottom must be released, otherwise the
+   base rule's right:8px/bottom:16px would over-constrain the box. The rail's
+   resize handle is covered while docked — collapsing to the capsule (⇥) or
+   closing gives it back. */
+.dsa-float[data-dsa-float-mode="dock"]{right:auto;bottom:auto;max-width:none;pointer-events:auto;
+  border-left:1px solid var(--dsw-alias-border-l2, rgba(127,127,127,.35));
+  background:var(--dsw-alias-bg-overlay, #fff);overflow:hidden}
+.dsa-float[data-dsa-float-mode="dock"] .dsa-stack{max-height:none;height:100%;min-height:0;overflow:hidden}
+.dsa-float[data-dsa-float-mode="dock"] .dsa-card{height:100%;min-height:0;max-height:none;border:0;border-radius:0;
+  box-shadow:none;background:transparent;padding:10px 12px 8px}
+.dsa-float[data-dsa-float-mode="dock"] .dsa-answer{max-height:none;flex:1 1 auto;min-height:0;overflow:auto}
 .dsa-stack{display:flex;flex-direction:column;gap:8px;max-height:52vh;overflow:auto}
 .dsa-capsule{display:flex;align-items:center;gap:8px;width:100%;box-sizing:border-box;text-align:left;
   padding:8px 12px;border-radius:999px;cursor:pointer;font:inherit;font-size:12px;line-height:18px;
@@ -3818,11 +4019,14 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
      */
     function FloatingLayer({ cards, actions }) {
       const containerRef = React.useRef(null)
+      const dockRef = React.useRef(null)
       const state = useStoreState()
+      const [dock, setDock] = React.useState(null)
       const visible = cards.filter(card => card.surface === 'flow' && card.open)
       const total = visible.length
       const mode = state.floatMode ?? state.config.floatMode ?? CLIENT_DEFAULTS.floatMode
       const maxWidth = state.config.floatMaxWidth ?? CLIENT_DEFAULTS.floatMaxWidth
+      const dockWanted = state.config.dockRail !== false
 
       // Measure the conversation column + right rail, then pin the layer's
       // width to what is left. Recomputed on frame resize and on rail toggles
@@ -3833,6 +4037,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
         const node = containerRef.current
         if (node === null || node === undefined) return undefined
         const selector = '[data-slot^="conversation"], .rightbar, [data-slot^="sidebar.right"], [data-dsh-panel-host]'
+        const observed = new Set()
         const all = () => {
           try {
             return typeof document.querySelectorAll === 'function'
@@ -3844,20 +4049,73 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           try { return typeof document.querySelector === 'function' ? document.querySelector(query) : null } catch { return null }
         }
         let frame = 0
+        let observer = null
+        let mutation = null
+        let observedRail = null
+        const timers = []
         const apply = () => {
           if (typeof node.style?.setProperty !== 'function') return
           const lane = one('[data-slot^="conversation"]')
-          const rail = one('.rightbar, [data-slot^="sidebar.right"], [data-dsh-panel-host]')
           const rootWidth = document.documentElement?.clientWidth ?? window.innerWidth
-          const laneRight = lane === null
-            ? rootWidth
-            : lane.getBoundingClientRect().right
-          const railLeft = rail === null ? null : rail.getBoundingClientRect().left
+          const rootHeight = document.documentElement?.clientHeight ?? window.innerHeight
+          const measure = target => {
+            if (target === null || target === undefined) return null
+            try {
+              const rect = typeof target.getBoundingClientRect === 'function'
+                ? target.getBoundingClientRect()
+                : null
+              return rect === null ? null : rect
+            } catch { return null }
+          }
+          const laneRect = measure(lane)
+          const rail = findRail(document)
+          const railBox = rail === null ? null : rail.box
+          const laneRight = laneRect === null ? rootWidth : laneRect.right
+          const railLeft = railBox === null ? null : railBox.left
           const placement = floatPlacement({ frameWidth: rootWidth, laneRight, railLeft, maxWidth })
           node.style.setProperty('--dsa-float-w', `${placement.width}px`)
           node.style.setProperty('--dsa-gap-right', `${FLOAT_GAP_RIGHT}px`)
           // Readable placement, so a user report can say WHERE the layer sat.
           node.dataset.layerWidth = String(placement.width)
+
+          // Docked presentation: the card fills the rail page's body instead of
+          // floating over it. Only measured in `full` mode — a capsule/launcher
+          // is deliberately small and must never take the rail over.
+          const next = railBox === null || mode !== 'full'
+            ? null
+            : railDock({
+              railLeft: railBox.left,
+              railTop: railBox.top,
+              railWidth: railBox.width,
+              railHeight: railBox.height,
+              frameWidth: rootWidth,
+              frameHeight: rootHeight,
+              enabled: dockWanted,
+            })
+          const prev = dockRef.current
+          const same = prev === next || (prev !== null && next !== null
+            && prev.left === next.left && prev.top === next.top
+            && prev.width === next.width && prev.height === next.height
+            && prev.clipped === next.clipped)
+          if (!same) {
+            dockRef.current = next
+            setDock(next)
+          }
+          // Why the layer is (not) docked, readable from DevTools. A rail that
+          // exists but is too narrow reads as `rail-too-small`, which is a
+          // different story from `no-rail` and is what a bug report needs.
+          node.dataset.dsaDock = next !== null
+            ? 'dock'
+            : (mode !== 'full'
+              ? 'mode'
+              : (dockWanted ? (railBox === null ? 'no-rail' : 'rail-too-small') : 'off'))
+          // The rail can appear AFTER this effect ran (opening it mounts new
+          // nodes), and it can be re-created later: keep the observer pointed at
+          // whichever node is currently accepted.
+          if (observer !== null && rail !== null && rail.node !== observedRail) {
+            observedRail = rail.node
+            try { observer.observe(rail.node) } catch { /* not observable */ }
+          }
         }
         const schedule = () => {
           if (typeof window.requestAnimationFrame !== 'function') { apply(); return }
@@ -3868,7 +4126,6 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           })
         }
         apply()
-        let observer = null
         if (typeof window.ResizeObserver === 'function') {
           observer = new window.ResizeObserver(schedule)
           for (const target of all()) {
@@ -3876,12 +4133,35 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           }
         }
         if (typeof window.addEventListener === 'function') window.addEventListener('resize', schedule)
+        // Opening/closing the rail changes no size this effect already watches,
+        // so the DOM itself has to be the trigger. Attributes only (no
+        // childList): streaming tokens rewrite text nodes continuously and must
+        // not wake the layer on every frame.
+        if (typeof window.MutationObserver === 'function' && document.body !== null && document.body !== undefined) {
+          try {
+            mutation = new window.MutationObserver(schedule)
+            mutation.observe(document.body, {
+              attributes: true,
+              subtree: true,
+              attributeFilter: ['data-sidebar-right-open', 'data-dockkit-pane-active', 'style', 'class'],
+            })
+          } catch { mutation = null }
+        }
+        // The rail slides in; a rect taken mid-animation is wrong. Re-measure a
+        // few times right after a card/mode change, then stop for good.
+        if (typeof window.setTimeout === 'function') {
+          for (const delay of [80, 200, 420, 800]) timers.push(window.setTimeout(schedule, delay))
+        }
         return () => {
           if (typeof window.removeEventListener === 'function') window.removeEventListener('resize', schedule)
           if (observer !== null) { try { observer.disconnect() } catch { /* already gone */ } }
+          if (mutation !== null) { try { mutation.disconnect() } catch { /* already gone */ } }
+          for (const timer of timers) {
+            if (typeof window.clearTimeout === 'function') window.clearTimeout(timer)
+          }
           if (frame !== 0 && typeof window.cancelAnimationFrame === 'function') window.cancelAnimationFrame(frame)
         }
-      }, [maxWidth, total, mode])
+      }, [maxWidth, total, mode, dockWanted])
 
       if (total === 0) return null
 
@@ -3894,13 +4174,47 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
         : t('floatDone', { n: total })
       const firstQuestion = visible[0].question
 
+      // Docked geometry is only meaningful in `full` mode; the effect nulls it
+      // out otherwise, and this guard keeps a stale rect from a previous mode
+      // from being painted for one frame.
+      const docked = mode === 'full' && dock !== null
+
       const container = children => h('div', {
-        className: 'dsa-float',
+        className: docked ? 'dsa-float dsa-dock' : 'dsa-float',
         'data-dsa-root': '',
         ref: containerRef,
-        'data-dsa-float-mode': mode,
+        'data-dsa-float-mode': docked ? 'dock' : mode,
+        ...(docked
+          ? {
+            style: {
+              left: `${dock.left}px`,
+              top: `${dock.top}px`,
+              width: `${dock.width}px`,
+              height: `${dock.height}px`,
+            },
+          }
+          : null),
       }, children)
 
+      const cardNodes = visible.map(card => h(AnswerCard, {
+        key: card.id,
+        card,
+        surfaceLabel: null,
+        onCopy: element => actions.copy(card, element),
+        onFollowUp: text => actions.followUp(card, text),
+        onRetry: () => actions.retry(card),
+        onRetryEdit: text => actions.retryEdit(card, text),
+        onCancel: () => actions.cancel(card),
+        onSendToMain: () => actions.sendToMain(card),
+        onClose: () => actions.close(card),
+        onLocate: target => actions.locateCard(target ?? card),
+        onExport: target => actions.exportCard(target ?? card),
+        onInsert: target => actions.insertAnswer(target ?? card),
+        onReplace: target => actions.insertAnswer(target ?? card, { replace: true }),
+        onViewVersion: index => actions.viewVersion(card, index),
+        onFloatMode: setFloatMode,
+      }))
+
       if (mode === 'off') {
         return container(h('button', {
           type: 'button',
@@ -3921,25 +4235,14 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
         h('span', { className: 'dsa-capsule-chev' }, '›')))
       }
 
-      return container(h('div', { className: 'dsa-stack' },
-        visible.map(card => h(AnswerCard, {
-          key: card.id,
-          card,
-          surfaceLabel: null,
-          onCopy: element => actions.copy(card, element),
-          onFollowUp: text => actions.followUp(card, text),
-          onRetry: () => actions.retry(card),
-          onRetryEdit: text => actions.retryEdit(card, text),
-          onCancel: () => actions.cancel(card),
-          onSendToMain: () => actions.sendToMain(card),
-          onClose: () => actions.close(card),
-          onLocate: target => actions.locateCard(target ?? card),
-          onExport: target => actions.exportCard(target ?? card),
-          onInsert: target => actions.insertAnswer(target ?? card),
-          onReplace: target => actions.insertAnswer(target ?? card, { replace: true }),
-          onViewVersion: index => actions.viewVersion(card, index),
-          onFloatMode: setFloatMode,
-        }))))
+      // Docked: the card takes the rail's whole rectangle, so it reads as one of
+      // the rail's pages rather than a 340px card hovering over it. The card
+      // keeps its own header (title + badges + collapse/hide controls), which is
+      // what makes the page dismissible without leaving the rail.
+      return container(h('div', {
+        className: 'dsa-stack',
+        'data-dsa-dock-body': docked ? String(dock.width) : undefined,
+      }, cardNodes))
     }
 
     /** The `shell.overlay` entry: styles + trigger + popover + cards + toast. */
@@ -4016,7 +4319,10 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
         else toast(t('notifyGranted'))
       }
 
-      const field = (label, control, hint) => h('div', { className: 'dsa-field' },
+      // `style` is optional: the two-chip carrier switch needs two grid tracks
+      // (`.dsa-grid` fits columns down to 150px, and two nowrap chips need
+      // ~175px), so that field spans two tracks instead of overflowing.
+      const field = (label, control, hint, style) => h('div', { className: 'dsa-field', style },
         h('label', null, label),
         control,
         hint !== undefined ? h('span', { className: 'dsa-muted' }, hint) : null)
@@ -4247,6 +4553,8 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           ? h('div', { className: 'dsa-family-notice', role: 'status' }, t('familyLegacyToast'))
           : null)
 
+      // NOT marked `data-dsa-rail-host`: the settings page is not a rail page,
+      // and marking it would let the floating layer dock over the settings panel.
       return h('div', { className: 'dsa-settings', 'data-dsa-root': '' },
         h(Styles, null),
         h('div', null,
@@ -4259,15 +4567,15 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             ['shortcut', t('setTriggerShortcut')],
             ['both', t('setTriggerBoth')],
           ])),
-          field(t('setCarrier'), select('defaultCarrier', [
-            ['side', t('carrierSide')],
-            ['main', t('carrierMain')],
-          ])),
+          field(t('setCarrier'), h(CarrierSeg, {
+            value: draft.defaultCarrier,
+            onChange: id => setDraft({ ...draft, defaultCarrier: id }),
+          }), undefined, { gridColumn: 'span 2' }),
           field(t('setSurface'), select('sideSurface', [
             ['auto', t('setSurfaceAuto')],
-            ['flow', t('setSurfaceFlow')],
-            ['native-rightbar', t('surfaceNative')],
             ['better-sidebar', t('surfaceBetter')],
+            ['flow', t('setSurfaceFlow')],
+            ['native-rightbar', t('surfaceNativeForce')],
           ])),
           field(t('setZones'), select('captureZones', [
             ['auto', t('setZonesAuto')],
@@ -4347,6 +4655,14 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           }),
           t('setFollowUps')),
         h('span', { className: 'dsa-muted' }, t('setFollowUpsHint')),
+        h('label', { className: 'dsa-check' },
+          h('input', {
+            type: 'checkbox',
+            checked: draft.dockRail !== false,
+            onChange: event => setDraft({ ...draft, dockRail: event.target.checked }),
+          }),
+          t('setDockRail')),
+        h('span', { className: 'dsa-muted' }, t('setDockRailHint')),
         historySection,
         h('div', { className: 'dsa-row' },
           h('button', {
@@ -5774,7 +6090,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             }
           }, [cardId])
           if (card === undefined) {
-            return h('div', { className: 'dsa-settings', 'data-dsa-root': '' },
+            return h('div', { className: 'dsa-settings', 'data-dsa-root': '', 'data-dsa-rail-host': '' },
               h(Styles, null),
               h('div', { className: 'dsa-muted' }, t('cardClosed')))
           }
@@ -5785,11 +6101,11 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             // note for a rail that keeps it.
             try { surfaces.native.close(card) } catch { /* the rail owns its lifecycle */ }
             try { surfaces.better.close(card) } catch { /* the host may already be gone */ }
-            return h('div', { className: 'dsa-settings', 'data-dsa-root': '' },
+            return h('div', { className: 'dsa-settings', 'data-dsa-root': '', 'data-dsa-rail-host': '' },
               h(Styles, null),
               h('div', { className: 'dsa-muted' }, t('cardMovedToFlow')))
           }
-          return h('div', { className: 'dsa-settings', 'data-dsa-root': '', style: { padding: '10px' } },
+          return h('div', { className: 'dsa-settings', 'data-dsa-root': '', 'data-dsa-rail-host': '', style: { padding: '10px' } },
             h(Styles, null),
             h(AnswerCard, {
               card,
@@ -5967,6 +6283,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           renderRichText,
           pickSurface,
           floatPlacement,
+          railDock,
           compareVersions,
           electFamilyLeader,
           findLegacyLayers,

package/index.js

@@ -42,7 +42,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 = '1.8.2'
+export const PLUGIN_VERSION = '1.8.3'
 
 /** Route prefix of the plugin's own API. */
 export const ROUTE_PREFIX = '/sidecard-ask/api'
@@ -83,6 +83,17 @@ export const DEFAULT_CONFIG = {
   floatMode: 'capsule',
   /** Hard cap, in CSS px, for the floating layer's width. */
   floatMaxWidth: 340,
+  /**
+   * Dock the answer card into the right rail when one is on screen, so the
+   * answer gets the whole rail instead of a 340px card floating over it.
+   *
+   * The rail exposes no "add a page" API to plugins on this DSH build (the
+   * `sidebarRightTabs` service is absent; see README §6), so the Client half
+   * measures the rail's rectangle and paints the card inside it. Turning this
+   * off restores the pure floating behaviour; with no rail on screen the
+   * floating layer is used either way.
+   */
+  dockRail: true,
   /**
    * One-click quick actions rendered beside the selection trigger.
    *
@@ -403,7 +414,7 @@ export function sanitizeLayer(raw, problems = []) {
     if (points >= 0 && points <= MAX_CUSTOM_PERSONA_CHARS) out.customPersona = raw.customPersona
     else problems.push(`customPersona: 必须是 ≤${MAX_CUSTOM_PERSONA_CHARS} 字符的字符串，已忽略`)
   }
-  for (const boolKey of ['showInUnclassified', 'notifyOnDone', 'contextMenu', 'followUpSuggestions']) {
+  for (const boolKey of ['showInUnclassified', 'notifyOnDone', 'contextMenu', 'followUpSuggestions', 'dockRail']) {
     if (raw[boolKey] === undefined) continue
     if (typeof raw[boolKey] === 'boolean') out[boolKey] = raw[boolKey]
     else problems.push(`${boolKey}: 必须是布尔值，已忽略`)

package/package.json

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