dsh-url-router 0.2.0 → 0.3.0

package/AGENTS.md

@@ -13,6 +13,10 @@
 
 - **本插件是地址栏的唯一写者**。任何其它写 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；只有会话级视图才写会话。
@@ -41,7 +45,14 @@
 - **`aria-current` 必须在 DOM 观察者的 `attributeFilter` 里** ✓：切换分区只改这一个属性 ✓，漏了它地址栏就永远停在第一次看到的分区（历史 bug ✓）。
 - **裸 `#/settings` 立即可落地**（`sameRoute` 的定向例外 ✓）：分区是那个表面的细化、不是另一个表面 ✓；但**两个命名分区之间仍然算不同** ✓（否则分区链接就不驱动了 ✓）。
 - **轮次锚点是"位置"，只做反映**：点击聊天里的一轮（`[data-chat-turn]` ✓）把轮号写进地址栏 ✓；**绝不 preventDefault** ✗、**绝不碰交互元素**（button/a/input/textarea/select/[role=button]/[contenteditable] ✓ —— 逐个 `closest`，不用逗号选择器 ✓，因为小 DOM 桩可能不支持 ✓）。驱动侧只开会话 + 一条说明 ✓（官方没有对外跳转接缝 ✗）。
-- **右栏 pane 走 `sidebarRightTabs` 服务**：`activeTabId` 读 ✓、`openTab(kind)` 驱动 ✓；DOM 兜底必须**只认真正属于右栏**的标记 ✓（`data-dockkit-pane-active` 是主区共用的 ✗，历史踩过 ✓）。该服务已加进 `inject` ✓ 与包声明的官方模块 id ✓。
+- **右栏根上有 `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` 读取。
@@ -49,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,6 +54,9 @@ 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。
 - **链接落地即交权**：视图一旦变成链接描述的那个界面，链接立刻失去权威——这样你在面板里继续点进去时，地址栏不会被拽回上一层。
@@ -62,17 +65,22 @@ dsh plugin --profile web add "link:/path/to/dsh-url-router"
 ### 已知限制
 
 - **轮次链接是"位置"不是"界面"**：点某一轮，地址栏记下 `#/session/<id>/turn/<n>` ✓；但**粘贴它只会打开那个对话，不会滚到那一轮** ✗ —— 官方把"跳到某轮"（`scrollToTurn` / `JUMP_PAGE_OPTIONS`）留在 chat 包**内部**，没有对外接缝 ✗，逐页翻也不可靠 ✗（实测「Load earlier」按钮在两个会话上都没加载出更早的轮次 ✗）。要真跳转，需要官方开一个服务或槽位 ✓。
-- **右栏 pane 已接入但未真机验证**：`#/panel/<面板>/pane/<页签 kind>` ✓（读 `sidebarRightTabs` 的 `activeTabId` ✓，驱动用它的 `openTab` ✓）。**注意**：本机组合里右栏没有任何页签注册 ✗，所以只跑过单测 ✓；页签 kind 由注册方决定 ✓（例如官方 `-files` / `-terminal` / `-browser` / `-documentpreview` 包注册的那些 ✓）。
+- **右栏 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），只能等它自己发布类似契约。
-- **右栏 pane 与会话内轮次/消息锚点暂未纳入**。
+- **会话内的轮次与行锚点已纳入** ✓：`#/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".
@@ -98,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
 
@@ -115,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

@@ -90,6 +90,22 @@ window.__ModuleLoader__.load({
 		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). */
@@ -103,8 +119,53 @@ window.__ModuleLoader__.load({
 		/** 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.
@@ -129,6 +190,135 @@ window.__ModuleLoader__.load({
 			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 `#`.
@@ -142,6 +332,24 @@ 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
@@ -159,7 +367,14 @@ window.__ModuleLoader__.load({
 				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]}` }
-				return { kind: 'workspace', id: name, inner: innerPath([WORKSPACE_SESSION_SEGMENT, sessionId]) }
+				// 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() ?? ''
@@ -307,6 +522,11 @@ window.__ModuleLoader__.load({
 			/** 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
@@ -328,6 +548,7 @@ window.__ModuleLoader__.load({
 				claimed = false
 				panelAttempts = 0
 				innerAttempts = 0
+				paneOpenedFor = undefined
 				dropTimer()
 			}
 			/**
@@ -363,13 +584,30 @@ window.__ModuleLoader__.load({
 					// 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]) }
+						return { kind: 'workspace', id: workspaceName, inner: innerPath([WORKSPACE_SESSION_SEGMENT, id, ...position, ...tail]) }
 					}
-					const pane = host.activePaneKind()
-					if (pane !== undefined) return { kind: 'session', id, inner: innerPath([PANE_SEGMENT, pane]) }
-					// The turn the user last pointed at is a position inside this conversation;
+					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]) }
@@ -383,22 +621,55 @@ window.__ModuleLoader__.load({
 			// 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.
-			const sameRoute = (left, right) => {
-				if (routeKey(left) === routeKey(right)) return true
-				// A workspace route is about the conversation it names; the workspace name is what the
-				// link *shows*, so a stale name must not keep the link from landing.
-				if (left?.kind === 'workspace' || right?.kind === 'workspace') {
-					if (left?.kind !== right?.kind) return false
-					return innerPath(left.inner)[1] === innerPath(right.inner)[1]
+			// 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 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 (left?.kind !== 'settings' || right?.kind !== 'settings') return false
-				if (left.id === '' || right.id === '') return true
-				// One level deeper: the same section is satisfied while a link names no tab, but a
-				// link that names a tab has to see that tab.
-				if (left.id !== right.id) return false
-				const leftTab = innerPath(left.inner)[0] ?? ''
-				const rightTab = innerPath(right.inner)[0] ?? ''
-				return leftTab === '' || rightTab === ''
+				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 => {
@@ -407,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
@@ -422,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
@@ -442,6 +732,40 @@ 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.
@@ -463,9 +787,16 @@ window.__ModuleLoader__.load({
 					return
 				}
 				if (linked.kind === 'session' && linked.inner !== undefined && innerPath(linked.inner)[0] === PANE_SEGMENT) {
-					if (source !== 'hash' && innerAttempts < INNER_ATTEMPT_LIMIT) {
+					// 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
-						host.openPane(innerPath(linked.inner)[1])
+						paneOpenedFor = wantedPane
+						host.openPane(wantedPane, linked.kind === 'panel' ? 'panel' : 'session', message => host.warn(message))
 					}
 					armRetry()
 					return
@@ -480,9 +811,9 @@ window.__ModuleLoader__.load({
 				}
 				if (linked.kind === 'panel') {
 					if (linked.inner !== undefined && innerPath(linked.inner)[0] === PANE_SEGMENT) {
-						if (source !== 'hash' && innerAttempts < INNER_ATTEMPT_LIMIT) {
+						if (innerAttempts < INNER_ATTEMPT_LIMIT) {
 							innerAttempts += 1
-							host.openPane(innerPath(linked.inner)[1])
+							host.openPane(innerPath(linked.inner)[1], linked.kind === 'panel' ? 'panel' : 'session', message => host.warn(message))
 						}
 						armRetry()
 						return
@@ -537,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')
@@ -546,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
 				}
@@ -615,27 +961,91 @@ window.__ModuleLoader__.load({
 				if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return
 				const target = event.target
 				if (typeof target?.closest !== 'function') return
-				const node = target.closest(`[${TURN_ATTRIBUTE}]`)
-				if (node === null) 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
-				const id = host.mainViewSessionId()
-				if (id === undefined) return
 				turnAnchor = { session: id, turn }
-				safeReconcile('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 {
@@ -1019,7 +1429,7 @@ 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 : () => openRightbar(),
+				openRightbar: openRightbar === undefined ? undefined : track => openRightbar(track),
 				sidebarRightTabs,
 				sidebarRight,
 					panels,
@@ -1151,15 +1561,130 @@ 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: () => {
-					const face = faces.sidebarRightTabs
-					if (face !== undefined) {
-						const snapshot = attempt(() => (typeof face.getSnapshot === 'function' ? face.getSnapshot() : undefined))
-						const active = snapshot === undefined ? undefined : snapshot.activeTabId ?? snapshot.activeTab ?? snapshot.active
-						if (typeof active === 'string' && active !== '') return active
+					// 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]')
@@ -1236,15 +1761,83 @@ window.__ModuleLoader__.load({
 						: undefined
 					if (typeof labelled?.click === 'function') attempt(() => labelled.click())
 				},
-				openPane: kind => {
+				openPane: (kind, track, warn) => {
 					if (typeof kind !== 'string' || kind === '') return
-					const face = faces.sidebarRightTabs ?? faces.sidebarRight
-					if (face !== undefined && typeof face.openTab === 'function') {
-						attempt(() => face.openTab(kind))
+					// 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
 					}
-					attempt(() => faces.openRightbar?.())
+					// `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())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-url-router",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "DSH Web GUI 地址栏路由插件：每个界面都有自己的链接（会话 / 主面板 / 插件页与组件页 / 任务看板），整行即真链接，只写 fragment。",
   "repository": {
     "type": "git",