dsh-url-router 0.1.2 → 0.3.0

package/AGENTS.md

@@ -13,6 +13,12 @@
 
 - **本插件是地址栏的唯一写者**。任何其它写 fragment 的插件都不得同时启用（`dsh-session-url` 就是这样一个插件）。
 - **段位**：`#/session/<id>`（会话，`uiWorkspace.openSession`）、`#/panel/<panelId>`（主面板，`ctx.layout.selectPanel`）。输入侧接受复数与百分号编码，规范化成单数形式；**不认识的段位一律不碰**，只留一条诊断。
+- **轮次归属必须可证明** ✓：助手行自带轮次 ✓；工具行只有调用 id ✗ → 靠 `[data-turn-start]`（值 = 轮号 ✓）反推 ✓，**但只有"行之前和之后各有一个已渲染边界"时才写** ✓（`turn/<n>/row/…` ✓）。虚拟化下边界常常只渲染一侧 ✗ → 那就**不写轮次** ✓（绝不猜 ✗）。假 DOM 的 `compareDocumentPosition` 用"根的后代序号"实现 ✓（不要用 `ownerDocument` ✗，假件没有 ✓）。
+- **行级路线**：`#/session/<id>/row/<类>/<作用域>/<id>` ✓（身份 = `data-trajectory-row-key` ✓，值是 `%00` 分隔的三元组 ✓ → 拆成路径段 ✓）；家系视图的 `data-dshts-turn`（轮号 ✓）按 `turn/<n>` 写 ✓。**点击处理器必须"行优先"** ✓：轨迹行本身就是按钮 ✓，而处理器开头的 `closest([data-chat-turn])` 会直接把非轮次元素挡掉 ✓（历史 bug ✓）。反映**纯被动** ✓（不 preventDefault ✓）。驱动 = 尽力 `scrollIntoView` ✓（虚拟化未渲染的行**不假装** ✓，返回 false ✓）。canonical 里位置的优先级 **行 > 视图 > 轮次** ✓。
+- **会话视图路线**：`#/session/<id>/view/<viewId>`（有工作区时跟在会话 id 之后 ✓）。**`uiConversation` 服务在根插件里读不到** ✗（实测 `ctx.get('uiConversation')` = undefined ✓，它是会话作用域内的 ✓）—— **视图 id 从槽位读** ✓：`ctx.slots.entries('conversation.view')` 的 `options.id` ✓，按 `options.order` 排序 ✓（chat=0 / trajectory=10 / surface=20 / plus2=21 ✓）。头部页签容器是 **`[data-conversation-tabs]`** ✓、页签是 `button[role="tab"][aria-selected]` ✓（**没有 id 写在 DOM 里** ✗）→ **位置↔注册顺序** 对齐出 id ✓。默认视图（第一个 ✓）不写进链接 ✓。
+- **视图驱动必须排在工作区/会话分支之前** ✓，否则那两条会先 `return` 把它吞掉 ✓（历史 bug ✓）；且**不能被 `source === 'hash'` 挡住** ✓（粘贴视图链接就是要切过去 ✓）。
+- **工作区路线**：`#/workspace/<工作区名>/session/<会话id>`（侧栏形状 ✓）。工作区行是 `data-row-key="workspace:<uuid>"` ✓、**行文本就是工作区名** ✓（无 `data-workspace-*` ✗，实测 ✓）；会话所属工作区 = 树里**它之前最近的那个 workspace 行** ✓（`workspaceNameOf()` ✓，行锚点与反映共用 ✓）。名字是**装饰** ✓：`sameRoute` 对 workspace 路线只比**会话 id** ✓（名字过期也能落地 ✓）；读不到工作区行就退回 `#/session/<id>` ✓（不猜 ✓）。
+- **行锚点的 href 也要带工作区** ✓（右键"复制链接"直接给出带归属的链接 ✓）。
 - **作用域由视图决定，不靠猜**：主面板是应用级界面（列的是本机插件，不是某个对话），所以它的链接**不带**会话 id；只有会话级视图才写会话。
 - **一个 boot 的权威窗口（8 秒）**：链接在窗口内压过两边各自的 localStorage 恢复，窗口过后视图重新拥有地址栏。
 - **绝不抛错**：官方 `selectPanel` 对未注册的面板 id 是**抛异常**的，所有宿主面调用都必须被容纳（`attempt`/`guard`），失败只留一条诊断并回落到屏幕上真实的视图。
@@ -31,6 +37,22 @@
 - **观察者的 `attributeFilter` 必须列全所有已发布的页面钩子**：只列 `data-plugin-detail` 曾让任务看板的重试通知饿死（历史 bug，别删名单项）。
 - **未落地的链接要有定时重试**（`LINK_RETRY_MS` = 500ms）：只靠 DOM 通知不够，启动后界面会安静下来，一次被吞掉的重试就永远不来了。
 - **切换主面板前先 `beginNavigation()`**（`ctx.layout` 的配套动作，可选面，缺失即跳过）。
+- **设置面板是覆盖层**：`#/settings` ✓（裸段位 ✓，`ROUTE_PATTERN` 支持 `#/<kind>` ✓）与 `#/settings/<分区>` ✓。反映读 `[data-dsh-surface="settings"]` ✓；驱动点 `[data-slot="sidebar.settings"]` 的入口 ✓（兜底按可访问名 ✓）。
+- **设置分区的身份 = 显示名**（实测无稳定 id ✗：导航项只有 `aria-current="true"` ✓，无 `id`/`data-*`/`aria-controls` ✗，右侧内容区无 `data-*` ✗）。反映：在覆盖层里找 `aria-current="true"` **且 `closest('nav') !== null`** 的按钮 ✓，取它的标签文字 ✓；驱动：按标签（先精确、再忽略大小写）点 ✓。**换语言/改文案会让旧分区链接失效** ✗（重新点一次即写出新链接 ✓）。
+- **设置分区里的页签同理，再深一层** ✓：`#/settings/<分区>/<页签>`。契约是标准 ARIA ✓：`[role="tab"][aria-selected="true"]` ✓（实测 `dsh-usage` 的用量/个人套餐/Token 银行就是 `role="tab"` ✓），身份同样是**标签文字** ✓；驱动=先点分区、再点标签匹配的页签 ✓（同一次调用里做完 ✓，因为分区一点开，页签就在同一个覆盖层里 ✓）。
+- **`aria-selected` 也必须观察** ✓（与 `aria-current` 同理：切换页签只改它 ✓）。
+- **设置链接按"前缀"落地** ✓：裸 → 分区 → 页签逐级 ✓；命名了页签的链接必须看到那个页签 ✓，只命名到分区的链接被该分区任意页签满足 ✓。
+- **`aria-current` 必须在 DOM 观察者的 `attributeFilter` 里** ✓：切换分区只改这一个属性 ✓，漏了它地址栏就永远停在第一次看到的分区（历史 bug ✓）。
+- **裸 `#/settings` 立即可落地**（`sameRoute` 的定向例外 ✓）：分区是那个表面的细化、不是另一个表面 ✓；但**两个命名分区之间仍然算不同** ✓（否则分区链接就不驱动了 ✓）。
+- **轮次锚点是"位置"，只做反映**：点击聊天里的一轮（`[data-chat-turn]` ✓）把轮号写进地址栏 ✓；**绝不 preventDefault** ✗、**绝不碰交互元素**（button/a/input/textarea/select/[role=button]/[contenteditable] ✓ —— 逐个 `closest`，不用逗号选择器 ✓，因为小 DOM 桩可能不支持 ✓）。驱动侧只开会话 + 一条说明 ✓（官方没有对外跳转接缝 ✗）。
+- **右栏根上有 `data-sidebar-right-session="<会话 id>"`** ✓（右栏是**按会话**的 ✓，实测与路由里的会话 id 一致 ✓）；**页签只读 `[data-dockkit-strip-tabs]`** ✓ —— 空态那层也有 `data-dockkit-pane="pane1"` ✗，读"任意 pane-active"会把空态当页签 ✗（历史 bug ✓）。
+- **官方源码级契约（读 dsh-web-frontend / sidebar-right 得到）** ✓：页签是 `role="tab"` ✓，活动的是 `aria-selected="true"` ✓，身份在 **`data-dockkit-tab`** ✓ —— 而**该值就是 `pageAddress(kind)` = `sidebar://<kind>[/<uuid>]`** ✓（`multiple: true` 的 kind 才拼 uuid ✓），所以 **kind 直接含在 tabId 里** ✓（`kindOfTabId()` 解 ✓）。`data-dockkit-pane` 的值是 **paneId**（`pane1` ✗），而且**主区也有同一套属性** ✗ → 读必须**限定在 `[data-sidebar-right-session]` 根内** ✓（否则读成主区的 pane ✗）。
+- **控制器的两条路** ✓：`openTab(kind)` 要求**已挂载**（`require()` 抛 `no session surface is mounted` ✗）；**`openTabIn(sessionId, kind, options)`** 才是显式带会话的公开路径 ✓（**参数顺序是 session 优先** ✗ 传反就成了"查一个叫 files 的会话" ✗ 历史 bug ✓）。`actionsFor(sessionId)` = `adopted.get(sessionId)?.store.actions` ✓，而 **adopt 发生在右栏被呈现时** ✓（`layout.openRightbar(track, fullscreen)` ✓，track = `session` | `panel` ✓）→ 所以驱动**先呈现右栏** ✓ 再 `openTabIn` ✓。
+- **`isExpanded()`** = `mountedSurface().layout.expanded` ✓；`toggleExpanded()` 内部同样走 `require()` ✗（未挂载会抛 ✓，要 try ✗）。
+- **旧守卫（已删）**：两条 pane 分支原来都有 `source !== 'hash'` ✗ → **粘贴 pane 链接不驱动** ✗（视图那次修了、pane 漏了 ✓）。
+- **驱动三级链（旧记录）**：`sidebarRight.openTab(kind, { sessionId })` → `openTabIn(kind, sessionId)` → **guide 动作**（空态卡片背后那一步 ✓，`sidebarRightTabs.guideEntries` ✓）。**真机全部无效** ✗（零异常零诊断 ✓）→ 与 `uiConversation` 同一结论：**根插件拿到的是根控制器** ✗，会话内的那一个够不着 ✓ → 需要**会话作用域接缝** ✓。
+- **右栏有两个服务，别混** ✓（实测两个面）：**`sidebarRightTabs` = 注册表** ✓（`kinds` / `ids` / `entries` / `register` / `active` / `candidates` / `guide` ✓）；**`sidebarRight` = 控制器** ✓（`openTab(kind, options)` / `openTabIn` / `close` / `closeIn` / `toggleExpanded` / `isExpanded` / `active` / `split` / `focus` / `screen` ✓）。读活动页签：控制器 `active` 优先 ✓（可能是值或方法 ✓）→ 注册表 `active` ✓ → 再 DOM 兜底 ✓。开页签：**必须走控制器** ✓（调注册表**静默失败** ✗，历史 bug ✓）。**真机仍未打开** ✗（9 个 kind 全试、零异常 ✓）→ 疑似**根控制器 vs 会话内控制器**（与 `uiConversation` 同类 ✓），需要会话作用域接缝 ✓。`paneKinds()` 已备好（供体检/预校验 ✓），暂未接进认领路径 ✓。
+- **旧记录（仍在）**：DOM 兜底必须**只认真正属于右栏**的标记 ✓（`data-dockkit-pane-active` 是主区共用的 ✗，历史踩过 ✓）。该服务已加进 `inject` ✓ 与包声明的官方模块 id ✓。
 - **链接落地即交权**：视图一旦等于链接描述的界面，链接立刻失去权威（只留"还没落地"的窗口期）。否则用户在面板里继续点进去时，地址栏会被拽回链接那一层（真机踩过：点组件行后又被改回包详情）。
 - **面板行同样是链接**：`data-slot="sidebar.panellist"` 所在的那个 `<button>`（官方侧栏渲染的面板行）会挂上 `href="#/panel/<id>"` 的锚点。**行里没有 id**，id 只能从注册表取：`ctx.slots.entries('sidebar.panellist')` 的 `options.id` / `options.order` / `options.label`；label 可能是**函数**（按语言解析），所以优先按可访问名匹配、数量一致时按 order 对齐，匹配不上一律不碰。
 - **`slots` 必须留在 `inject` 里**：cordis 下读未声明的服务会抛错，而插件激活期的抛错会让整个插件 `failed`（真机事故：面板链接那次就是这么挂的——假 ctx 无条件给服务，单测抓不到，只有真机能抓）。其余可选面（如 `ctx.layout`）一律 `try/catch` 读取。
@@ -38,3 +60,44 @@
 ## 跨机开发日志
 
 改动记录在私有库 [DDDMUC/repo-devlogs](https://github.com/DDDMUC/repo-devlogs) 的 **`dsh-url-router/`** 文件夹（`HANDOFF.md` 最新一轮在最上面；macOS 端写 `WORKLOG-macos.md`，条目以 `[macOS]` 开头）。按该库规矩，每条先写 `**运行环境**`（设备 / 应用 / 服务商与模型），再写做了什么、动了哪些文件、怎么验证、遗留问题。
+
+## 待办设计（用户 2026-10-10 提的一批，未实现，设计已定）
+
+- **外部 fragment 写者共存（#4）**：`dsh-milestone` 之类的插件会在同一条 URL 的**同一个 fragment** 里写 `#msg=…` ✓。一个 fragment 只能有一个写者 ✗ → 现在的行为是"互不认账、静默覆盖" ✗。要做：① 自己的写入**只碰自己的段位** ✓（已经是这样 ✓）；② 读到**不属于本插件语法**的 fragment 时，**留一条明确诊断**（点出对方形态 + 说明互斥），不要静默 ✓；③ 真共存需要**统一裁决**（见下条的接缝）✓。
+- **兼容边界自检（#6）**：官方一改契约（侧栏行结构、插件管理器的 `data-plugin-*`、设置导航的 `aria-current`、会话视图的 `[data-conversation-tabs]`、槽位 id）就会**静默失效** ✗。要做"屏幕形态 vs 期望形态"的**渲染期检测** ✓，每类只报一次 ✓，措辞统一为"与当前 DSH 版本不兼容，请升级插件" ✓。**只告警、不改行为** ✓。
+- **路由体检（#7）**：一个 `window.__dshUrlRouter.report()` ✓（无 UI 依赖 ✓，绝不抛错 ✓），列出：当前 canonical 路由 ✓、正在落地的链接与重试次数 ✓、每一层界面**读到多少个钩子** ✓（会话行 / 工作区行 / 视图 tab 与 id 列表 / 轮次 / 轨迹行 / 轮次边界 / 插件行 / 官方项 / 设置覆盖层与分区 / 任务看板 / 右栏 pane ✓）、已发出的告警 ✓、以及被"不碰"的段位 ✓。
+- **对外接缝（#8）**：`ctx.urlRouter`（服务）或同名窗口事件 ✓，让第三方把"当前界面"写成链接 ✓，并由本插件**统一裁决** fragment 所有权 ✓ —— 这同时也是 #4 的真正解法 ✓。
+- **面板内层页面（#5）**：技能中心 / SSH 需要各自发契约 ✓（`data-*` + 接受同名窗口事件 ✓）；任务看板是现成先例 ✓，可作为 PR 往上游推 ✓（需要各仓 owner 同意 ✓）。
+- **跳转到某一轮（官方）**：已发讨论 <https://github.com/deepseek-ai/deepseek-harness/discussions/9339> ✓（请求一个 `scrollToTurn(turn)` 服务或 `dsh-chat-scroll-to-turn` 窗口事件 ✓；退路是驱动 rail 刻度点击 ✗ 虚拟化下不可靠 ✓）。
+
+## 已实现：#4 外部 fragment 共存 / #7 路由体检（2026-10-11）
+
+- **#4 一个 URL 只有一个 fragment** ✓：两个写者只能轮流拥有 ✓，本插件**绝不假装合并** ✗。
+  - `foreignFragmentOf(hash)` ✓：不以 `#/kind…`（或 `#<alias>`）开头的 fragment 即外来 ✓。
+  - 读到外来 fragment：**命名一次** ✓（`… was written by another plugin … a URL has one fragment, so this router leaves it alone — enable only one writer` ✓）并退开 ✓。
+  - `reflect` 遇到外来 fragment：**不覆盖** ✓ + 一条说明 ✓（`not writing a route while … is in the address bar` ✓）。
+  - unknown kind 记入 `observed.ignored` ✓ 供体检 ✓。
+- **#7 `window.__dshUrlRouter.report()`** ✓（挂在 `startUrlRouting` 内部作用域 ✓ 才能读到 `linked`/`attempts` ✗ 放外面必抛 ✓）：
+  版本 / 当前 fragment / `canonical` / 正在落地的链接与重试次数 / **16 项钩子计数**（会话行·工作区行·视图 tab 与 id 列表·轮次·轨迹行·轮次边界·插件行·官方项·设置覆盖层与分区·任务看板两项·右栏 pane 与 **kinds 列表**）/ 兼容告警 / 外来 fragment / 被不碰的段位。
+  **它绝不出错、绝不写任何东西** ✓（整段 `guard` 包裹 ✓）。
+- **`ROUTER_VERSION`** 由测试断言等于 `package.json` ✓（发布时忘改会被测试抓住 ✓）。
+- **实测顺带发现（下次可用）** ✓：`paneKinds()` 走 `entries()` 能拿到**全量 7 个 kind**：
+  `guide / subagentchat / changes-review / plan / files / text / terminal` ✓
+  —— 上一轮"根作用域只有 guide"的结论**下早了** ✗（那次读的是 `kinds` getter ✗）。⇒ **右栏 pane 的驱动很可能真能做** ✓，用这些 kind 值 ✓。
+
+## 右栏 pane 驱动已闭环（2026-10-11，真机验证 ✓）
+
+**用官方 7 个真实 kind 做完了驱动** ✓（`guide / subagentchat / changes-review / plan / files / text / terminal` ✓）。
+
+**真机实测** ✓：贴 `#/session/<id>/pane/terminal` → 右栏展开 ✓、**只开一个 Terminal** ✓、地址栏写 `…/pane/terminal` ✓；再贴 `…/pane/files` → 开出 Files ✓、地址栏跟着切 ✓；**零异常零诊断** ✓。
+
+**本轮修掉的 5 个真 bug** ✓：
+1. **`sameRoute` 把 pane 当"细化"** ✗：`pane/terminal` vs 屏幕上 `pane/Start` 被判"已落地" → 链接被丢、驱动不跑 ✓。且它用 `routeKey` 精确比 ✗（含 kind：`session` vs `workspace` ✗ 永不相等 ✓）→ 改为**只比 pane kind** ✓（形状是装饰 ✓，跟工作区别名一样 ✓）。
+2. **canonical 的 workspace 分支先 return** ✗ → pane 永远读不到 ✓（workspace 吞掉 pane ✓，与"视图被工作区吞掉"同一类 ✓）→ pane 读取**提前** ✓，两种形状都带 ✓。
+3. **`openRightbar` 薄面丢参数** ✗（`() => openRightbar()` ✓）→ track 永远 undefined ✗ → 改成转发 ✓。
+4. **`multiple: true` 的 kind 每轮重试多开一个页签** ✗（实测开出 40 个 ✗）→ 加护栏：**同一 claim 只驱动一次** ✓（`paneOpenedFor` 放机器级作用域 ✓，放 reconcile 内每次都会重建 ✗）。
+5. **kind 白名单** ✓：驱动前用注册表校验 ✓，未知 kind 明确拒绝并列出已知 kind ✓（不留"挂着什么都不做"的链接 ✓）。
+
+**读侧同步升级** ✓：注册表条目实测有 **`{kind, title(): () => label, multiple, guide, patterns, priority}`** ✓ → 用 `title()` 把页签**标签映射回 kind** ✓，于是地址栏写 `pane/files` ✓（而不是 `pane/Files` ✗）。
+
+**坑（老熟人 ✓）**：诊断用 `console.info` 而 harness 的 console 只有 `warn` ✗ → 抛错被 `guard` 吞 → `canonical` 中断 → 地址栏写空 ✗（**测试里别用 console.info** ✓）。

package/README.md

@@ -37,7 +37,7 @@ dsh plugin --profile web add "link:/path/to/dsh-url-router"
 | `#/panel/task-board/task/<任务 id>` | 任务看板里某个任务的详情 | 任务看板自己的 `dsh-taskboard-open-task` 窗口事件 |
 | `#/panel/task-board/new` | 任务看板的新建任务表单 | 任务看板自己的 `dsh-taskboard-new-task` 窗口事件 |
 
-输入侧宽容：`sessions`/`panels` 复数、百分号编码都接受，一律规范化成上面的形式。**不认识的段位不碰**（例如 `#/settings/…`），只留一条诊断，留给以后的路由器。
+输入侧宽容：`sessions`/`panels` 复数、百分号编码都接受，一律规范化成上面的形式。**不认识的段位不碰**，只留一条诊断（留给以后的路由器，或者别的插件写的深链形态 ✓ —— 一个 fragment 只能有一个写者 ✓，所以读到不属于本插件的形态时会**明确说一句**，而不是静默 ✗）。
 
 面板内部页是**面板自己的词汇表**，本插件不发明：插件管理器发布 `data-plugin-detail` / `data-plugin-item-detail` / `data-plugin-row-detail`，任务看板发布 `data-dsh-taskboard-open-task` / `data-dsh-taskboard-new-task`，并接受同名窗口事件。
 
@@ -54,21 +54,33 @@ dsh plugin --profile web add "link:/path/to/dsh-url-router"
 - **只动 fragment**：路径与查询串从不改写（启动 `?token=…` 能活下来）。
 - **唯一写者**：本插件拥有 fragment，请**不要**和别的写 fragment 的插件同时启用（例如 `dsh-session-url`），两者会互相覆盖。
 - **只用 `replaceState`**：浏览面板不污染后退栈。
+- **轮次信息：能证明才写** ✓。助手行自己的身份里就带轮次（`row/assistant/80/32` = 第 80 轮第 32 项 ✓）；**工具行不带** ✗（只有调用 id ✓）→ 于是我从视图的**轮次边界** `[data-turn-start]` 反推 ✓，**但只在行夹在两个已渲染边界之间时才写** ✓（`turn/82/row/tool/call/…` ✓）。视图是虚拟化的 ✓，边界可能只渲染了一侧 ✗ → 那时**宁可不写轮次** ✓，也绝不猜一个错的轮次 ✗。
+- **轨迹里的每一行都有自己的链接** ✓：`#/session/<id>/row/<类>/<作用域>/<id>`（例：`row/tool/call/call_ce3a…`、`row/assistant/80/32` = 第 80 轮第 32 项 ✓；有工作区时跟在会话 id 之后 ✓）。身份来自视图自己发的 **`data-trajectory-row-key`** ✓（值是 `<类>%00<作用域>%00<id>` ✓，我把它拆成可读路径 ✓）；你家 Trajectory Plus 发的是 **`data-dshts-turn`**（轮号 ✓）→ 那种行按轮次写（`turn/<n>` ✓）。点一行就反映进地址栏 ✓（**纯被动**：不 preventDefault ✓）。粘贴行链接会打开那个对话并**尽力滚到那一行** ✓ —— 视图是虚拟化的 ✓，**没渲染出来的行不会被假装滚到** ✗（不会骗你 ✓）。
+- **会话视图（对话 / 轨迹 / 轨迹plus …）也进地址栏** ✓：`#/session/<id>/view/<viewId>`（有工作区时是 `#/workspace/<名>/session/<id>/view/<viewId>` ✓）。**视图 id 是真的 id** ✓（来自槽位 `conversation.view` 的 `id` 字段 ✓，按 `order` 排序后与头部页签一一对应 ✓）：实测本机是 `chat` / `trajectory` / **`surface`**（Trajectory Plus ✓）/ **`plus2`**（Trajectory Plus 2 ✓）。默认视图（第一个 ✓）**不写进链接** ✓，所以普通对话链接保持短 ✓。**粘贴视图链接会真的切过去** ✓（与其它覆盖层不同：这是链接存在的意义 ✓）。
+- **工作区是"它住在哪"，所以写在链接最前面** ✓：`#/workspace/<工作区名>/session/<会话id>`（侧栏本身就是这个形状 ✓）。工作区名是**给眼睛看的** ✓ —— 决定打开哪个会话的永远是会话 id ✓，所以**名字过期/写错也照样打开对的会话** ✓（地址栏随后自己纠正成真实工作区 ✓）。读不到工作区行（没有侧栏 / 树里没有）就**不猜** ✓，退回 `#/session/<id>` ✓。
 - **作用域由视图决定，不靠猜**：主面板是应用级界面（列的是本机插件，不是某个对话），所以它的链接不带会话 id。
 - **链接落地即交权**：视图一旦变成链接描述的那个界面，链接立刻失去权威——这样你在面板里继续点进去时，地址栏不会被拽回上一层。
 - **绝不抛错**：官方 `selectPanel` 对未注册的面板 id 是抛异常的；所有宿主面调用都被容纳，失败只留一条诊断并回落到屏幕上真实的视图。
 
 ### 已知限制
 
-- **设置页分区暂未纳入**：设置包没有"打开某个分区"的接缝（它们是 keyed list slot），只能等它自己发布类似契约。
-- **右栏 pane 与会话内轮次/消息锚点暂未纳入**。
+- **轮次链接是"位置"不是"界面"**：点某一轮，地址栏记下 `#/session/<id>/turn/<n>` ✓；但**粘贴它只会打开那个对话，不会滚到那一轮** ✗ —— 官方把"跳到某轮"（`scrollToTurn` / `JUMP_PAGE_OPTIONS`）留在 chat 包**内部**，没有对外接缝 ✗，逐页翻也不可靠 ✗（实测「Load earlier」按钮在两个会话上都没加载出更早的轮次 ✗）。要真跳转，需要官方开一个服务或槽位 ✓。
+- **右栏 pane 已闭环** ✓：`#/session/<id>/pane/<kind>` 与 `#/panel/<面板>/pane/<kind>` ✓（真机验证：贴链接开出对应页签 ✓、地址栏跟着切换 ✓）。页签种类由右栏自己注册 ✓（实测 7 种：`guide` / `subagentchat` / `changes-review` / `plan` / `files` / `text` / `terminal` ✓）。
+- **设置面板已纳入**：`#/settings` ✓、**`#/settings/<分区>`** ✓、**`#/settings/<分区>/<页签>`** ✓（页签靠标准 `role="tab"` + `aria-selected` ✓，分区内任何页签都吃这一套 ✓）。分区**没有稳定 id** ✗（实测：导航项上只有 `aria-current="true"` ✓，父链是 `nav` ✓，右侧内容区一个 `data-*` 都没有 ✗；官方内部的 `openSection(id)` 也不对外 ✗）→ 所以**分区的身份就是它的显示名** ✓：反映读「`aria-current="true"` 且属于 `nav`」的那个按钮的**标签文字** ✓，驱动按标签点 ✓。含义：**换语言或官方改文案后，旧的分区链接会失效** ✗（但你重新点一次，地址栏就会写出新链接 ✓ —— 自洽、不过期 ✓）。裸 `#/settings` 只要面板开着就算落地 ✓，随后地址栏自动升级为具体分区 ✓。
+- **设置页分区暂未纳入（旧描述）**：设置包没有"打开某个分区"的接缝（它们是 keyed list slot），只能等它自己发布类似契约。
+- **会话内的轮次与行锚点已纳入** ✓：`#/session/<id>/turn/<n>` ✓（只做反映 ✓）、`#/session/<id>/row/<类>/<作用域>/<id>` ✓（反映 + 尽力滚动 ✓，含可证明时的轮次归属 ✓）。**跳转仍然做不到** ✗（官方把 `scrollToTurn` 留在包内部 ✓，已向官方提 <https://github.com/deepseek-ai/deepseek-harness/discussions/9339> ✓）。
 - **技能中心 / SSH 的内部页**：需要它们各自发布"当前实体 id + 按 id 打开"的契约（任务看板就是这么做的）。
+- **和别的 fragment 写者互斥**（例如写 `#msg=` 的"跳到消息"插件）：一个 URL 只有一个 fragment ✓，两个写者只能轮流拥有 ✗。本插件**不假装合并** ✓ —— 它认出外来 fragment ✓、**绝不覆盖** ✓，并明确说"只能启用一个写者" ✓（而不是互相静默擦掉对方的链接 ✗）。
 - 链接**同名不跨机**：会话 id 只在同一台机器、同一个 `DSH_HOME` 下有意义。
 
 ### 开发
 
 手写 JS 直接进 `lib/`（无构建步骤），`npm test` 直接跑交付产物（35→45 条用例，`node --test`）。改之前请读 [AGENTS.md](AGENTS.md) 里的路由与行链接契约。
 
+### 排障
+
+浏览器 Console 里调用 `window.__dshUrlRouter.report()` ✓，它会列出：当前地址栏 ✓、本插件认为屏幕在哪个界面 ✓、正在落地的链接与重试次数 ✓、**每一层读到了多少个钩子** ✓、右栏 pane 的**真实 kind 列表** ✓、以及它**拒绝认领**的段位 ✓。它绝不出错、也不写任何东西 ✓。
+
 ## English
 
 **A URL router for the DSH Web GUI — every surface gets its own link.** Click a conversation and the address bar becomes `#/session/<id>`; click a panel (Plugins, Task Board, …) and it becomes `#/panel/<panelId>`; walk into a plugin, a component, or a task and the bar follows. Paste the link into another tab, or right-click any sidebar row for the browser's own "open in new tab / copy link".
@@ -94,7 +106,7 @@ dsh plugin --profile web add dsh-url-router
 | `#/panel/task-board/task/<taskId>` | one task's detail on the task board |
 | `#/panel/task-board/new` | the task board's new-task form |
 
-A kind it does not know (`#/settings/…`) is left alone with a single diagnostic. Panel inner pages are the panel's own vocabulary: the plugin manager publishes `data-plugin-detail` / `data-plugin-item-detail` / `data-plugin-row-detail`, the task board publishes `data-dsh-taskboard-open-task` / `data-dsh-taskboard-new-task`.
+A kind it does not know is left alone with a single diagnostic (a fragment has exactly one writer, so a foreign shape is named rather than silently ignored). Panel inner pages are the panel's own vocabulary: the plugin manager publishes `data-plugin-detail` / `data-plugin-item-detail` / `data-plugin-row-detail`, the task board publishes `data-dsh-taskboard-open-task` / `data-dsh-taskboard-new-task`.
 
 ### Every row is a real link
 
@@ -111,4 +123,4 @@ Conversation rows and both plugin-list groups carry a transparent full-row ancho
 
 ### Limits
 
-Settings sections (no open seam yet), the right-hand panes, and in-conversation turn anchors are not routed. Skill Center / SSH inner pages need their own "publish the current id + accept an open request" contract, the way the task board did. Session links are meaningful on the same machine and `DSH_HOME` only.
+Still open: jumping to a named turn (the official chat keeps `scrollToTurn` inside its own package — asked for a seam in discussion #9339), the right-hand panes (wired, but the right bar starts empty in this composition so they are not verified end to end yet), and Skill Center / SSH inner pages, which need their own "publish the current id + accept an open request" contract the way the task board did. Session links are meaningful on the same machine and `DSH_HOME` only.

package/lib/client.js

@@ -63,9 +63,15 @@ window.__ModuleLoader__.load({
 		// another router's route may legitimately be pasted in.
 		// ---------------------------------------------------------------------
 		/** Route kind aliases accepted on input. */
-		const ROUTE_ALIASES = { session: 'session', sessions: 'session', panel: 'panel', panels: 'panel' }
-		/** Canonical fragment shape. */
-		const ROUTE_PATTERN = /^#\/?([a-z][a-z0-9-]*)\/(.+)$/
+		const ROUTE_ALIASES = { session: 'session', sessions: 'session', panel: 'panel', panels: 'panel', settings: 'settings', workspace: 'workspace', workspaces: 'workspace' }
+		/** Attribute the settings overlay puts on its root element. */
+		const SETTINGS_SURFACE_ATTRIBUTE = 'data-dsh-surface'
+		/** Value of that attribute for the settings overlay. */
+		const SETTINGS_SURFACE_VALUE = 'settings'
+		/** Slot the settings entry is rendered into (its button opens the overlay). */
+		const SETTINGS_TRIGGER_SLOT = 'sidebar.settings'
+		/** Canonical fragment shape, plus the bare `#/<kind>` form a modal surface uses. */
+		const ROUTE_PATTERN = /^#\/?([a-z][a-z0-9-]*)(?:\/(.+))?$/
 		/** How often an unsatisfied link is retried while it is authoritative. */
 		const LINK_RETRY_MS = 500
 		/** How many times an inner page may be requested while its link is authoritative. */
@@ -82,11 +88,237 @@ window.__ModuleLoader__.load({
 		const TASK_BOARD_NEW_ATTRIBUTE = 'data-dsh-taskboard-new-task'
 		/** Window event that asks the task board for its new-task form. */
 		const TASK_BOARD_NEW_EVENT = 'dsh-taskboard-new-task'
+		/** Sidebar row key prefix for a workspace (the value is its id; the row text is its name). */
+		const WORKSPACE_ROW_PREFIX = 'workspace:'
+		/** Stable container the conversation header renders its view tabs into. */
+		const CONVERSATION_TABS_ATTRIBUTE = 'data-conversation-tabs'
+		/** Attribute each trajectory row carries: `<kind>%00<scope>%00<id>`. */
+		const TRAJECTORY_ROW_ATTRIBUTE = 'data-trajectory-row-key'
+		/** Attribute the family trajectory view puts on a row's turn cell. */
+		const TRAJECTORY_TURN_ATTRIBUTE = 'data-dshts-turn'
+		/** The right bar's own root: it carries the session the bar belongs to. */
+		const RIGHT_BAR_ATTRIBUTE = 'data-sidebar-right-session'
+		/** The right bar's tab strip: only *tabs* live here (the empty state has a bare pane). */
+		const RIGHT_BAR_STRIP_ATTRIBUTE = 'data-dockkit-strip-tabs'
+		/** Attribute the trajectory view puts on the first row of a turn. */
+		const TRAJECTORY_TURN_START_ATTRIBUTE = 'data-turn-start'
+		/** Inner segment that names one row inside a conversation view. */
+		const ROW_SEGMENT = 'row'
+		/** Inner segment that names which conversation view is showing. */
+		const VIEW_SEGMENT = 'view'
+		/** Inner segment that marks the conversation inside a workspace route. */
+		const WORKSPACE_SESSION_SEGMENT = 'session'
+		/** Attribute the chat view puts on every rendered turn node (the turn number). */
+		const TURN_ATTRIBUTE = 'data-chat-turn'
+		/** Inner segment that names the turn a conversation is showing. */
+		const TURN_SEGMENT = 'turn'
+		/** Inner segment that names the right-hand pane in front. */
+		const PANE_SEGMENT = 'pane'
+		/** Service the right-hand pane registers, whose snapshot names the active tab. */
+		const SIDEBAR_RIGHT_SERVICE = 'sidebarRightTabs'
 		/** Panel id of the official plugin manager, whose list rows and detail pages are routed. */
 		const PLUGINS_PANEL_ID = 'plugins'
 		/** Log prefix for every diagnostic. */
+		/**
+		 * The router's own version, for the report a human files. A test keeps it equal to the
+		 * package version, so a release cannot forget to bump it.
+		 */
+		const ROUTER_VERSION = '0.3.0'
+
 		const TAG = '[url-router]'
 
+		/**
+		 * The conversation view ids the registry publishes, in registration order — the same order
+		 * the header renders its tabs in, which is what lets a tab position map back to an id.
+		 * @param {object} faces - the probed host faces.
+		 * @returns {string[]|undefined} the ids, or undefined when the registry is not readable.
+		 */
+		function conversationViewIdsOf(faces) {
+			// The conversation's own `uiConversation` registry is scoped to the conversation and is
+			// not visible from a root plugin (measured: undefined), but the view tabs are contributed
+			// through the `conversation.view` slot, and that *is* readable — with an id and an order.
+			const entries = attemptValue(() => faces.slots?.entries?.('conversation.view'))
+			if (!Array.isArray(entries)) return undefined
+			const rows = []
+			for (const entry of entries) {
+				if (entry === null || typeof entry !== 'object') continue
+				const options = entry.options ?? entry
+				const id = options.id ?? entry.id
+				if (typeof id !== 'string' || id === '') continue
+				const order = typeof options.order === 'number' ? options.order : 0
+				rows.push({ id, order })
+			}
+			if (rows.length === 0) return undefined
+			rows.sort((left, right) => left.order - right.order)
+			return rows.map(row => row.id)
+		}
+
+		/**
+		 * Read a value, or undefined when reading it throws.
+		 * @param {Function} read - the reader.
+		 * @returns {*} the value, or undefined.
+		 */
+		function attemptValue(read) {
+			try {
+				return read()
+			} catch {
+				return undefined
+			}
+		}
+
+		/**
+		 * The workspace a sidebar row belongs to: the nearest workspace row before it, read from the
+		 * row text. Returns undefined when the tree says nothing, so no caller has to guess.
+		 * @param {object} row - the conversation row.
+		 * @param {object} document - the document the tree lives in.
+		 * @returns {string|undefined} the workspace display name.
+		 */
+		function workspaceNameOf(row, document) {
+			const rows = document?.querySelectorAll?.('[data-row-key]')
+			if (rows === undefined || rows === null) return undefined
+			let name
+			for (const candidate of rows) {
+				const key = typeof candidate.getAttribute === 'function' ? candidate.getAttribute('data-row-key') : null
+				if (typeof key !== 'string') continue
+				if (key.startsWith(WORKSPACE_ROW_PREFIX)) {
+					name = (candidate.textContent ?? '').trim()
+					continue
+				}
+				if (candidate !== row) continue
+				return name === undefined || name === '' ? undefined : name
+			}
+			return undefined
+		}
+
+		/**
+		 * The kind inside a tab id: the bar builds one as `sidebar://<kind>` and appends a uuid for
+		 * kinds that may be opened more than once, so the kind is right there in the address.
+		 * @param {string} value - a tab id.
+		 * @returns {string|undefined} the kind, when the value is one of these addresses.
+		 */
+		/**
+		 * The right bar's registry, normalised: one row per page type with its kind, the label
+		 * the tab shows, whether more than one may be open, and its empty-state card (measured
+		 * live: `{kind, title(): () => string, multiple?: true, guide?: [{id, order}]}`).
+		 * @param {object} faces - the probed host faces.
+		 * @returns {{kind: string, label: string|undefined, multiple: boolean}[]|undefined} the rows.
+		 */
+		function paneRegistryOf(faces) {
+			const rows = attemptValue(() => faces.sidebarRightTabs?.entries?.())
+			if (!Array.isArray(rows)) return undefined
+			const out = []
+			for (const row of rows) {
+				if (row === null || typeof row !== 'object') continue
+				const kind = row.kind ?? row.options?.kind ?? row.id
+				if (typeof kind !== 'string' || kind === '') continue
+				const label = attemptValue(() => (typeof row.title === 'function' ? row.title() : row.title))
+				out.push({ kind, label: typeof label === 'string' && label !== '' ? label : undefined, multiple: row.multiple === true })
+			}
+			return out.length === 0 ? undefined : out
+		}
+
+		/**
+		 * A tab label compared without the noise a visible label can carry (padding, an underline
+		 * marker, a shortcut hint), so a registry label can be matched to what the tab shows.
+		 * @param {string} value - the text to flatten.
+		 * @returns {string} the flattened text.
+		 */
+		function flatLabel(value) {
+			return String(value).replace(/\s+/g, ' ').trim()
+		}
+
+		function kindOfTabId(value) {
+			if (typeof value !== 'string' || value === '') return undefined
+			const match = /^sidebar:\/\/([^/?#]+)/.exec(value)
+			return match === null ? undefined : decodeURIComponent(match[1])
+		}
+		
+		/**
+		 * The session the right bar belongs to: the bar is per session and says so on its own root.
+		 * @param {object} document - the document to read.
+		 * @returns {string|undefined} the session id.
+		 */
+		function rightBarSessionIdOf(document) {
+			const root = attemptValue(() => document?.querySelector?.(`[${RIGHT_BAR_ATTRIBUTE}]`))
+			const id = root === null || root === undefined ? null : attemptValue(() => root.getAttribute?.(RIGHT_BAR_ATTRIBUTE))
+			return typeof id === 'string' && id !== '' ? id : undefined
+		}
+
+		/**
+		 * The right bar's active tab kind, read from its *strip*: the empty state also renders a
+		 * `data-dockkit-pane`, so any pane-active marker would report a tab that is not there.
+		 * @param {object} document - the document to read.
+		 * @returns {string|undefined} the active kind.
+		 */
+		/**
+		 * Notes already said, across reconciles: a compatibility note is useful the first time, and
+		 * a plugin that repeats it every reconcile is a log spammer.
+		 */
+		const paneNotes = new Set()
+		/**
+		 * Say a pane diagnostic once.
+		 * @param {Function} warn - the host's warning sink.
+		 * @param {string} key - deduplication key.
+		 * @param {string} message - what to say.
+		 */
+		const notePaneShape = (warn, key, message) => {
+			if (paneNotes.has(key)) return
+			paneNotes.add(key)
+			warn(`${TAG} ${message}`)
+		}
+
+		function activePaneTabOf(document, registry) {
+			// Scoped to the right bar's own root: the same dockkit attributes dress the main area
+			// too, and reading them unscoped reports the main area's panes, not this bar's tabs.
+			const right = attemptValue(() => document?.querySelector?.(`[${RIGHT_BAR_ATTRIBUTE}]`))
+			const scope = right === null || right === undefined ? document : right
+			const strip = typeof scope?.querySelector === 'function' ? attemptValue(() => scope.querySelector(`[${RIGHT_BAR_STRIP_ATTRIBUTE}]`)) : undefined
+			if (strip === null || strip === undefined) return undefined
+			// A tab is `role="tab"` with its id in `data-dockkit-tab` — and that id *is* the page
+			// address, so the kind sits inside it. Pane markers belong to the content area.
+			// Remember what the strip holds, *before* trying to read it: this is what a compatibility
+			// note has to name when nothing can be read, so it must be recorded either way.
+			const described = attemptValue(() => {
+				const child = strip.children?.[0]
+				if (child === undefined) return undefined
+				// An Attr list and a Map both show up (the DOM makes the former, a stub the latter).
+				const pairs = [...child.attributes].map(attribute => Array.isArray(attribute) ? { name: attribute[0], value: attribute[1] } : attribute)
+				return pairs.map(attribute => `${attribute.name}="${String(attribute.value).slice(0, 24)}"`).join(' ')
+			})
+			if (typeof described === 'string') activePaneTabOf.observed = described
+			const tabs = typeof strip.querySelectorAll === 'function' ? attemptValue(() => [...strip.querySelectorAll('[role="tab"]')]) : undefined
+			if (!Array.isArray(tabs) || tabs.length === 0) return undefined
+			const chosen = tabs.find(tab => attemptValue(() => tab.getAttribute?.('aria-selected')) === 'true') ?? tabs[0]
+			// The tab's own name is the reliable source: measured live, `data-dockkit-tab` and
+			// `data-dockkit-content` both carry the strip's tab id (`tab3`), which says nothing about
+			// the kind — while the visible label *is* the kind's name (`Files`, `Start`, `Terminal`).
+			const nameOfTab = tab => {
+				const labelled = attemptValue(() => tab.getAttribute?.('aria-label')) ?? attemptValue(() => tab.getAttribute?.('title'))
+				if (typeof labelled === 'string' && labelled.trim() !== '') return labelled.trim()
+				const text = attemptValue(() => (tab.textContent ?? '').trim())
+				return typeof text === 'string' && text !== '' && text.length < 40 ? text : undefined
+			}
+			// 1) the tab's name, resolved to a kind through the registry whenever it can be: the
+			// registry publishes the very label each tab shows, so a link can carry the kind
+			// (`pane/files`) instead of a sentence in whatever language is on screen.
+			const named = nameOfTab(chosen)
+			if (named !== undefined) {
+				const wanted = flatLabel(named).toLowerCase()
+				const match = Array.isArray(registry) ? registry.find(row => typeof row.label === 'string' && flatLabel(row.label).toLowerCase() === wanted) : undefined
+				return match === undefined ? named : match.kind
+			}
+			// 2) an address-shaped id, for a future build that puts one there
+			const fromTab = kindOfTabId(attemptValue(() => chosen.getAttribute?.('data-dockkit-tab')))
+			if (fromTab !== undefined) return fromTab
+			// 3) the tab host section, likewise
+			const hosts = typeof scope.querySelectorAll === 'function' ? attemptValue(() => [...scope.querySelectorAll('[data-dockkit-content]')]) : []
+			for (const host of hosts) {
+				const kind = kindOfTabId(attemptValue(() => host.getAttribute?.('data-dockkit-content')))
+				if (kind !== undefined) return kind
+			}
+			return undefined
+		}
+
 		/**
 		 * Read a route out of a location fragment.
 		 * @param {string} hash - the raw `window.location.hash`, including the leading `#`.
@@ -100,16 +332,65 @@ window.__ModuleLoader__.load({
 			}
 		}
 
+		/**
+		 * The fragment, when it belongs to some other writer.
+		 *
+		 * A URL has exactly one fragment, so two plugins that both write it can only take turns:
+		 * whichever wrote last owns it, and the other one's link is gone. This router never
+		 * pretends otherwise — it names the fragment it did not write and leaves it alone.
+		 * @param {string} hash - the current fragment.
+		 * @returns {string|undefined} the foreign fragment, or undefined when it is ours (or empty).
+		 */
+		function foreignFragmentOf(hash) {
+			if (typeof hash !== 'string') return undefined
+			const trimmed = hash.trim()
+			if (trimmed === '' || trimmed === '#') return undefined
+			const match = ROUTE_PATTERN.exec(trimmed)
+			if (match !== null && ROUTE_ALIASES[match[1]] !== undefined) return undefined
+			return trimmed
+		}
+
 		function parseRoute(hash) {
 			const match = ROUTE_PATTERN.exec(hash)
 			if (match === null) return undefined
+			const kind = ROUTE_ALIASES[match[1]]
+			if (kind === undefined) return { unknown: match[1] }
+			// A modal surface needs no identity: `#/settings` is the whole route.
+			if (match[2] === undefined) return kind === 'settings' ? { kind, id: '' } : undefined
+			// A conversation can be named inside its workspace — the shape the sidebar itself shows,
+			// and the only way a link says *where* a conversation lives.
+			if (kind === 'workspace') {
+				const parts = match[2].replace(/\/+$/, '').split('/')
+				const name = decodePart(parts.shift() ?? '').trim()
+				if (name === '') return { unknown: `workspace/${match[2]}` }
+				const rest = parts.map(decodePart).filter(segment => segment.trim() !== '')
+				if (rest.length < 2 || rest[0] !== WORKSPACE_SESSION_SEGMENT) return { unknown: `workspace/${match[2]}` }
+				const sessionId = rest[1].trim()
+				if (sessionId === '') return { unknown: `workspace/${match[2]}` }
+				// The view a conversation is showing is part of the conversation, so it may follow.
+				const tail = rest.slice(2)
+				if (tail.length === 0) return { kind: 'workspace', id: name, inner: innerPath([WORKSPACE_SESSION_SEGMENT, sessionId]) }
+				if (tail.length < 2 || tail[1].trim() === '') return { unknown: `workspace/${match[2]}` }
+				if (tail[0] === VIEW_SEGMENT && tail.length === 2) return { kind: 'workspace', id: name, inner: innerPath([WORKSPACE_SESSION_SEGMENT, sessionId, VIEW_SEGMENT, tail[1]]) }
+				if (tail[0] === ROW_SEGMENT && tail.length >= 3) return { kind: 'workspace', id: name, inner: innerPath([WORKSPACE_SESSION_SEGMENT, sessionId, ...tail]) }
+				if (tail[0] === PANE_SEGMENT && tail.length === 2) return { kind: 'workspace', id: name, inner: innerPath([WORKSPACE_SESSION_SEGMENT, sessionId, PANE_SEGMENT, tail[1]]) }
+				return { unknown: `workspace/${match[2]}` }
+			}
 			const segments = match[2].replace(/\/+$/, '').split('/')
 			const head = segments.shift() ?? ''
-			if (head === '') return undefined
+			if (head === '') return kind === 'settings' ? { kind, id: '' } : undefined
 			const id = decodePart(head).trim()
-			if (id === '') return undefined
-			const kind = ROUTE_ALIASES[match[1]]
-			if (kind === undefined) return { unknown: match[1] }
+			if (id === '') return kind === 'settings' ? { kind, id: '' } : undefined
+			// A settings section has no stable id in the DOM (measured: the nav item carries only
+			// aria-current), so its identity is its *label* — the string the user actually sees and
+			// clicks. Round-tripping the label keeps the link self-consistent; a locale change
+			// renames the sections and the address bar simply writes the new label next time.
+			if (kind === 'settings') {
+				// A section may hold tabs of its own (measured: `role="tab"` + `aria-selected`), so
+				// the rest of the path names the tab — again by its label.
+				const rest = segments.map(decodePart).filter(segment => segment.trim() !== '')
+				return rest.length === 0 ? { kind, id } : { kind, id, inner: rest }
+			}
 			// A panel may have an inner page (a plugin's detail view, for instance): the
 			// rest of the path names it, per panel.
 			const inner = segments.map(decodePart).filter(segment => segment.trim() !== '')
@@ -123,6 +404,18 @@ window.__ModuleLoader__.load({
 		 * @returns {string} the `#/<kind>/<encoded id>` fragment.
 		 */
 		function routeHash(kind, id, inner) {
+			// A modal surface has no identity: `#/settings`, not `#/settings/`.
+			if (kind === 'settings' && (id === undefined || id === '')) return '#/settings'
+			if (kind === 'workspace') {
+				const rest = innerPath(inner)
+				const tail = rest.length === 0 ? '' : `/${rest.map(encodeURIComponent).join('/')}`
+				return `#/workspace/${encodeURIComponent(id)}${tail}`
+			}
+			if (kind === 'settings') {
+				const head = `#/settings/${encodeURIComponent(id)}`
+				const rest = innerPath(inner)
+				return rest.length === 0 ? head : `${head}/${rest.map(encodeURIComponent).join('/')}`
+			}
 			const base = `#/${kind}/${encodeURIComponent(id)}`
 			if (inner === undefined || inner === '') return base
 			const segments = innerPath(inner)
@@ -228,6 +521,13 @@ window.__ModuleLoader__.load({
 			let claimed = false
 			/** The package segment of the deepest panel page the address bar carried. */
 			let panelScope
+			/** The turn the user last clicked inside a conversation, with its session. */
+			/** What the report can say about this run: fragments it refused, kinds it left alone. */
+			const observed = { foreignFragment: undefined, ignored: [], warnings: [] }
+			let rowAnchor
+			/** The pane kind this claim already opened (one drive per claim, see the pane branch). */
+			let paneOpenedFor
+			let turnAnchor
 			/** How many times the linked panel was selected (bounded, see below). */
 			let panelAttempts = 0
 			/** How many times a panel link's inner page was requested (bounded, see below). */
@@ -248,6 +548,7 @@ window.__ModuleLoader__.load({
 				claimed = false
 				panelAttempts = 0
 				innerAttempts = 0
+				paneOpenedFor = undefined
 				dropTimer()
 			}
 			/**
@@ -255,9 +556,20 @@ window.__ModuleLoader__.load({
 			 * conversation behind it, because the panel is what fills the screen.
 			 */
 			const canonical = () => {
+				// The settings overlay covers the main column, so while it is up it is what is on
+				// screen; when it closes the ordinary surface takes the address bar back.
+				if (window.document?.querySelector?.(`[${SETTINGS_SURFACE_ATTRIBUTE}="${SETTINGS_SURFACE_VALUE}"]`) != null) {
+					const section = host.activeSettingsSection() ?? ''
+					const tab = section === '' ? undefined : host.activeSettingsTab()
+					return tab === undefined ? { kind: 'settings', id: section } : { kind: 'settings', id: section, inner: [tab] }
+				}
 				const panelId = host.activePanelId()
 				if (panelId !== undefined && panelId !== null) {
 					const id = String(panelId)
+					// A right-hand pane in front is part of what is on screen, so it is named first:
+					// it is true whether or not the panel itself reports an inner page.
+					const paneInPanel = host.activePaneKind()
+					if (paneInPanel !== undefined) return { kind: 'panel', id, inner: innerPath([PANE_SEGMENT, paneInPanel]) }
 					const page = host.panelPage(id, panelScope)
 					if (page === undefined) return { kind: 'panel', id, inner: undefined }
 					const segments = innerPath(page)
@@ -267,10 +579,98 @@ window.__ModuleLoader__.load({
 					return { kind: 'panel', id, inner: segments }
 				}
 				const session = host.mainViewSessionId()
-				if (session !== undefined && session !== null) return { kind: 'session', id: String(session) }
+				if (session !== undefined && session !== null) {
+					const id = String(session)
+					// The workspace is part of *where* the conversation lives, so it leads the route.
+					// Reading it from the sidebar keeps this honest: no sidebar (or no matching row)
+					// means the plain conversation route, never a guess.
+					// Which conversation view is showing, when it is not the default one: a plain
+					// conversation keeps its short route, any other view says which one it is.
+					// A pointed-at row is the most specific position there is, then the view, then the
+					// turn: they are all "where inside this conversation", so one of them is written.
+					const view = host.activeConversationView()
+					const position = rowAnchor !== undefined && rowAnchor.session === id
+						? rowAnchor.turn === undefined || rowAnchor.turn === ''
+							? [ROW_SEGMENT, ...rowAnchor.parts]
+							: [TURN_SEGMENT, rowAnchor.turn, ROW_SEGMENT, ...rowAnchor.parts]
+						: view !== undefined && view.index !== 0
+							? [VIEW_SEGMENT, view.id]
+							: []
+					// The right-hand pane is its own layer, not a position inside the conversation:
+					// it is named next to whatever the main column shows, never instead of it — so it
+					// is read *before* the workspace branch, or the workspace would swallow it.
+					const pane = host.activePaneKind()
+					const tail = pane === undefined ? [] : [PANE_SEGMENT, pane]
+					const workspaceName = host.workspaceNameOf(id)
+					if (workspaceName !== undefined) {
+						return { kind: 'workspace', id: workspaceName, inner: innerPath([WORKSPACE_SESSION_SEGMENT, id, ...position, ...tail]) }
+					}
+					if (tail.length === 0 && position.length > 0) return { kind: 'session', id, inner: innerPath(position) }
+					if (tail.length > 0) return { kind: 'session', id, inner: innerPath([...position, ...tail]) }
+						// The turn the user last pointed at is a position inside this conversation;
+					// it is only named while the same conversation is the one on screen.
+					if (turnAnchor !== undefined && turnAnchor.session === id) {
+						return { kind: 'session', id, inner: innerPath([TURN_SEGMENT, turnAnchor.turn]) }
+					}
+					return { kind: 'session', id }
+				}
+				return undefined
+			}
+			// Two routes are the same surface when they compare equal — plus one refinement: a bare
+			// `#/settings` names the overlay, and whichever section it happens to show is that same
+			// surface, so the link lands at once instead of sitting there until its window expires.
+			// A *named* section against a different named section is a real difference, so a section
+			// link still drives the overlay to the section it asks for.
+			// Whether the view on screen already *is* what a link asked for.
+			//
+			// The rule is directional on purpose: a link may be less specific than the view (a bare
+			// `#/settings` is satisfied by any section, `#/session/<id>` by any view of it), but a view
+			// that is less specific than the link never satisfies it — otherwise a link naming a view
+			// would look "already there" and never be driven.
+			const sessionIdOfRoute = route => {
+				if (route?.kind === 'workspace') return innerPath(route.inner)[1]
+				if (route?.kind === 'session') return route.id
 				return undefined
 			}
-			const sameRoute = (left, right) => routeKey(left) === routeKey(right)
+			const viewIdOfRoute = route => {
+				const parts = innerPath(route?.inner)
+				const at = parts.indexOf(VIEW_SEGMENT)
+				return at < 0 ? undefined : parts[at + 1]
+			}
+
+				const paneOf = route => {
+				const parts = innerPath(route?.inner)
+				const at = parts.indexOf(PANE_SEGMENT)
+				return at < 0 ? undefined : parts[at + 1]
+				}
+			const sameRoute = (current, linked) => {
+				if (routeKey(current) === routeKey(linked)) return true
+				const currentSession = sessionIdOfRoute(current)
+				const linkedSession = sessionIdOfRoute(linked)
+				if (currentSession !== undefined && linkedSession !== undefined) {
+					if (currentSession !== linkedSession) return false
+					const linkedView = viewIdOfRoute(linked)
+					if (linkedView === undefined) {
+						// A row or turn link is a position inside the conversation, so it stays exact; any other
+						// route that names the same conversation is satisfied by it being on screen —
+						// the workspace name is decoration, not a condition.
+						const parts = innerPath(linked.inner)
+						if (parts.includes(TURN_SEGMENT) || parts.includes(ROW_SEGMENT)) return routeKey(current) === routeKey(linked)
+						// A pane is its own layer, named next to the conversation: the route *shape* (with or
+						// without the workspace) is decoration, exactly like the workspace name — what has to
+						// match is the pane kind itself.
+						if (parts.includes(PANE_SEGMENT)) return paneOf(current) === paneOf(linked)
+						return true
+					}
+					// A link that names a view has to see that view.
+					return viewIdOfRoute(current) === linkedView
+				}
+				if (current?.kind !== 'settings' || linked?.kind !== 'settings') return false
+				if (linked.id === '') return true
+				if (current.id !== linked.id) return false
+				const linkedTab = innerPath(linked.inner)[0] ?? ''
+				return linkedTab === '' || innerPath(current.inner)[0] === linkedTab
+			}
 			/** Write the fragment for the current view, leaving path and query untouched. */
 			const reflect = route => {
 				const { pathname, search, hash } = host.readLocation()
@@ -278,6 +678,18 @@ window.__ModuleLoader__.load({
 				// path or the launch query, and comparing them made every call look like a change.
 				const wantedHash = route === undefined ? '' : routeHash(route.kind, route.id, route.inner)
 				if (hash === wantedHash) return
+				// Somebody else's fragment is on screen: taking it over would erase their link, so
+				// this router stays quiet and says why instead.
+				const foreign = foreignFragmentOf(hash)
+				if (foreign !== undefined) {
+					observed.foreignFragment = foreign
+					const known = observed.warnings.includes(`refused to write over: ${foreign}`)
+					if (!known) {
+						observed.warnings.push(`refused to write over: ${foreign}`)
+						host.warn(`${TAG} not writing a route while ${foreign} is in the address bar: that fragment belongs to another plugin`)
+					}
+					return
+				}
 				// Nothing to name and nothing named: leave the address bar exactly as it is
 				// (this also leaves a foreign fragment alone, which the caller never reaches).
 				if (route === undefined && hash === '') return
@@ -293,6 +705,13 @@ window.__ModuleLoader__.load({
 				const currentKey = routeKey(current)
 				const moved = currentKey !== seen
 				seen = currentKey
+					// The right bar holds a tab this build cannot name: say it once, with the tab's own
+					// attributes. A silent pane layer is the worst of both worlds — this is how the shape
+					// reaches a bug report instead of a guess.
+					const paneTabs = attemptValue(() => window.document?.querySelector?.(`[${RIGHT_BAR_STRIP_ATTRIBUTE}]`)?.querySelectorAll?.('[role="tab"]')?.length) ?? 0
+					if (paneTabs > 0 && host.activePaneKind() === undefined) {
+						notePaneShape(message => host.warn(message), 'pane-shape', `the right bar shows ${paneTabs} tab(s) but this build cannot read the active one; the first tab is: ${activePaneTabOf.observed ?? 'no attributes read'}`)
+					}
 				if (linked === undefined) {
 					reflect(current)
 					return
@@ -313,7 +732,92 @@ window.__ModuleLoader__.load({
 					reflect(canonical())
 					return
 				}
+				// A conversation link may name which view it wants, on either route shape; the view is
+				// driven before the plain conversation/workspace branches, or they would swallow it.
+				const rowParts = innerPath(linked.inner)
+				const rowAt = rowParts.indexOf(ROW_SEGMENT)
+				const wantedTurn = rowParts.indexOf(TURN_SEGMENT)
+				const rowSession = linked.kind === 'workspace' ? rowParts[1] : linked.kind === 'session' ? linked.id : undefined
+				if (rowSession !== undefined && rowAt >= 0 && rowParts.length > rowAt + 2) {
+					const shown = host.mainViewSessionId()
+					if (shown !== rowSession && panelAttempts < INNER_ATTEMPT_LIMIT) {
+						panelAttempts += 1
+						host.openSession(rowSession)
+					} else if (shown === rowSession && innerAttempts < INNER_ATTEMPT_LIMIT) {
+						innerAttempts += 1
+						if (!host.revealRow(rowParts.slice(rowAt)) && wantedTurn >= 0) host.revealRow(rowParts.slice(wantedTurn, wantedTurn + 2))
+					}
+					armRetry()
+					return
+				}
+				const wantedView = linked.kind === 'session' || linked.kind === 'workspace' ? viewIdOfRoute(linked) : undefined
+				const wantedSession = linked.kind === 'workspace' ? innerPath(linked.inner)[1] : linked.kind === 'session' ? linked.id : undefined
+				if (wantedView !== undefined && wantedSession !== undefined) {
+					// Unlike the boot restore, a named view is driven whatever brought the route in —
+					// a pasted view link exists precisely to switch the view, so it must not be skipped.
+					const shown = host.mainViewSessionId()
+					if (shown !== wantedSession && panelAttempts < INNER_ATTEMPT_LIMIT) {
+						panelAttempts += 1
+						host.openSession(wantedSession)
+					} else if (shown === wantedSession && innerAttempts < INNER_ATTEMPT_LIMIT) {
+						innerAttempts += 1
+						host.openConversationView(wantedView)
+					}
+					armRetry()
+					return
+				}
+				if (linked.kind === 'workspace') {
+					// The workspace is where the conversation lives, not a separate surface: the link
+					// is satisfied by that conversation being on screen, whatever the name says.
+					const target = innerPath(linked.inner)[1]
+					const shown = host.mainViewSessionId()
+					if (shown !== target && source !== 'hash' && panelAttempts < INNER_ATTEMPT_LIMIT) {
+						panelAttempts += 1
+						host.openSession(target)
+					}
+					armRetry()
+					return
+				}
+				if (linked.kind === 'settings') {
+					if (source !== 'hash' && innerAttempts < INNER_ATTEMPT_LIMIT) {
+						innerAttempts += 1
+						host.openSettings(linked.id, innerPath(linked.inner)[0])
+					}
+					armRetry()
+					return
+				}
+				if (linked.kind === 'session' && linked.inner !== undefined && innerPath(linked.inner)[0] === PANE_SEGMENT) {
+					// A pasted pane link is exactly what this drive is for, so the source is not a filter
+					// here (the same lesson as the view branch); the attempt bound still limits it.
+					const wantedPane = innerPath(linked.inner)[1]
+					// A page type that may be opened more than once (measured: `multiple: true`, the
+					// terminal) makes *every* attempt open another tab, so one claim drives once and the
+					// retry then only waits for the bar to report the tab it opened.
+					if (innerAttempts < INNER_ATTEMPT_LIMIT && paneOpenedFor !== wantedPane) {
+						innerAttempts += 1
+						paneOpenedFor = wantedPane
+						host.openPane(wantedPane, linked.kind === 'panel' ? 'panel' : 'session', message => host.warn(message))
+					}
+					armRetry()
+					return
+				}
+				if (linked.kind === 'session' && linked.inner !== undefined && innerPath(linked.inner)[0] === TURN_SEGMENT) {
+					// A turn link is a position, not a surface: the conversation is opened, and the
+					// view is told once that this build does not scroll to the turn (see README).
+					// Record the position so the canonical form keeps it, then fall through to the
+					// ordinary conversation branch: a turn link opens the conversation, and saying so
+					// in the console would only be noise.
+					turnAnchor = { session: linked.id, turn: innerPath(linked.inner)[1] }
+				}
 				if (linked.kind === 'panel') {
+					if (linked.inner !== undefined && innerPath(linked.inner)[0] === PANE_SEGMENT) {
+						if (innerAttempts < INNER_ATTEMPT_LIMIT) {
+							innerAttempts += 1
+							host.openPane(innerPath(linked.inner)[1], linked.kind === 'panel' ? 'panel' : 'session', message => host.warn(message))
+						}
+						armRetry()
+						return
+					}
 					// Panels are selected by id and report back through the panel store; an id
 					// nobody registered never becomes active, so the claim is retried when the
 					// panel store moves (a late-loading plugin), not on every catalog tick.
@@ -364,7 +868,21 @@ window.__ModuleLoader__.load({
 			/** Adopt the surface the address bar names, if it names one. */
 			const readLink = () => {
 				if (disposed) return
-				const parsed = parseRoute(host.readLocation().hash)
+				const hash = host.readLocation().hash
+				// Another writer owns the fragment: name it once and step aside. Overwriting it here
+				// is how two routers silently erase each other's links.
+				const foreign = foreignFragmentOf(hash)
+				if (foreign !== undefined) {
+					const known = observed.foreignFragment === foreign
+					observed.foreignFragment = foreign
+					dropLink()
+					if (!known) {
+						host.warn(`${TAG} ${foreign} was written by another plugin (for example a jump-to-message writer); a URL has one fragment, so this router leaves it alone — enable only one writer`)
+						observed.warnings.push(`foreign fragment: ${foreign}`)
+					}
+					return
+				}
+				const parsed = parseRoute(hash)
 				if (parsed === undefined) {
 					dropLink()
 					reconcile('hash')
@@ -373,6 +891,7 @@ window.__ModuleLoader__.load({
 				if (parsed.unknown !== undefined) {
 					// Another router's route (or a typo): leave the address bar alone and say so
 					// once, so a router owning more kinds can take over later.
+					if (!observed.ignored.includes(parsed.unknown)) observed.ignored.push(parsed.unknown)
 					if (linked === undefined) host.warn(`${TAG} ignoring unknown route kind "${parsed.unknown}"`)
 					return
 				}
@@ -434,8 +953,106 @@ window.__ModuleLoader__.load({
 			const offDom = host.onDomChange(() => safeReconcile('dom'))
 			const offHashChange = host.onHashChange(() => safeReadLink())
 			safeReadLink()
+			// Pointing at a turn records a position, never a navigation: the listener is passive
+			// and it refuses to act on any interactive element, so clicks keep working exactly as
+			// the chat expects. Clicking a turn is how the address bar learns "which turn".
+			const onDocumentClick = event => {
+				if (disposed || event.button !== 0 || event.defaultPrevented) return
+				if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return
+				const target = event.target
+				if (typeof target?.closest !== 'function') return
+				// A trajectory row names itself first: it carries its own identity (and is often a
+				// button), while a chat turn carries only a turn number. Both paths are pure observers
+				// — nothing is prevented, so clicks keep behaving exactly as the views expect.
+				const session = host.mainViewSessionId()
+				const rowOwner = attemptValue(() => host.rowIdentityOf(target))
+				if (rowOwner !== undefined) {
+					if (session !== undefined) {
+						if (rowOwner[0] === TURN_SEGMENT && rowOwner.length === 2) {
+							turnAnchor = { session, turn: rowOwner[1] }
+							rowAnchor = undefined
+						} else {
+							// The view's own key carries the turn for assistant nodes but not for tool
+							// calls; when the row sits between two rendered turn boundaries the turn is
+							// provable, so the link may say it. Otherwise it stays out of the route.
+							const turn = rowOwner.includes(TURN_SEGMENT) ? undefined : attemptValue(() => host.turnOfRow(target))
+							rowAnchor = turn === undefined || turn === '' ? { session, parts: rowOwner } : { session, turn, parts: rowOwner }
+							turnAnchor = undefined
+						}
+						safeReconcile('row')
+					}
+					return
+				}
+				// One selector at a time: a comma list is the kind of thing a small DOM stub (and a
+				// future minimal engine) may not implement, and the answer must be the same.
+				for (const interactive of ['button', 'a', 'input', 'textarea', 'select', '[role="button"]', '[contenteditable="true"]']) {
+					if (target.closest(interactive) !== null) return
+				}
+				const node = target.closest(`[${TURN_ATTRIBUTE}]`)
+				if (node === null) return
+				const id = session
+				if (id === undefined) return
+				const raw = node.getAttribute?.(TURN_ATTRIBUTE)
+				const turn = typeof raw === 'string' ? raw.trim() : ''
+				if (turn === '') return
+				turnAnchor = { session: id, turn }
+				rowAnchor = undefined
+				safeReconcile('turn')			}
+			try {
+				window.document?.addEventListener?.('click', onDocumentClick, true)
+			} catch {
+				// A composition without the DOM listener is still a working router.
+			}
+
+			/**
+			 * The route health report: every layer this router knows about, the shape it is in right
+			 * now, and everything it refused to touch. Reachable as `window.__dshUrlRouter.report()`
+			 * — a debug seam, so it never throws and never writes anything.
+			 * @returns {object} the report.
+			 */
+			const report = () => {
+				const current = attemptValue(() => canonical())
+				const document = window.document
+				const count = selector => attemptValue(() => document?.querySelectorAll?.(selector)?.length) ?? '\u2014'
+				return {
+					version: ROUTER_VERSION,
+					hash: attemptValue(() => host.readLocation().hash) ?? '',
+					canonical: current === undefined ? null : { kind: current.kind, id: current.id, inner: innerPath(current.inner) },
+					link: linked === undefined ? null : { hash: routeHash(linked.kind, linked.id, linked.inner), attempts: { panel: panelAttempts, inner: innerAttempts } },
+					surfaces: {
+						conversationRows: count(`[data-row-key^="${ROW_KEY_PREFIX}"]`),
+						workspaceRows: count(`[data-row-key^="${WORKSPACE_ROW_PREFIX}"]`),
+						viewTabs: count(`[${CONVERSATION_TABS_ATTRIBUTE}]`),
+						viewIds: attemptValue(() => host.conversationViewIds?.()) ?? [],
+						turns: count(`[${TURN_ATTRIBUTE}]`),
+						trajectoryRows: count(`[${TRAJECTORY_ROW_ATTRIBUTE}]`),
+						turnBoundaries: count(`[${TRAJECTORY_TURN_START_ATTRIBUTE}]`),
+						pluginPackages: count('[data-plugin-package]'),
+						officialItems: count('[data-plugin-item]'),
+						settingsOverlay: count(`[${SETTINGS_SURFACE_ATTRIBUTE}="${SETTINGS_SURFACE_VALUE}"]`),
+						settingsSection: attemptValue(() => host.activeSettingsSection()) ?? null,
+						taskBoardOpen: count(`[${TASK_BOARD_OPEN_ATTRIBUTE}]`),
+						taskBoardNew: count(`[${TASK_BOARD_NEW_ATTRIBUTE}]`),
+						paneActive: attemptValue(() => host.activePaneKind()) ?? null,
+						paneKinds: attemptValue(() => host.paneKinds?.()) ?? null,
+					},
+					compat: observed.compat,
+					foreignFragment: observed.foreignFragment,
+					ignoredKinds: observed.ignored,
+					warnings: observed.warnings,
+				}
+			}
+			guard(() => {
+				window.__dshUrlRouter = { version: ROUTER_VERSION, report, when: host.now() }
+			})
+
 			return () => {
 				disposed = true
+				try {
+					window.document?.removeEventListener?.('click', onDocumentClick, true)
+				} catch {
+					// Nothing to undo when the listener was never attached.
+				}
 				dropTimer()
 				dropRetry()
 				offPanel()
@@ -630,7 +1247,13 @@ window.__ModuleLoader__.load({
 		function enhanceRow(document, row, openSession) {
 			const id = sessionIdOfRow(row)
 			if (id === undefined) return false
-			return mountAnchor(document, row, routeHash('session', id), () => openSession(id))
+			// The workspace the row sits under leads the link, so a copied link says where the
+			// conversation lives. No workspace row in the tree means no guess: the plain route.
+			const workspaceName = workspaceNameOf(row, document)
+			const href = workspaceName === undefined
+				? routeHash('session', id)
+				: routeHash('workspace', workspaceName, innerPath([WORKSPACE_SESSION_SEGMENT, id]))
+			return mountAnchor(document, row, href, () => openSession(id))
 		}
 
 		/**
@@ -761,7 +1384,7 @@ window.__ModuleLoader__.load({
 		// browser wiring: probe the official faces, then drive the machine.
 		// ---------------------------------------------------------------------
 		/** Services this plugin needs before apply runs; `layout` is optional and read through `ctx.get`. */
-		const inject = ['sessions', 'workspaces', 'uiWorkspace', 'slots']
+		const inject = ['sessions', 'workspaces', 'uiWorkspace', 'slots', 'sidebarRightTabs']
 
 		/**
 		 * Probe the faces the router needs.
@@ -796,6 +1419,9 @@ window.__ModuleLoader__.load({
 			const panels = typeof panelInfo?.getSnapshot === 'function' && typeof panelInfo?.subscribe === 'function' ? panelInfo : undefined
 			const selectPanel = typeof layout?.selectPanel === 'function' ? layout.selectPanel.bind(layout) : undefined
 			const beginNavigation = typeof layout?.beginNavigation === 'function' ? layout.beginNavigation.bind(layout) : undefined
+			const openRightbar = typeof layout?.openRightbar === 'function' ? layout.openRightbar.bind(layout) : undefined
+			const sidebarRightTabs = typeof scope.get === 'function' ? scope.get('sidebarRightTabs') : undefined
+			const sidebarRight = typeof scope.get === 'function' ? scope.get('sidebarRight') : undefined
 			return {
 				faces: {
 					catalog: list,
@@ -803,6 +1429,9 @@ window.__ModuleLoader__.load({
 					openSession: id => openSession.call(navigation, id),
 					selectPanel: selectPanel === undefined ? undefined : id => selectPanel(id),
 					beginNavigation: beginNavigation === undefined ? undefined : () => beginNavigation(),
+				openRightbar: openRightbar === undefined ? undefined : track => openRightbar(track),
+				sidebarRightTabs,
+				sidebarRight,
 					panels,
 					slots,
 				},
@@ -832,6 +1461,24 @@ window.__ModuleLoader__.load({
 			}
 			return {
 				mainViewSessionId: () => attempt(() => mainViewSessionId(faces.catalog.getSnapshot().byId), undefined),
+				// The sidebar lists workspaces and their sessions in one tree, in order, so the
+				// workspace a conversation belongs to is the nearest workspace row before it.
+				workspaceNameOf: sessionId => {
+					const rows = window.document?.querySelectorAll?.('[data-row-key]')
+					if (rows === undefined || rows === null) return undefined
+					let name
+					for (const row of rows) {
+						const key = typeof row.getAttribute === 'function' ? row.getAttribute('data-row-key') : null
+						if (typeof key !== 'string') continue
+						if (key.startsWith(WORKSPACE_ROW_PREFIX)) {
+							name = (row.textContent ?? '').trim()
+							continue
+						}
+						if (key !== `${ROW_KEY_PREFIX}${sessionId}`) continue
+						return name === undefined || name === '' ? undefined : name
+					}
+					return undefined
+				},
 				activePanelId: () => (faces.panels === undefined ? undefined : attempt(() => faces.panels.getSnapshot()?.activePanelId, undefined)),
 				// The panel that owns inner pages advertises them with a data attribute; the
 				// router only reads it, never the panel's internals.
@@ -914,6 +1561,283 @@ window.__ModuleLoader__.load({
 				openSession: id => {
 					attempt(() => faces.openSession(id))
 				},
+				// A row's own identity, in the shape the trajectory views publish it. The value is a
+				// percent-encoded NUL-separated triple, so the route can read as a plain path.
+				rowIdentityOf: element => {
+					let node = element
+					for (let depth = 0; node !== null && node !== undefined && depth < 12; depth += 1, node = node.parentElement) {
+						if (typeof node.getAttribute !== 'function') break
+						const key = node.getAttribute(TRAJECTORY_ROW_ATTRIBUTE)
+						if (typeof key === 'string' && key !== '') {
+							const parts = key.split('%00').map(part => part.trim()).filter(part => part !== '')
+							if (parts.length >= 2) return parts
+						}
+						const turn = node.getAttribute(TRAJECTORY_TURN_ATTRIBUTE)
+						if (typeof turn === 'string' && turn.trim() !== '') return [TURN_SEGMENT, turn.trim()]
+					}
+					return undefined
+				},
+				// The turn a row belongs to, but only when it is *provable*: the trajectory view
+				// virtualizes, so the evidence is a turn boundary rendered before the row, and that is
+				// trustworthy exactly when the next boundary is also rendered after it. Otherwise the
+				// answer is undefined — never a guess.
+				turnOfRow: element => {
+					if (typeof element?.compareDocumentPosition !== 'function') return undefined
+					const boundaries = window.document?.querySelectorAll?.(`[${TRAJECTORY_TURN_START_ATTRIBUTE}]`)
+					if (boundaries === undefined || boundaries === null || boundaries.length === 0) return undefined
+					const following = window.Node?.DOCUMENT_POSITION_FOLLOWING ?? 4
+					const preceding = window.Node?.DOCUMENT_POSITION_PRECEDING ?? 2
+					let before
+					let after
+					for (const boundary of boundaries) {
+						const position = attemptValue(() => element.compareDocumentPosition(boundary)) ?? 0
+						const turn = (boundary.getAttribute?.(TRAJECTORY_TURN_START_ATTRIBUTE) ?? '').trim()
+						if (turn === '') continue
+						if ((position & following) !== 0) after ??= turn
+						if ((position & preceding) !== 0) before = turn
+					}
+					if (before === undefined || after === undefined || before === after) return undefined
+					return before
+				},
+				// Best effort: scroll to the named row when it is rendered.
+				revealRow: parts => {
+					const wanted = innerPath(parts)
+					const document = window.document
+					if (wanted[0] === ROW_SEGMENT && wanted.length >= 3) {
+						const key = wanted.slice(1).join('%00')
+						for (const candidate of document?.querySelectorAll?.(`[${TRAJECTORY_ROW_ATTRIBUTE}]`) ?? []) {
+							if (candidate.getAttribute?.(TRAJECTORY_ROW_ATTRIBUTE) !== key) continue
+							attempt(() => candidate.scrollIntoView?.({ block: 'center' }))
+							return true
+						}
+						return false
+					}
+					if (wanted[0] === TURN_SEGMENT) {
+						for (const candidate of document?.querySelectorAll?.(`[${TRAJECTORY_TURN_ATTRIBUTE}]`) ?? []) {
+							if (candidate.getAttribute?.(TRAJECTORY_TURN_ATTRIBUTE) !== wanted[1]) continue
+							attempt(() => candidate.scrollIntoView?.({ block: 'center' }))
+							return true
+						}
+					}
+					return false
+				},
+				// Which conversation view is showing. The registry is the source of truth for ids
+				// (`ctx.uiConversation.views`), the header renders its tabs in registration order,
+				// and the active tab is the aria-selected one — so the position maps to an id.
+				activeConversationView: () => {
+					// One selector at a time: the container first, then its tabs inside it.
+					const row = window.document?.querySelector?.(`[${CONVERSATION_TABS_ATTRIBUTE}]`)
+					const tabs = typeof row?.querySelectorAll === 'function' ? row.querySelectorAll('[role="tab"]') : undefined
+					if (tabs === undefined || tabs === null || tabs.length === 0) return undefined
+					let index = -1
+					for (let position = 0; position < tabs.length; position += 1) {
+						const tab = tabs[position]
+						if (typeof tab.getAttribute !== 'function') continue
+						if (tab.getAttribute('aria-selected') !== 'true') continue
+						index = position
+						break
+					}
+					if (index < 0) return undefined
+					const ids = conversationViewIdsOf(faces)
+					if (ids === undefined || ids.length !== tabs.length) return undefined
+					return { id: ids[index], index, total: ids.length }
+				},
+				openConversationView: viewId => {
+					const row = window.document?.querySelector?.(`[${CONVERSATION_TABS_ATTRIBUTE}]`)
+					const tabs = typeof row?.querySelectorAll === 'function' ? row.querySelectorAll('[role="tab"]') : undefined
+					if (tabs === undefined || tabs === null) return
+					const ids = conversationViewIdsOf(faces)
+					if (ids === undefined) return
+					const index = ids.indexOf(viewId)
+					const tab = index < 0 ? undefined : tabs[index]
+					if (typeof tab?.click === 'function') attempt(() => tab.click())
+				},
+				// The right-hand pane names the tab in front. The service is the source of truth;
+				// the DOM marker is a fallback for a composition where the service is absent.
+				rightBarSessionId: () => rightBarSessionIdOf(window.document),
+				activePaneTab: () => activePaneTabOf(window.document),
+				activePaneKind: () => {
+					// Both services answer `active`; the controller is authoritative when it does, and
+					// `active` may be exposed as a value or as a method. Neither exposes `getSnapshot`.
+					// `active` can be a string, a tab descriptor or a method returning either, and the
+					// bar's own tab objects carry the kind under a few plausible names.
+					const kindOf = value => {
+						if (typeof value === 'string') return value === '' ? undefined : value
+						if (value === null || typeof value !== 'object') return undefined
+						const nested = value.tab ?? value.entry ?? value.options
+						const candidates = [value.kind, value.id, value.tabId, value.name, nested?.kind, nested?.id]
+						for (const candidate of candidates) {
+							if (typeof candidate === 'string' && candidate !== '' && candidate !== 'pane1') return candidate
+						}
+						return undefined
+					}
+					const read = owner => {
+						if (owner === undefined || owner === null) return undefined
+						const value = typeof owner.active === 'function' ? attemptValue(() => owner.active()) : owner.active
+						const direct = kindOf(value)
+						if (direct !== undefined) return direct
+						const snapshot = attemptValue(() => (typeof owner.getSnapshot === 'function' ? owner.getSnapshot() : undefined))
+						return snapshot === undefined ? undefined : kindOf(snapshot.activeTabId ?? snapshot.activeTab ?? snapshot.active)
+					}
+					const fromStrip = activePaneTabOf(window.document, paneRegistryOf(faces))
+					if (fromStrip !== undefined) return fromStrip
+					const fromController = read(faces.sidebarRight)
+					if (fromController !== undefined) return fromController
+					const fromRegistry = read(faces.sidebarRightTabs)
+					if (fromRegistry !== undefined) return fromRegistry
+					// DOM fallback, deliberately narrow: the active-pane marker is shared with the
+					// main dockkit, so it only counts when it really belongs to the right bar.
+					const active = window.document?.querySelector?.('[data-dockkit-pane-active]')
+					if (active === null || active === undefined) return undefined
+					const own = typeof active.getAttribute === 'function' ? active.getAttribute('data-sidebar-right-tab') : null
+					if (typeof own === 'string' && own !== '') return own
+					const inside = typeof active.querySelector === 'function' ? active.querySelector('[data-sidebar-right-tab]') : null
+					const inner = typeof inside?.getAttribute === 'function' ? inside.getAttribute('data-sidebar-right-tab') : null
+					return typeof inner === 'string' && inner !== '' ? inner : undefined
+				},
+				// The section the overlay shows: the nav item the platform marks aria-current.
+				// One selector at a time (a comma list is beyond a small DOM stub) and the `nav`
+				// ancestor check keeps unrelated aria-current controls out of it.
+				activeSettingsSection: () => {
+					const overlay = window.document?.querySelector?.(`[${SETTINGS_SURFACE_ATTRIBUTE}="${SETTINGS_SURFACE_VALUE}"]`)
+					if (overlay === null || overlay === undefined || typeof overlay.querySelectorAll !== 'function') return undefined
+					for (const candidate of overlay.querySelectorAll('button')) {
+						if (typeof candidate.getAttribute !== 'function') continue
+						if (candidate.getAttribute('aria-current') !== 'true') continue
+						if (typeof candidate.closest === 'function' && candidate.closest('nav') === null) continue
+						const label = (candidate.textContent ?? '').trim()
+						if (label !== '') return label
+					}
+					return undefined
+				},
+				// The tab a settings section is showing: the same ARIA contract one level deeper.
+				activeSettingsTab: () => {
+					const overlay = window.document?.querySelector?.(`[${SETTINGS_SURFACE_ATTRIBUTE}="${SETTINGS_SURFACE_VALUE}"]`)
+					if (overlay === null || overlay === undefined || typeof overlay.querySelectorAll !== 'function') return undefined
+					for (const candidate of overlay.querySelectorAll('[role="tab"]')) {
+						if (typeof candidate.getAttribute !== 'function') continue
+						if (candidate.getAttribute('aria-selected') !== 'true') continue
+						const label = (candidate.textContent ?? '').trim()
+						if (label !== '') return label
+					}
+					return undefined
+				},
+				openSettings: (section, tab) => {
+					if (typeof section === 'string' && section !== '') {
+						// A section is named by the label the user reads, so the request is a label match.
+						const overlay = window.document?.querySelector?.(`[${SETTINGS_SURFACE_ATTRIBUTE}="${SETTINGS_SURFACE_VALUE}"]`)
+						const scope = overlay ?? window.document
+						if (typeof scope?.querySelectorAll === 'function') {
+							const candidates = [...scope.querySelectorAll('button')].filter(candidate => {
+								if (typeof candidate.closest === 'function' && candidate.closest('nav') === null) return false
+								return (candidate.textContent ?? '').trim() !== ''
+							})
+							const wanted = section.trim().toLowerCase()
+							const match = candidates.find(candidate => (candidate.textContent ?? '').trim().toLowerCase() === wanted)
+							if (match !== undefined && typeof match.click === 'function') {
+								attempt(() => match.click())
+								// The section may own tabs: a named one is clicked once the section is up.
+								if (typeof tab === 'string' && tab !== '') {
+									const wantedTab = tab.trim().toLowerCase()
+									const tabs = [...scope.querySelectorAll('[role="tab"]')]
+									const matchTab = tabs.find(candidate => (candidate.textContent ?? '').trim().toLowerCase() === wantedTab)
+									if (matchTab !== undefined && typeof matchTab.click === 'function') attempt(() => matchTab.click())
+								}
+								return
+							}
+						}
+					}
+					const slot = window.document?.querySelector?.(`[data-slot="${SETTINGS_TRIGGER_SLOT}"]`)
+					const button =
+						(typeof slot?.querySelector === 'function' ? slot.querySelector('button') : null) ??
+						(typeof slot?.closest === 'function' ? slot.closest('button') : null)
+					if (typeof button?.click === 'function') {
+						attempt(() => button.click())
+						return
+					}
+					// Fallback for a composition without that slot: the labelled entry.
+					const labelled = typeof window.document?.querySelectorAll === 'function'
+						? [...window.document.querySelectorAll('button')].find(candidate => /^(settings|设置)$/i.test((candidate.textContent ?? '').trim()))
+						: undefined
+					if (typeof labelled?.click === 'function') attempt(() => labelled.click())
+				},
+				openPane: (kind, track, warn) => {
+					if (typeof kind !== 'string' || kind === '') return
+					// A pane link is a claim like any other, so it is checked before it is made: the
+					// registry names every kind the bar can show, and asking for one it does not know
+					// would leave the link sitting there doing nothing. (Measured live: guide,
+					// subagentchat, changes-review, plan, files, text, terminal.)
+					const known = attemptValue(() => paneRegistryOf(faces))?.map(row => row.kind)
+					if (Array.isArray(known) && !known.includes(kind)) {
+						warn(`${TAG} the right bar has no pane type "${kind}"; it knows: ${known.join(', ')}`)
+						return
+					}
+					// `openTab(kind, options)` belongs to the controller (`sidebarRight`); the registry
+					// only knows the kinds. Asking the registry to open one fails silently.
+					const controller = faces.sidebarRight
+					// Present the right column first: a session's store is adopted only once the bar is
+					// shown, and every open on an unadopted session is a silent no-op.
+					const expanded = attemptValue(() => (typeof controller?.isExpanded === 'function' ? controller.isExpanded() : undefined))
+					if (expanded === false) {
+						const wanted = typeof track === 'string' && track !== '' ? track : (attemptValue(() => faces.mainViewSessionId()) !== undefined ? 'session' : 'panel')
+						attempt(() => faces.openRightbar?.(wanted))
+					}
+					const session = rightBarSessionIdOf(window.document)
+					const expand = () => {
+						const expanded = attemptValue(() => (typeof controller?.isExpanded === 'function' ? controller.isExpanded() : true))
+						if (expanded === false) attempt(() => controller?.toggleExpanded?.())
+					}
+					if (controller !== undefined && controller !== null) {
+						// The controller a root plugin reaches is not "mounted" for a session, and `openTab(kind)`
+						// throws exactly then ("no session surface is mounted") — so the per-session path is the
+						// real one, and it takes the session **first**: `openTabIn(sessionId, kind, options)`.
+						// (Passed the other way round it looks up a session called "files" and does nothing.)
+						const opened = attemptValue(() => {
+							if (typeof controller.openTabIn === 'function' && typeof session === 'string' && session !== '') {
+								controller.openTabIn(session, kind, {})
+								return true
+							}
+							if (typeof controller.openTab === 'function') {
+								controller.openTab(kind, {})
+								return true
+							}
+							return false
+						})
+						if (opened === true) {
+							expand()
+							return
+						}
+
+					}
+					// Last resort: the same action the right bar's empty-state card runs. It is the
+					// bar's own "open this kind" entry, so using it is not a workaround.
+					const guides = attemptValue(() => {
+						const registry = faces.sidebarRightTabs
+						if (registry === undefined || registry === null) return undefined
+						const rows = typeof registry.guideEntries === 'function' ? registry.guideEntries() : registry.guideEntries
+						if (Array.isArray(rows)) return rows
+						const guide = typeof registry.guide === 'function' ? registry.guide() : registry.guide
+						return Array.isArray(guide) ? guide : undefined
+					})
+					if (!Array.isArray(guides)) return
+					for (const entry of guides) {
+						if (entry === null || typeof entry !== 'object') continue
+						const entryKind = entry.kind ?? entry.options?.kind ?? entry.id
+						if (typeof entryKind !== 'string' || entryKind !== kind) continue
+						const run = entry.onPick ?? entry.action ?? entry.select ?? entry.open ?? entry.run
+						if (typeof run === 'function') {
+							attempt(() => run())
+							expand()
+							return
+						}
+					}
+				},
+				// The kinds the bar can show: link targets are checked against this before claiming.
+				paneKinds: () => paneRegistryOf(faces)?.map(row => row.kind),
+				// The rows the registry publishes, for the report and for the drive's check.
+				paneRegistry: () => paneRegistryOf(faces),
+				// The conversation view ids the registry publishes, for the report.
+				conversationViewIds: () => conversationViewIdsOf(faces),
 				beginNavigation: () => {
 					if (faces.beginNavigation === undefined) return
 					attempt(() => faces.beginNavigation())
@@ -953,6 +1877,12 @@ window.__ModuleLoader__.load({
 								'data-plugin-row-detail',
 								TASK_BOARD_OPEN_ATTRIBUTE,
 								TASK_BOARD_NEW_ATTRIBUTE,
+								// Switching a settings section only moves this marker, so it must be
+								// watched or the address bar keeps the section it saw first.
+								'aria-current',
+								// Switching a settings *tab* moves this one, for the same reason.
+								'aria-selected',
+								SETTINGS_SURFACE_ATTRIBUTE,
 							],
 						})
 						return () => observer.disconnect()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-url-router",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "DSH Web GUI 地址栏路由插件：每个界面都有自己的链接（会话 / 主面板 / 插件页与组件页 / 任务看板），整行即真链接，只写 fragment。",
   "repository": {
     "type": "git",
@@ -29,7 +29,8 @@
         "@deepseek-ai/dsh-api-session-controller",
         "@deepseek-ai/dsh-api-workspace-controller",
         "@deepseek-ai/dsh-client-ui-workspace",
-        "@deepseek-ai/dsh-client-ui-layout"
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar-right"
       ]
     },
     "compatibility": {