dsh-url-router 0.1.2 → 0.2.0

package/AGENTS.md

@@ -13,6 +13,8 @@
 
 - **本插件是地址栏的唯一写者**。任何其它写 fragment 的插件都不得同时启用（`dsh-session-url` 就是这样一个插件）。
 - **段位**：`#/session/<id>`（会话，`uiWorkspace.openSession`）、`#/panel/<panelId>`（主面板，`ctx.layout.selectPanel`）。输入侧接受复数与百分号编码，规范化成单数形式；**不认识的段位一律不碰**，只留一条诊断。
+- **工作区路线**：`#/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 +33,15 @@
 - **观察者的 `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 桩可能不支持 ✓）。驱动侧只开会话 + 一条说明 ✓（官方没有对外跳转接缝 ✗）。
+- **右栏 pane 走 `sidebarRightTabs` 服务**：`activeTabId` 读 ✓、`openTab(kind)` 驱动 ✓；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` 读取。

package/README.md

@@ -54,13 +54,17 @@ dsh plugin --profile web add "link:/path/to/dsh-url-router"
 - **只动 fragment**：路径与查询串从不改写（启动 `?token=…` 能活下来）。
 - **唯一写者**：本插件拥有 fragment，请**不要**和别的写 fragment 的插件同时启用（例如 `dsh-session-url`），两者会互相覆盖。
 - **只用 `replaceState`**：浏览面板不污染后退栈。
+- **工作区是"它住在哪"，所以写在链接最前面** ✓：`#/workspace/<工作区名>/session/<会话id>`（侧栏本身就是这个形状 ✓）。工作区名是**给眼睛看的** ✓ —— 决定打开哪个会话的永远是会话 id ✓，所以**名字过期/写错也照样打开对的会话** ✓（地址栏随后自己纠正成真实工作区 ✓）。读不到工作区行（没有侧栏 / 树里没有）就**不猜** ✓，退回 `#/session/<id>` ✓。
 - **作用域由视图决定，不靠猜**：主面板是应用级界面（列的是本机插件，不是某个对话），所以它的链接不带会话 id。
 - **链接落地即交权**：视图一旦变成链接描述的那个界面，链接立刻失去权威——这样你在面板里继续点进去时，地址栏不会被拽回上一层。
 - **绝不抛错**：官方 `selectPanel` 对未注册的面板 id 是抛异常的；所有宿主面调用都被容纳，失败只留一条诊断并回落到屏幕上真实的视图。
 
 ### 已知限制
 
-- **设置页分区暂未纳入**：设置包没有"打开某个分区"的接缝（它们是 keyed list slot），只能等它自己发布类似契约。
+- **轮次链接是"位置"不是"界面"**：点某一轮，地址栏记下 `#/session/<id>/turn/<n>` ✓；但**粘贴它只会打开那个对话，不会滚到那一轮** ✗ —— 官方把"跳到某轮"（`scrollToTurn` / `JUMP_PAGE_OPTIONS`）留在 chat 包**内部**，没有对外接缝 ✗，逐页翻也不可靠 ✗（实测「Load earlier」按钮在两个会话上都没加载出更早的轮次 ✗）。要真跳转，需要官方开一个服务或槽位 ✓。
+- **右栏 pane 已接入但未真机验证**：`#/panel/<面板>/pane/<页签 kind>` ✓（读 `sidebarRightTabs` 的 `activeTabId` ✓，驱动用它的 `openTab` ✓）。**注意**：本机组合里右栏没有任何页签注册 ✗，所以只跑过单测 ✓；页签 kind 由注册方决定 ✓（例如官方 `-files` / `-terminal` / `-browser` / `-documentpreview` 包注册的那些 ✓）。
+- **设置面板已纳入**：`#/settings` ✓、**`#/settings/<分区>`** ✓、**`#/settings/<分区>/<页签>`** ✓（页签靠标准 `role="tab"` + `aria-selected` ✓，分区内任何页签都吃这一套 ✓）。分区**没有稳定 id** ✗（实测：导航项上只有 `aria-current="true"` ✓，父链是 `nav` ✓，右侧内容区一个 `data-*` 都没有 ✗；官方内部的 `openSection(id)` 也不对外 ✗）→ 所以**分区的身份就是它的显示名** ✓：反映读「`aria-current="true"` 且属于 `nav`」的那个按钮的**标签文字** ✓，驱动按标签点 ✓。含义：**换语言或官方改文案后，旧的分区链接会失效** ✗（但你重新点一次，地址栏就会写出新链接 ✓ —— 自洽、不过期 ✓）。裸 `#/settings` 只要面板开着就算落地 ✓，随后地址栏自动升级为具体分区 ✓。
+- **设置页分区暂未纳入（旧描述）**：设置包没有"打开某个分区"的接缝（它们是 keyed list slot），只能等它自己发布类似契约。
 - **右栏 pane 与会话内轮次/消息锚点暂未纳入**。
 - **技能中心 / SSH 的内部页**：需要它们各自发布"当前实体 id + 按 id 打开"的契约（任务看板就是这么做的）。
 - 链接**同名不跨机**：会话 id 只在同一台机器、同一个 `DSH_HOME` 下有意义。

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,47 @@ 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:'
+		/** 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. */
 		const TAG = '[url-router]'
 
+		/**
+		 * 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
+		}
+
 		/**
 		 * Read a route out of a location fragment.
 		 * @param {string} hash - the raw `window.location.hash`, including the leading `#`.
@@ -103,13 +145,37 @@ window.__ModuleLoader__.load({
 		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]}` }
+				return { kind: 'workspace', id: name, inner: innerPath([WORKSPACE_SESSION_SEGMENT, sessionId]) }
+			}
 			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 +189,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 +306,8 @@ 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. */
+			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). */
@@ -255,9 +335,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 +358,48 @@ 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.
+					const workspaceName = host.workspaceNameOf(id)
+					if (workspaceName !== undefined) {
+						return { kind: 'workspace', id: workspaceName, inner: innerPath([WORKSPACE_SESSION_SEGMENT, id]) }
+					}
+					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;
+					// 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
 			}
-			const sameRoute = (left, right) => routeKey(left) === routeKey(right)
+			// 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.
+			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]
+				}
+				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 === ''
+			}
 			/** Write the fragment for the current view, leaving path and query untouched. */
 			const reflect = route => {
 				const { pathname, search, hash } = host.readLocation()
@@ -313,7 +442,51 @@ window.__ModuleLoader__.load({
 					reflect(canonical())
 					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) {
+					if (source !== 'hash' && innerAttempts < INNER_ATTEMPT_LIMIT) {
+						innerAttempts += 1
+						host.openPane(innerPath(linked.inner)[1])
+					}
+					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 (source !== 'hash' && innerAttempts < INNER_ATTEMPT_LIMIT) {
+							innerAttempts += 1
+							host.openPane(innerPath(linked.inner)[1])
+						}
+						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.
@@ -434,8 +607,42 @@ 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
+				const node = target.closest(`[${TURN_ATTRIBUTE}]`)
+				if (node === null) 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 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')
+			}
+			try {
+				window.document?.addEventListener?.('click', onDocumentClick, true)
+			} catch {
+				// A composition without the DOM listener is still a working router.
+			}
+
 			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 +837,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 +974,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 +1009,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 +1019,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 : () => openRightbar(),
+				sidebarRightTabs,
+				sidebarRight,
 					panels,
 					slots,
 				},
@@ -832,6 +1051,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 +1151,100 @@ window.__ModuleLoader__.load({
 				openSession: id => {
 					attempt(() => faces.openSession(id))
 				},
+				// 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.
+				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
+					}
+					// 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 => {
+					if (typeof kind !== 'string' || kind === '') return
+					const face = faces.sidebarRightTabs ?? faces.sidebarRight
+					if (face !== undefined && typeof face.openTab === 'function') {
+						attempt(() => face.openTab(kind))
+						return
+					}
+					attempt(() => faces.openRightbar?.())
+				},
 				beginNavigation: () => {
 					if (faces.beginNavigation === undefined) return
 					attempt(() => faces.beginNavigation())
@@ -953,6 +1284,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.2.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": {