dsh-url-router 0.4.1 → 0.4.3

package/lib/client.js

@@ -35,11 +35,26 @@
 
 window.__ModuleLoader__.load({
 	id: 'dsh-url-router',
-	factory: () => {
+	factory: require => {
 		const module = { exports: {} }
 		const exports = module.exports
 		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
 
+		// ---------------------------------------------------------------------
+		// React, when the module loader hands one over.
+		//
+		// Routing, the address bar and the row links are plain DOM, so a host without
+		// React still gets every route. Only the plugin manager's settings card is a
+		// React component; without the runtime the card is not registered at all, and
+		// nothing else changes.
+		// ---------------------------------------------------------------------
+		let react
+		try {
+			react = typeof require === 'function' ? require('react') : undefined
+		} catch {
+			react = undefined
+		}
+
 		// ---------------------------------------------------------------------
 		// main-view session: resolve the Session the main view currently shows.
 		// Reads the catalog's rows rather than a per-id retain-info source, so this
@@ -63,7 +78,69 @@ 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', settings: 'settings', workspace: 'workspace', workspaces: 'workspace' }
+		const ROUTE_ALIASES = { session: 'session', sessions: 'session', panel: 'panel', panels: 'panel', settings: 'settings', power: 'power', workspace: 'workspace', workspaces: 'workspace' }
+		/**
+		 * The power actions a link may name, and the endpoint the power plugin publishes for each.
+		 *
+		 * These are *commands*, not places: a URL that carries one ends the whole application (or
+		 * restarts it), so a fragment that names one is honoured only when the reader typed it into
+		 * the address bar themselves — never when it arrived as a hash change from a link somebody
+		 * else wrote. `dsh-power-menu` already exposes both endpoints (`POST
+		 * /api/dsh-power-menu/{shutdown,restart}`), so no click and no cooperation is needed.
+		 */
+		const POWER_ACTIONS = { shutdown: 'shutdown', restart: 'restart' }
+		/**
+		 * The bases the power actions live under, in the order they are tried.
+		 *
+		 * Two packages publish the same two actions under different paths: the desktop build ships
+		 * `dsh-power-menu-mac` (`/api/dsh-power-menu-mac`) while the plain package uses
+		 * `/api/dsh-power-menu`. Measured 2026-10-29: posting to the wrong one is a silent 404, which
+		 * is exactly how "cannot restart" looked — so both are tried, and a wrong base costs nothing.
+		 */
+		const POWER_ACTION_BASES = ['/api/dsh-power-menu-mac', '/api/dsh-power-menu']
+		/**
+		 * How many drive steps the plugin's own menu gets before the endpoint is used instead.
+		 *
+		 * The drive retries every half second, so this is a couple of seconds: long enough for the
+		 * menu to render, short enough that a plugin which never publishes the item still acts.
+		 */
+		const POWER_ACTION_MENU_LIMIT = 4
+
+		/**
+		 * The power plugin's own menu, when it is on screen.
+		 *
+		 * Contract attribute first (`data-dshpm-menu`), then the class the plugin ships. Neither is
+		 * guessed at: an unreadable menu sends the drive down the endpoint fallback instead.
+		 * @param {object} document - the document.
+		 * @returns {object|undefined} the menu root.
+		 */
+		function powerMenuOf(document) {
+			const contracted = attemptValue(() => document?.querySelector?.('[data-dshpm-menu]'))
+			if (contracted !== undefined && contracted !== null) return contracted
+			const known = attemptValue(() => document?.getElementsByClassName?.('dshpm-menu')?.[0])
+			return known === undefined || known === null ? undefined : known
+		}
+
+		/**
+		 * The power action a route names, if any.
+		 * @param {string} id - the route's identity segment.
+		 * @returns {string|undefined} the action.
+		 */
+		function powerActionOf(id) {
+			if (typeof id !== 'string') return undefined
+			return Object.prototype.hasOwnProperty.call(POWER_ACTIONS, id) ? POWER_ACTIONS[id] : undefined
+		}
+		/**
+		 * The power menu: a transient popover rendered by a separate plugin, and the one surface
+		 * this router does not own. Its contract is an attribute; the class names are the fallback
+		 * for a build that has not added it yet.
+		 */
+		/** How many times one link may press the settings launcher while no menu appears. */
+		const SETTINGS_PRESS_LIMIT = 3
+		const POWER_MENU_ATTRIBUTE = 'data-dsh-power-menu'
+		const POWER_MENU_CLASS = 'dshpm-menu'
+		const POWER_TRIGGER_ATTRIBUTE = 'data-dsh-power-trigger'
+		const POWER_TRIGGER_CLASS = 'dshpm-trigger'
 		/** Attribute the settings overlay puts on its root element. */
 		const SETTINGS_SURFACE_ATTRIBUTE = 'data-dsh-surface'
 		/**
@@ -78,6 +155,8 @@ window.__ModuleLoader__.load({
 		const SETTINGS_SURFACE_VALUE = 'settings'
 		/** Slot the settings entry is rendered into (its button opens the overlay). */
 		const SETTINGS_TRIGGER_SLOT = 'sidebar.settings'
+		/** Slot the settings sections are registered into — the same list the shell renders. */
+		const SETTINGS_SECTION_SLOT = 'settings.section'
 		/** 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. */
@@ -122,23 +201,85 @@ window.__ModuleLoader__.load({
 		const TURN_SEGMENT = 'turn'
 		/** Inner segment that names the right-hand pane in front. */
 		const PANE_SEGMENT = 'pane'
+		/**
+		 * The parent of a subagent session, as a decoration after the session id.
+		 *
+		 * A subagent session is a session of its own (it opens, it has turns and links), but the
+		 * printed id says nothing about *whose* subagent it is. The catalog knows: the session
+		 * controller resolves a child's durable (parent, child) address without opening anything.
+		 * The parent is written like a workspace name — decoration, never the thing that lands.
+		 */
+		const SUBAGENT_SEGMENT = 'subagent-of'
+		/**
+		 * Segment names other parsers look for, so a decoration never becomes one.
+		 *
+		 * The parent of a subagent is written as a readable segment when the catalog has a title.
+		 * Those parsers (`viewIdOfRoute`, the turn/row/pane lookups) search by segment name, so a
+		 * title that *is* one of these names would be read as a position. Such a title falls back
+		 * to the parent id instead.
+		 */
+		const ROUTE_RESERVED_TOKENS = new Set(['turn', 'row', 'view', 'pane', 'subagent-of', 'provider', 'filter', 'task', 'rule', 'records', 'session', 'workspace', 'settings', 'panel'])
+		/** How long a title may be inside a route before it is clipped. */
+		const SUBAGENT_TITLE_LIMIT = 80
+		/**
+		 * Whether a route segment is a session id (a uuid, with or without the `session-` prefix).
+		 *
+		 * The subagent decoration is a title when the catalog has one and the parent id otherwise,
+		 * so the drive has to tell the two apart: an id is opened by address, anything else is a
+		 * label and the child is opened by its own id.
+		 * @param {unknown} value - the segment.
+		 * @returns {boolean} whether it reads as a session id.
+		 */
+		function isSessionIdLike(value) {
+			return typeof value === 'string' && /^(?:session-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value.trim())
+		}
+		/**
+		 * The readable name of a subagent's parent, or its id when there is no usable title.
+		 * @param {object} parent - `{ id, title }` from the catalog.
+		 * @returns {string} the segment to write.
+		 */
+		function subagentDecorationOf(parent) {
+			const title = typeof parent?.title === 'string' ? parent.title.trim().replace(/\s+/gu, ' ') : ''
+			const usable = title !== '' && !ROUTE_RESERVED_TOKENS.has(title.toLowerCase())
+			return usable ? title.slice(0, SUBAGENT_TITLE_LIMIT) : String(parent?.id ?? '')
+		}
 		/** 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'
+		/** Panel id of the automation-task manager, whose status filter and open task are routed. */
+		const SCHEDULES_PANEL_ID = 'schedules'
+		/** Inner segment that names the automation task a list has open. */
+		const TASK_SEGMENT = 'task'
+		/** Inner segment that names the model-provider card an open editor belongs to. */
+		const PROVIDER_SEGMENT = 'provider'
+		/** Inner segment that names the automation list's status filter. */
+		const FILTER_SEGMENT = 'filter'
+		/**
+		 * The status filters, in the fixed order the manager renders them.
+		 *
+		 * Its own source maps `["all", "active", "inactive"]` over the three buttons, and the
+		 * buttons carry no value of their own (only `aria-pressed`), so the position is the
+		 * identity — the same positional contract the conversation view tabs already use.
+		 */
+		const SCHEDULE_FILTERS = ['all', 'active', 'inactive']
+		/** Attribute the manager puts on a task-detail tab, whose value is `rule` or `records`. */
+		const SCHEDULE_TAB_ATTRIBUTE = 'data-detail-tab'
+		/** The right bar's own "collapsed" marker: its tabs stay mounted while the bar is shut. */
+		const RIGHT_BAR_COLLAPSED_ATTRIBUTE = 'data-rightbar-collapsed'
 		/** 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.4.1'
+		const ROUTER_VERSION = '0.4.3'
 		/**
 		 * Hand-maintained build marker, reported alongside the version. A working copy that is
 		 * linked into a profile serves this file straight from disk, so the package version
 		 * cannot say *which* copy a live window loaded — this can, and `report().build` is how a
 		 * real-machine check answers that. Bump it whenever a live window must be told apart.
 		 */
-		const ROUTER_BUILD = 'desktop-bar+settings-marker+modal-dismiss+mac-header-bar.2'
+		const ROUTER_BUILD = 'desktop-bar+settings-marker+modal-dismiss+mac-header-bar+bar-select-all+recent-links+copy-link+automation-links+page-over-pane+band-yield+provider-card+perf+compat+turn-jump+subagent-title+hover+view-labels+power+settings-launcher+settings-menu-visible+settings-seat+settings-once+landed-forms+settings-press+settings-store+settings-depth+settings-class-fallback+node-list+power-actions+power-action-lands+power-bases+power-menu-first+typed-rearms+power-contract-only+power-typed-gate+power-leave-focus+power-records+power-gate-precise+power-echo.39'
 
 		const TAG = '[url-router]'
 
@@ -153,6 +294,11 @@ window.__ModuleLoader__.load({
 		/** The bar's structural hook, the way the row anchors carry theirs. */
 		const TITLEBAR_PART = 'url-router-address-bar'
 		const TITLEBAR_STYLE_ID = 'dsh-url-router-titlebar-style'
+		/** Structural hooks the bar's recent list publishes (tests and the observer read them). */
+		const RECENT_LIST_ATTRIBUTE = 'data-dsh-url-router-recent'
+		const RECENT_ITEM_ATTRIBUTE = 'data-dsh-url-router-recent-item'
+		/** The bar's copy-confirmation chip. */
+		const TOAST_ATTRIBUTE = 'data-dsh-url-router-toast'
 		/** Width the window's caption buttons take at the right end of the strip. */
 		const TITLEBAR_CAPTION_WIDTH = 138
 	/** Gap between the shell's menu and the bar. */
@@ -188,11 +334,22 @@ window.__ModuleLoader__.load({
 	 * has no power button. A couple of pixels is rounding, more is a resize.
 	 */
 	const MAC_BAR_RESIZE_SLACK = 8
+	/**
+	 * The bar is hidden until the pointer is over it, when the preference asks for it.
+	 *
+	 * The bar keeps its box (only its opacity drops), so hovering the place where it lives is
+	 * what reveals it — no extra hit area, and nothing else on the row moves.
+	 */
+	const HOVER_ATTRIBUTE = 'data-dsh-url-router-hover'
+	/** The reveal itself, set by the pointer/focus handlers and read by the stylesheet. */
+	const SHOWN_ATTRIBUTE = 'data-dsh-url-router-shown'
 	const MAC_STYLE_TEXT = [
 		`#${TITLEBAR_BAR_ID}[data-dsh-url-router-platform="mac"]{position:fixed;display:flex;align-items:center;height:${MAC_BAR_HEIGHT}px;z-index:1200;-webkit-app-region:no-drag}`,
 		`#${TITLEBAR_BAR_ID}[data-dsh-url-router-platform="mac"] input{height:${MAC_BAR_HEIGHT}px;width:100%;box-sizing:border-box;border:1px solid rgba(127,127,127,.34);border-radius:8px;padding:0 10px;font:inherit;font-size:12px;color:inherit;background:rgba(127,127,127,.16);outline:none;-webkit-app-region:no-drag}`,
 		`#${TITLEBAR_BAR_ID}[data-dsh-url-router-platform="mac"] input:focus{border-color:var(--dsw-alias-brand-primary,rgba(79,124,255,.9))}`,
 		`#${TITLEBAR_BAR_ID}[data-dsh-url-router-platform="mac"][data-dsh-url-router-state="refused"] input{border-color:rgba(214,69,69,.85);color:rgba(214,69,69,1)}`,
+		`#${TITLEBAR_BAR_ID}[${HOVER_ATTRIBUTE}]{opacity:0;transition:opacity .14s ease}`,
+		`#${TITLEBAR_BAR_ID}[${HOVER_ATTRIBUTE}][${SHOWN_ATTRIBUTE}]{opacity:1}`,
 	].join('')
 	/** Where the bar's last spot is kept, so a screen without a power button still gets it. */
 	const MAC_PLACEMENT_KEY = 'dsh-url-router-placement'
@@ -236,6 +393,59 @@ window.__ModuleLoader__.load({
 		}
 		return leaves
 	}
+	/**
+	 * The things whose presence on a line means "do not draw over this".
+	 *
+	 * Controls only: a page heading or an icon is decoration the bar may sit on, while a tab, a
+	 * button or a field is something to click or type into (measured: the automation task's detail
+	 * tabs were exactly what the bar covered).
+	 */
+	const BAND_SELECTORS = ['button', '[role="tab"]', '[role="button"]', 'a', 'input', 'textarea', 'select', '[contenteditable="true"]', 'h1', 'h2', 'h3']
+	/**
+	 * The page's own contents that stand on one line of the window, as merged spans.
+	 *
+	 * A screen with no header row to measure (a panel, the settings overlay) still draws things
+	 * at the bar's line: the automation task's detail tabs, a page heading, a toolbar. Reusing a
+	 * stretch measured on a conversation put the bar straight across those tabs (measured on the
+	 * automation panel). Only controls, headings and icons count — a background or a plain
+	 * container is not something to give way to.
+	 * @param {object} document - the page.
+	 * @param {object} own - the bar itself, whose box is never an obstacle.
+	 * @param {number} top - the line's top edge.
+	 * @param {number} height - the line's height.
+	 * @returns {Array<{left: number, right: number}>} merged spans, left to right.
+	 */
+	function bandSpans(document, own, top, height) {
+		const bottom = top + height
+		const seen = new Set()
+		const spans = []
+		// One selector at a time: a comma list is beyond a small DOM stub.
+		for (const selector of BAND_SELECTORS) {
+			for (const node of attemptValue(() => [...(document?.querySelectorAll?.(selector) ?? [])]) ?? []) {
+				if (node === null || node === undefined || seen.has(node)) continue
+				seen.add(node)
+				const mine = node === own || (typeof own?.contains === 'function' && own.contains(node) === true)
+				if (mine) continue
+				const rect = attemptValue(() => node.getBoundingClientRect?.())
+				if (rect === undefined || rect === null) continue
+				if (!(rect.height > 0) || rect.top >= bottom || rect.top + rect.height <= top) continue
+				const left = Math.round(rect.left)
+				const right = Math.round(rect.left + rect.width)
+				if (right > left) spans.push({ left, right })
+			}
+		}
+		spans.sort((first, second) => first.left - second.left)
+		const merged = []
+		for (const span of spans) {
+			const last = merged[merged.length - 1]
+			if (last !== undefined && span.left <= last.right) {
+				if (span.right > last.right) last.right = span.right
+				continue
+			}
+			merged.push({ left: span.left, right: span.right })
+		}
+		return merged
+	}
 	/**
 	 * The header row the bar has to live in: the row that carries the
 	 * conversation's title on the left and the header's own buttons on the right.
@@ -248,8 +458,9 @@ window.__ModuleLoader__.load({
 	 * @returns {object|undefined} the row element, or undefined when there is none.
 	 */
 	function macHeaderRow(trigger) {
-		const corner = document.querySelector?.('[data-conversation-header-corner]')
-		const named = document.querySelector?.('[class*="titleRow"]')
+		const page = attemptValue(() => window.document)
+		const corner = attemptValue(() => page?.querySelector?.('[data-conversation-header-corner]'))
+		const named = attemptValue(() => page?.querySelector?.('[class*="titleRow"]'))
 		if (named !== undefined && named !== null) {
 			// Only the row that actually holds the button is the row to measure.
 			if (trigger === undefined || trigger === null) return named
@@ -330,6 +541,26 @@ window.__ModuleLoader__.load({
 			`#${TITLEBAR_BAR_ID} input{height:26px;width:100%;box-sizing:border-box;border:1px solid transparent;border-radius:6px;padding:0 8px;font:inherit;font-size:12px;color:inherit;background:var(--dsw-specific-sidebar-fill,rgba(127,127,127,.14));outline:none;-webkit-app-region:no-drag}`,
 			`#${TITLEBAR_BAR_ID} input:focus{border-color:var(--dsw-alias-brand-primary,rgba(79,124,255,.9))}`,
 			`#${TITLEBAR_BAR_ID}[data-dsh-url-router-state="refused"] input{border-color:rgba(214,69,69,.85);color:rgba(214,69,69,1)}`,
+			`#${TITLEBAR_BAR_ID}[${HOVER_ATTRIBUTE}]{opacity:0;transition:opacity .14s ease}`,
+			`#${TITLEBAR_BAR_ID}[${HOVER_ATTRIBUTE}][${SHOWN_ATTRIBUTE}]{opacity:1}`,
+		].join('')
+		/**
+		 * The recent list's own stylesheet: a browser-style drop-down under the bar.
+		 *
+		 * Both platforms share it — the bar is the same fixed-position element in both — so
+		 * the picker can never drift into two different-looking lists.
+		 */
+		const RECENT_STYLE_TEXT = [
+			`#${TITLEBAR_BAR_ID} [${RECENT_LIST_ATTRIBUTE}]{position:absolute;top:calc(100% + 4px);left:0;right:0;z-index:5;display:none;box-sizing:border-box;max-height:min(52vh,420px);overflow:auto;padding:4px;border:1px solid rgba(127,127,127,.34);border-radius:10px;background:var(--dsw-alias-bg-layer-1,#fff);box-shadow:0 16px 40px rgba(0,0,0,.16);-webkit-app-region:no-drag}`,
+			`#${TITLEBAR_BAR_ID} [${RECENT_LIST_ATTRIBUTE}][data-open]{display:block}`,
+			`#${TITLEBAR_BAR_ID} [${RECENT_ITEM_ATTRIBUTE}]{display:flex;align-items:center;gap:8px;width:100%;box-sizing:border-box;padding:6px 8px;border:none;border-radius:7px;background:transparent;color:inherit;font:inherit;font-size:12px;line-height:18px;text-align:left;cursor:pointer}`,
+			`#${TITLEBAR_BAR_ID} [${RECENT_ITEM_ATTRIBUTE}]:hover,#${TITLEBAR_BAR_ID} [${RECENT_ITEM_ATTRIBUTE}]:focus-visible{background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.16));outline:none}`,
+			`#${TITLEBAR_BAR_ID} .dshur-kind{flex:none;padding:0 6px;border-radius:5px;background:rgba(127,127,127,.16);color:var(--dsw-alias-label-secondary,#4b5872);font-size:11px;line-height:18px}`,
+			`#${TITLEBAR_BAR_ID} .dshur-title{flex:0 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-primary,#1b1b20)}`,
+			`#${TITLEBAR_BAR_ID} .dshur-link{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-tertiary,#81858c);font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:11px}`,
+			`#${TITLEBAR_BAR_ID} [${RECENT_ITEM_ATTRIBUTE}][data-copied] .dshur-link{color:var(--dsw-alias-brand-primary,#4d6bfe);font-weight:600}`,
+			`#${TITLEBAR_BAR_ID} [${TOAST_ATTRIBUTE}]{position:absolute;right:6px;top:50%;transform:translateY(-50%);z-index:6;padding:0 8px;line-height:20px;border-radius:999px;border:1px solid rgba(127,127,127,.34);background:var(--dsw-alias-bg-layer-1,#fff);color:var(--dsw-alias-label-secondary,#4b5872);font-size:11px;pointer-events:none;opacity:0;transition:opacity .12s}`,
+			`#${TITLEBAR_BAR_ID} [${TOAST_ATTRIBUTE}][data-show]{opacity:1}`,
 		].join('')
 		/** Listeners told the fragment this router just wrote; the desktop bar reads it. */
 		const routeFeed = new Set()
@@ -338,6 +569,9 @@ window.__ModuleLoader__.load({
 		 * @param {string} hash - the fragment just written.
 		 */
 		function publishRoute(hash) {
+			// A fragment this router just wrote names the screen the reader moved to, so it is
+			// remembered (the bar's recent list). An empty write names nothing and is skipped.
+			rememberRecent(hash)
 			for (const listener of [...routeFeed]) {
 				try {
 					listener(hash)
@@ -363,6 +597,285 @@ window.__ModuleLoader__.load({
 		 */
 		let driveTypedFragment = () => {}
 
+		// ---------------------------------------------------------------------
+		// preferences: how the address bar behaves, remembered on this machine
+		//
+		// Two small preferences make the bar act like a browser's: the first click
+		// selects all of the old link, and the bar remembers the screens it has named
+		// plus the links pasted into it. They belong to this window rather than to the
+		// profile, so they live in localStorage; the plugin manager page writes them
+		// (`#/panel/plugins/dsh-url-router/dsh-url-router`).
+		// ---------------------------------------------------------------------
+		/** Preference record: the two switches the settings page owns. */
+		const SETTINGS_KEY = 'dsh-url-router-settings'
+		/** Remembered links, newest first. */
+		const RECENT_KEY = 'dsh-url-router-recent'
+		/** What the bar does before the settings page has ever been opened. */
+		const DEFAULT_SETTINGS = { selectAllOnFocus: true, hoverReveal: false, recentLimit: 8 }
+		/**
+		 * The key the plugin manager dispatches a row's configuration under:
+		 * `<package name>#<row id>`. This package declares one row whose package name and
+		 * row id are the same string, so the key names it twice — and the page it opens is
+		 * exactly `#/panel/plugins/dsh-url-router/dsh-url-router`.
+		 */
+		const ROW_CONFIG_KEY = 'dsh-url-router#dsh-url-router'
+
+		/**
+		 * How much work the two observers have caused, for the report.
+		 *
+		 * A streaming answer mutates the page dozens of times a second; these counters are what a
+		 * real-machine check reads to tell "coalesced" from "reconciled on every batch".
+		 */
+		const workCounts = { reconciles: 0, placements: 0 }
+		/** Listeners told the preferences changed; the settings card redraws from them. */
+		const settingsListeners = new Set()
+		/** The parsed record, read once and kept in step with every write. */
+		let settingsCache
+
+		/**
+		 * The settings record, with anything unusable replaced by its default.
+		 * @param {unknown} raw - the parsed record, or anything that was on disk.
+		 * @returns {{selectAllOnFocus: boolean, hoverReveal: boolean, recentLimit: number}} the record.
+		 */
+		function normaliseSettings(raw) {
+			const source = raw !== null && typeof raw === 'object' ? raw : {}
+			const limit = Number(source.recentLimit)
+			return {
+				selectAllOnFocus: typeof source.selectAllOnFocus === 'boolean' ? source.selectAllOnFocus : DEFAULT_SETTINGS.selectAllOnFocus,
+				hoverReveal: typeof source.hoverReveal === 'boolean' ? source.hoverReveal : DEFAULT_SETTINGS.hoverReveal,
+				// A count of remembered links: whole, never negative, and with no upper bound
+				// the reader did not ask for.
+				recentLimit: Number.isFinite(limit) && limit >= 0 ? Math.floor(limit) : DEFAULT_SETTINGS.recentLimit,
+			}
+		}
+
+		/**
+		 * Read the settings, once.
+		 * @returns {{selectAllOnFocus: boolean, hoverReveal: boolean, recentLimit: number}} the record in force.
+		 */
+		function readSettings() {
+			if (settingsCache !== undefined) return settingsCache
+			settingsCache = normaliseSettings(attemptValue(() => {
+				const raw = globalThis.localStorage?.getItem?.(SETTINGS_KEY)
+				return raw === null || raw === undefined || raw === '' ? undefined : JSON.parse(raw)
+			}))
+			return settingsCache
+		}
+
+		/**
+		 * Change the settings, keep them, and tell the card.
+		 * @param {object} patch - the fields to change.
+		 * @returns {object} the record now in force.
+		 */
+		function updateSettings(patch) {
+			const next = normaliseSettings({ ...readSettings(), ...(patch !== null && typeof patch === 'object' ? patch : {}) })
+			settingsCache = next
+			attemptValue(() => globalThis.localStorage?.setItem?.(SETTINGS_KEY, JSON.stringify(next)))
+			// A lower count takes effect now, not at the next remembered link.
+			trimRecent()
+			for (const listener of [...settingsListeners]) {
+				try {
+					listener(next)
+				} catch {
+					// A card that throws must not stop the bar from reading the new record.
+				}
+			}
+			return next
+		}
+
+		/**
+		 * Follow the settings from something that draws them.
+		 * @param {Function} listener - called with the record after every change.
+		 * @returns {() => void} the unsubscribe.
+		 */
+		function subscribeSettings(listener) {
+			settingsListeners.add(listener)
+			return () => settingsListeners.delete(listener)
+		}
+
+		/**
+		 * One remembered link, exactly as it was stored.
+		 * @param {unknown} raw - one entry off disk.
+		 * @returns {{hash: string, at: number, source: string}|undefined} the entry, or undefined when unusable.
+		 */
+		function recentEntryOf(raw) {
+			if (raw === null || typeof raw !== 'object') return undefined
+			const hash = typeof raw.hash === 'string' ? raw.hash.trim() : ''
+			if (!hash.startsWith('#') || hash === '#') return undefined
+			const at = Number(raw.at)
+			return { hash, at: Number.isFinite(at) ? at : 0, source: raw.source === 'paste' ? 'paste' : 'visit' }
+		}
+
+		/**
+		 * The remembered links, newest first.
+		 * @returns {Array<object>} the entries, in the order they are shown.
+		 */
+		function readRecent() {
+			const raw = attemptValue(() => {
+				const text = globalThis.localStorage?.getItem?.(RECENT_KEY)
+				return text === null || text === undefined || text === '' ? [] : JSON.parse(text)
+			})
+			if (!Array.isArray(raw)) return []
+			return raw.map(recentEntryOf).filter(entry => entry !== undefined)
+		}
+
+		/**
+		 * Put the remembered links on disk.
+		 * @param {Array<object>} entries - the entries to keep, newest first.
+		 */
+		function writeRecent(entries) {
+			attemptValue(() => globalThis.localStorage?.setItem?.(RECENT_KEY, JSON.stringify(entries)))
+		}
+
+		/**
+		 * The screen a remembered link stands for.
+		 *
+		 * A link may name a position inside a screen (`turn/…`, `row/…`, a panel's inner
+		 * page); the memory is of *screens*, so the identity stops at the surface. Without
+		 * this every click inside a conversation would push another entry of the same
+		 * conversation and crowd the list out.
+		 * @param {string} hash - the fragment.
+		 * @returns {string} the identity two links of the same screen share.
+		 */
+		function recentIdentity(hash) {
+			const route = parseRoute(String(hash ?? ''))
+			if (route === undefined || route.unknown !== undefined) return String(hash ?? '')
+			// A command has no place to come back to, so it never enters the recent list.
+			if (route.kind === 'power' && powerActionOf(route.id) !== undefined) return ''
+			if (route.kind === 'workspace') {
+				const inner = innerPath(route.inner)
+				return inner.length >= 2 ? `${ROW_KEY_PREFIX}${inner[1]}` : `${route.kind}:${route.id}`
+			}
+			return `${route.kind}:${route.id}`
+		}
+
+		/**
+		 * The screen the address bar names right now.
+		 * @returns {string} the current fragment, or an empty string off a page.
+		 */
+		function currentScreenHash() {
+			return typeof window?.location?.hash === 'string' ? window.location.hash : ''
+		}
+
+		/**
+		 * How many entries are kept on disk.
+		 *
+		 * The count the reader sets is the number of links the drop-down offers — the screen in
+		 * the address bar is not one of them, because that is where the reader already is. That
+		 * screen is still remembered (leave it and it comes back in the list), so it may not eat
+		 * one of the slots: one spare slot covers it, since a screen has exactly one entry.
+		 * @returns {number} the entries to keep.
+		 */
+		function recentKeep() {
+			const limit = readSettings().recentLimit
+			return limit <= 0 ? 0 : limit + 1
+		}
+
+		/**
+		 * Keep the remembered links at the count in force, newest first.
+		 * @returns {Array<object>} the entries that are kept.
+		 */
+		function trimRecent() {
+			const keep = recentKeep()
+			const stored = readRecent()
+			const kept = keep <= 0 ? [] : stored.slice(0, keep)
+			if (kept.length !== stored.length) writeRecent(kept)
+			return kept
+		}
+
+		/**
+		 * The remembered links the drop-down offers: the count in force, without the screen the
+		 * address bar already names, newest first.
+		 * @returns {Array<object>} the entries, in the order they are shown.
+		 */
+		function recentEntries() {
+			const limit = readSettings().recentLimit
+			// The memory is off: nothing is kept and nothing is shown.
+			if (limit <= 0) return []
+			const keep = recentKeep()
+			const stored = readRecent()
+			const kept = stored.length > keep ? stored.slice(0, keep) : stored
+			// Reading never writes: `report()` calls this and it must stay side-effect free.
+			// The disc is trimmed when a link is written and when the count changes.
+			const current = currentScreenHash()
+			return kept.filter(entry => entry.hash !== current).slice(0, limit)
+		}
+
+		/**
+		 * Remember a link: a screen the view just moved to, or a link pasted into the bar.
+		 * @param {string} hash - the fragment.
+		 * @param {string} [source] - `paste` for a pasted link, `visit` (the default) otherwise.
+		 */
+		function rememberRecent(hash, source) {
+			const text = typeof hash === 'string' ? hash.trim() : ''
+			if (!text.startsWith('#') || text === '#') return
+			// Nothing is remembered while the memory is off, so turning it on later starts
+			// from an empty list instead of resurrecting links from before.
+			const limit = readSettings().recentLimit
+			if (limit <= 0) return
+			const identity = recentIdentity(text)
+			const entries = readRecent().filter(entry => recentIdentity(entry.hash) !== identity)
+			entries.unshift({ hash: text, at: attemptValue(() => Date.now(), 0), source: source === 'paste' ? 'paste' : 'visit' })
+			writeRecent(entries.slice(0, recentKeep()))
+		}
+
+		/** Forget every remembered link. */
+		function clearRecent() {
+			writeRecent([])
+		}
+
+		/**
+		 * The conversation title the sidebar shows for an id, when it is rendered.
+		 * @param {string} sessionId - the conversation id.
+		 * @returns {string} the title, or an empty string when the row is not on screen.
+		 */
+		function sessionTitles() {
+			const titles = new Map()
+			const rows = attemptValue(() => window.document?.querySelectorAll?.('[data-row-key]')) ?? []
+			for (const row of rows) {
+				const key = typeof row?.getAttribute === 'function' ? row.getAttribute('data-row-key') : null
+				if (typeof key !== 'string' || !key.startsWith(ROW_KEY_PREFIX)) continue
+				const text = String(row.textContent ?? '').trim().replace(/\s+/gu, ' ').slice(0, 80)
+				if (text !== '') titles.set(key, text)
+			}
+			return titles
+		}
+
+		/**
+		 * The title of one conversation, read from a map made once for the whole list.
+		 * @param {string} sessionId - the conversation id.
+		 * @param {Map<string, string>} [titles] - the row titles, when the caller already has them.
+		 * @returns {string} the title, or an empty string when the row is not on screen.
+		 */
+		function sessionTitleOf(sessionId, titles) {
+			const key = `${ROW_KEY_PREFIX}${sessionId}`
+			if (titles !== undefined) return titles.get(key) ?? ''
+			for (const row of attemptValue(() => window.document?.querySelectorAll?.('[data-row-key]')) ?? []) {
+				if (typeof row?.getAttribute !== 'function' || row.getAttribute('data-row-key') !== key) continue
+				return String(row.textContent ?? '').trim().replace(/\s+/gu, ' ').slice(0, 80)
+			}
+			return ''
+		}
+
+		/**
+		 * The words a remembered link reads as: the conversation's own title when the
+		 * sidebar has it, a settings section's label, or nothing (the fragment then says it).
+		 * @param {string} hash - the fragment.
+		 * @returns {string} the label, or an empty string.
+		 */
+		function recentLabel(hash, titles) {
+			const route = parseRoute(String(hash ?? ''))
+			if (route === undefined || route.unknown !== undefined) return ''
+			if (route.kind === 'session') return sessionTitleOf(route.id, titles)
+			if (route.kind === 'workspace') {
+				const inner = innerPath(route.inner)
+				return inner.length >= 2 ? sessionTitleOf(inner[1], titles) : route.id
+			}
+			// A settings section's identity is its own display name.
+			if (route.kind === 'settings') return route.id
+			return ''
+		}
+
 		/**
 		 * 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.
@@ -387,6 +900,30 @@ window.__ModuleLoader__.load({
 			return ids.length === 0 ? undefined : ids
 		}
 
+		/**
+		 * The conversation views the slot contributes, with the labels the header prints.
+		 *
+		 * The header renders only some of these tabs (the rest go into the "…" menu), so a tab's
+		 * *text* is the only reliable identity a reader can be mapped by — the registry ids alone
+		 * can only be matched positionally, and only while every view is rendered.
+		 * @param {object} slots - the slot service.
+		 * @returns {Array<{id: string, label: string}>} contributions in registration order.
+		 */
+		function conversationViewLabelsOf(slots) {
+			const rows = attemptValue(() => slots?.entries?.('conversation.view'))
+			if (!Array.isArray(rows)) return []
+			const out = []
+			for (const row of rows) {
+				const options = row === null || typeof row !== 'object' ? undefined : row.options
+				const id = options?.id
+				if (typeof id !== 'string' || id === '') continue
+				let label = options?.label
+				if (typeof label === 'function') label = attemptValue(() => label())
+				out.push({ id, label: typeof label === 'string' ? label.trim() : '' })
+			}
+			return out
+		}
+
 		/**
 		 * Read a value, or undefined when reading it throws.
 		 * @param {Function} read - the reader.
@@ -519,6 +1056,72 @@ window.__ModuleLoader__.load({
 			warn(`${TAG} ${message}`)
 		}
 
+		/** Notes already given, per check: a compatibility problem is worth saying once. */
+		const compatNotes = new Set()
+		/** At most one compatibility sweep per this interval: each check reads the page. */
+		const COMPAT_EVERY_MS = 1000
+		/** The phrase every compatibility note carries, so a log can be searched for it. */
+		const COMPAT_MESSAGE = '与当前 DSH 版本不兼容'
+
+		/**
+		 * The screens whose hooks this router reads, and what it expects to find on them.
+		 *
+		 * Each check pairs a *weak* signal that the screen is up (something this build still
+		 * recognises) with a *strong* hook the router actually needs. A screen that is up while
+		 * its strong hook is gone is exactly the silent breakage this plugin cannot afford: links
+		 * stop naming that surface and nothing says so. The checks only report — they never change
+		 * what the router does.
+		 * @param {object} document - the page.
+		 * @param {object} context - what the router knows: the active panel, conversation count and registered views.
+		 * @returns {Array<{name: string, expected: string, found: string}>} the problems, empty when healthy.
+		 */
+		function compatibilityProblems(document, context) {
+			const problems = []
+			if (document === undefined || document === null || typeof document.querySelectorAll !== 'function') return problems
+			const count = selector => attemptValue(() => document.querySelectorAll?.(selector)?.length) ?? 0
+			// 1) The settings overlay. A modal carrying a nav of several buttons is this app's
+			// settings page; when neither official marker is on it, the router is reading a page it
+			// cannot name (this is the marker that already moved once).
+			for (const dialog of attemptValue(() => [...(document.querySelectorAll('[role="dialog"]') ?? [])]) ?? []) {
+				if (attemptValue(() => dialog.getAttribute?.('aria-modal')) !== 'true') continue
+				let navButtons = 0
+				for (const nav of attemptValue(() => [...(dialog.querySelectorAll('nav') ?? [])]) ?? []) {
+					navButtons += attemptValue(() => nav.querySelectorAll?.('button')?.length) ?? 0
+				}
+				if (navButtons < 3) continue
+				if (settingsOverlayOf(document) !== undefined) continue
+				problems.push({ name: 'settings-overlay', expected: 'data-shortcut-modal="settings"', found: `a modal with a ${navButtons}-button nav and no settings marker` })
+				break
+			}
+			// 2) The plugin manager. Its panel root is stable; its row/detail hooks are what links
+			// are built from.
+			if (count('[data-plugin-panel]') > 0) {
+				const hooks = count('[data-plugin-package]') + count('[data-plugin-item]') + count('[data-plugin-row]')
+					+ count('[data-plugin-detail]') + count('[data-plugin-item-detail]') + count('[data-plugin-row-detail]')
+				if (hooks === 0) {
+					problems.push({ name: 'plugin-manager', expected: 'data-plugin-package / data-plugin-item / data-plugin-row / data-plugin-detail', found: 'a plugin panel with none of them' })
+				}
+			}
+			// 3) The automation list's status filter: three aria-pressed buttons in a role=group.
+			if (context?.activePanelId === 'schedules' || count('[data-plugin-panel="schedules"]') > 0) {
+				const groups = attemptValue(() => [...(document.querySelectorAll('[role="group"]') ?? [])]) ?? []
+				if (groups.length > 0 && scheduleFilterOf(document) === undefined) {
+					problems.push({ name: 'schedules-filter', expected: 'a [role="group"] holding three aria-pressed buttons', found: `${groups.length} group(s), none matching` })
+				}
+			}
+			// 4) The conversation header's view tabs. Only when the registry really publishes more
+			// than one view: a composition with a single view has no tabs to find.
+			if ((context?.views ?? 0) >= 2 && count('[data-chat-turn]') > 0 && count('[data-conversation-tabs]') === 0) {
+				problems.push({ name: 'conversation-tabs', expected: `[${CONVERSATION_TABS_ATTRIBUTE}] in the header`, found: 'chat turns with no header container' })
+			}
+			// 5) The sidebar's conversation rows. The settings entry is the "a real sidebar is up"
+			// signal, and the catalog says there is something to list.
+			if (count(`[data-slot="${SETTINGS_TRIGGER_SLOT}"]`) > 0 && (context?.sessions ?? 0) > 0 && count('[data-row-key^="session:"]') === 0) {
+				problems.push({ name: 'sidebar-rows', expected: '[data-row-key="session:<id>"] rows', found: `a sidebar with ${context.sessions} conversation(s) and no rows` })
+			}
+			return problems
+		}
+
 		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.
@@ -557,7 +1160,11 @@ window.__ModuleLoader__.load({
 			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
+				if (match !== undefined) return match.kind
+				// With a registry to check against, a label that matches nothing is a *title* — the
+				// open file's name, a terminal's own name — never a kind. Without a registry the
+				// label is the only name there is, so it is taken as the kind.
+				return Array.isArray(registry) && registry.length > 0 ? undefined : named
 			}
 			// 2) an address-shaped id, for a future build that puts one there
 			const fromTab = kindOfTabId(attemptValue(() => chosen.getAttribute?.('data-dockkit-tab')))
@@ -571,6 +1178,329 @@ window.__ModuleLoader__.load({
 			return undefined
 		}
 
+		/**
+		 * Whether the right-hand bar is collapsed.
+		 *
+		 * A collapsed bar keeps its tab strip mounted, so "a tab is selected in the strip" is not
+		 * the same question as "that pane is on screen" — measured: after closing the bar the
+		 * address bar kept naming its last pane, which was no longer anywhere.
+		 * @param {object} document - the page.
+		 * @returns {boolean} whether the bar is collapsed.
+		 */
+		function rightBarCollapsedOf(document) {
+			const marker = attemptValue(() => document?.querySelector?.(`[${RIGHT_BAR_COLLAPSED_ATTRIBUTE}]`))
+			if (marker === null || marker === undefined) return false
+			const value = attemptValue(() => marker.getAttribute?.(RIGHT_BAR_COLLAPSED_ATTRIBUTE))
+			return value !== 'false'
+		}
+
+		/**
+		 * The status filter the automation-task list is showing.
+		 *
+		 * Read from the group's own buttons: the pressed one's *position* among the three is the
+		 * filter (see `SCHEDULE_FILTERS`). A group is the manager's when it holds exactly three
+		 * buttons, all of them pressed-state buttons, and it is not the right bar's own.
+		 * @param {object} document - the page.
+		 * @returns {string|undefined} `all`, `active` or `inactive`.
+		 */
+		function scheduleFilterOf(document) {
+			const groups = attemptValue(() => [...(document?.querySelectorAll?.('[role="group"]') ?? [])]) ?? []
+			for (const group of groups) {
+				const inside = attemptValue(() => group?.closest?.(`[${RIGHT_BAR_ATTRIBUTE}]`))
+				if (inside !== null && inside !== undefined) continue
+				const buttons = attemptValue(() => [...(group?.querySelectorAll?.('button') ?? [])]) ?? []
+				if (buttons.length !== SCHEDULE_FILTERS.length) continue
+				if (!buttons.every(button => attemptValue(() => button.getAttribute?.('aria-pressed')) !== null)) continue
+				const pressed = buttons.findIndex(button => attemptValue(() => button.getAttribute?.('aria-pressed')) === 'true')
+				if (pressed < 0) continue
+				return SCHEDULE_FILTERS[pressed]
+			}
+			return undefined
+		}
+
+		/**
+		 * The automation task the manager has open, and the detail tab it shows.
+		 *
+		 * The row states both facts: `aria-expanded` marks the open one, and its
+		 * `aria-describedby` ends with the task id (`<useId>-metadata-<taskId>`). The detail's
+		 * tabs carry their own value (`data-detail-tab="rule" | "records"`).
+		 * @param {object} document - the page.
+		 * @returns {{id: string, tab: string}|undefined} the open task, or undefined when none is.
+		 */
+		function scheduleTaskOf(document) {
+			const buttons = attemptValue(() => [...(document?.querySelectorAll?.('button') ?? [])]) ?? []
+			for (const button of buttons) {
+				const described = attemptValue(() => button.getAttribute?.('aria-describedby'))
+				if (typeof described !== 'string' || described === '') continue
+				const match = /-metadata-(.+)$/u.exec(described)
+				if (match === null) continue
+				if (attemptValue(() => button.getAttribute?.('aria-expanded')) !== 'true') continue
+				const tabs = attemptValue(() => [...(document?.querySelectorAll?.(`[${SCHEDULE_TAB_ATTRIBUTE}]`) ?? [])]) ?? []
+				const chosen = tabs.find(tab => attemptValue(() => tab.getAttribute?.('aria-selected')) === 'true')
+				const tab = attemptValue(() => chosen?.getAttribute?.(SCHEDULE_TAB_ATTRIBUTE))
+				return { id: match[1], tab: typeof tab === 'string' && tab !== '' ? tab : 'rule' }
+			}
+			return undefined
+		}
+
+		/**
+		 * The parts of a settings inner path.
+		 *
+		 * A settings route may name a tab (`[<tab>]`) and, one level deeper, the model-provider
+		 * card whose editor is open (`[<tab>?/provider/<id>]`). Keeping one reader for both shapes
+		 * is what lets the link's landing rule and the drive agree.
+		 * @param {string|Array<string>} inner - the inner path.
+		 * @returns {{tab: string|undefined, provider: string|undefined}} the parts.
+		 */
+		/** A row whose state lives in a styling class: the class has to end in one of these words. */
+		const ROW_ON_CLASS = /(?:On|Active|Selected|Current|Checked)$/
+
+		/**
+		 * The label a control is known by: its own text, without a nested badge.
+		 *
+		 * A chip can read `宠物 12`, where `12` is a count inside a nested element (measured on the
+		 * market's filter row). A count is not identity — it moves — so only the control's own text
+		 * names it, and a link stays valid when the number changes.
+		 * @param {object} control - the control.
+		 * @returns {string} its label.
+		 */
+		function controlLabelOf(control) {
+			let own = ''
+			for (const node of control?.childNodes ?? []) {
+				if (node?.nodeType === 3) own += String(node.textContent ?? '')
+			}
+			const text = own.trim() !== '' ? own : String(control?.textContent ?? '')
+			return text.trim().replace(/\s+/g, ' ')
+		}
+
+		/**
+		 * Whether one settings row's control is the one selected.
+		 * @param {object} row - a row from `settingsRowsOf`.
+		 * @param {object} control - a control of that row.
+		 * @returns {boolean} whether it is on.
+		 */
+		function controlIsOn(row, control) {
+			if (row.marker === 'class') return typeof control.className === 'string' && ROW_ON_CLASS.test(control.className)
+			return control.getAttribute(row.marker) === 'true'
+		}
+
+		/**
+		 * The rows of selectable controls inside the settings overlay, in document order.
+		 *
+		 * The overlay is deeper than one tab row: a section owns tabs, a tab may own another row
+		 * (measured 2026-10-28: `Web 扩展 / 创意工坊` holds `编辑推荐 / 皮肤 / 宠物 / 插件 / 预设`),
+		 * and that row may hold filters of its own. A row is a parent whose children all carry the
+		 * same marker — `aria-selected` for tabs, `aria-pressed` for toggles — with exactly one of
+		 * them true, and the row's place is its first control's place in the document.
+		 * @param {object} overlay - the settings overlay.
+		 * @returns {Array<{node: object, marker: string}>} the rows.
+		 */
+		function settingsRowsOf(overlay) {
+			if (overlay === null || overlay === undefined || typeof overlay.querySelectorAll !== 'function') return []
+			const rows = []
+			const seen = new Set()
+			for (const marker of ['aria-selected', 'aria-pressed']) {
+				// A query result is a NodeList, not an array: spread it *inside* the attempt, or the
+				// guard below silently skips the whole scan in a real DOM (measured 2026-10-28).
+				const nodes = attemptValue(() => [...overlay.querySelectorAll(`[${marker}]`)])
+				if (!Array.isArray(nodes)) continue
+				for (const node of nodes) {
+					const parent = node?.parentElement
+					if (parent === null || parent === undefined || seen.has(parent)) continue
+					const children = attemptValue(() => [...parent.children]) ?? []
+					const marked = children.filter(child => typeof child.getAttribute === 'function' && child.getAttribute(marker) !== null)
+					if (marked.length < 2) continue
+					const on = marked.find(child => child.getAttribute(marker) === 'true')
+					if (on === undefined) continue
+					if (controlLabelOf(on) === '') continue
+					seen.add(parent)
+					rows.push({ node: parent, marker })
+				}
+			}
+			// A row with no ARIA at all: some plugins only toggle a styling class (measured on the
+			// market's filter chips: `…_filterChipOn`, no aria-* anywhere). It is a last resort and it
+			// is deliberately narrow — the class has to *end* in one of these words, exactly one
+			// sibling may carry it, and the row must have at least two controls.
+			const buttons = attemptValue(() => [...overlay.querySelectorAll('button')])
+			if (Array.isArray(buttons)) {
+				for (const node of buttons) {
+					const parent = node?.parentElement
+					if (parent === null || parent === undefined || seen.has(parent)) continue
+					const children = (attemptValue(() => [...parent.children]) ?? []).filter(child => typeof child.className === 'string')
+					if (children.length < 2) continue
+					const marked = children.filter(child => ROW_ON_CLASS.test(child.className))
+					if (marked.length !== 1) continue
+					if (controlLabelOf(marked[0]) === '') continue
+					seen.add(parent)
+					rows.push({ node: parent, marker: 'class' })
+				}
+			}
+			return rows.sort((a, b) => {
+				if (a.node === b.node) return 0
+				const position = attemptValue(() => a.node.compareDocumentPosition?.(b.node)) ?? 0
+				// 4 is DOCUMENT_POSITION_FOLLOWING: `a` comes first.
+				return (position & 4) !== 0 ? -1 : 1
+			})
+		}
+
+		/**
+		 * What each settings row has selected, in row order — the path a link can name.
+		 * @param {object} overlay - the settings overlay.
+		 * @returns {string[]} the labels.
+		 */
+		function settingsSelectedLabelsOf(overlay) {
+			const out = []
+			for (const row of settingsRowsOf(overlay)) {
+				const on = [...row.node.children].find(child => controlIsOn(row, child))
+				const label = on === undefined ? '' : controlLabelOf(on)
+				if (label !== '') out.push(label)
+			}
+			return out
+		}
+
+		/**
+		 * The control inside one settings row whose label is the one a link names.
+		 * @param {object} row - a row from `settingsRowsOf`.
+		 * @param {string} label - the wanted label.
+		 * @returns {object|undefined} the control.
+		 */
+		function settingsControlOf(row, label) {
+			const wanted = label.trim().toLowerCase()
+			for (const child of attemptValue(() => [...row.node.children]) ?? []) {
+				if (typeof child.getAttribute !== 'function') continue
+				if (row.marker !== 'class' && child.getAttribute(row.marker) === null) continue
+				if (controlLabelOf(child).toLowerCase() !== wanted) continue
+				return child
+			}
+			return undefined
+		}
+
+		function settingsPartsOf(inner) {
+			const parts = innerPath(inner)
+			const at = parts.indexOf(PROVIDER_SEGMENT)
+			const levels = at < 0 ? parts : parts.slice(0, at)
+			return { levels, provider: at < 0 ? undefined : parts[at + 1] }
+		}
+
+		/**
+		 * The model-provider card that is open in the settings overlay, when one is.
+		 *
+		 * The models section renders a card's editor inline and publishes no data hook for it: the
+		 * card is an `li` that suddenly holds a text field, and its identity lives in an action's
+		 * accessible name, which the official copy builds as `<label> <displayName>
+		 * (<provider>)`. Only the parenthesised provider id is language-independent, so that is
+		 * what a link carries.
+		 * @param {object} document - the page.
+		 * @returns {string|undefined} the open provider id.
+		 */
+		function openSettingsProviderId(document) {
+			const overlay = settingsOverlayOf(document)
+			if (overlay === null || overlay === undefined || typeof overlay.querySelectorAll !== 'function') return undefined
+			for (const card of overlay.querySelectorAll('li')) {
+				if (typeof card?.querySelector !== 'function') continue
+				if (card.querySelector('input') === null && card.querySelector('textarea') === null) continue
+				for (const button of card.querySelectorAll('button')) {
+					const label = attemptValue(() => button.getAttribute?.('aria-label'))
+					if (typeof label !== 'string' || label === '') continue
+					const match = /\(([^()]*)\)\s*$/u.exec(label)
+					if (match === null || match[1].trim() === '') continue
+					return match[1].trim()
+				}
+			}
+			return undefined
+		}
+
+		/**
+		 * Open one model-provider card's editor in the settings overlay.
+		 * @param {string} id - the provider id the link named.
+		 */
+		function clickSettingsProvider(id) {
+			const wanted = String(id ?? '').trim().toLowerCase()
+			if (wanted === '') return
+			const overlay = settingsOverlayOf(window.document)
+			const scope = overlay ?? window.document
+			const buttons = attemptValue(() => [...(scope?.querySelectorAll?.('button') ?? [])]) ?? []
+			for (const button of buttons) {
+				const label = attemptValue(() => button.getAttribute?.('aria-label'))
+				if (typeof label !== 'string') continue
+				const match = /\(([^()]*)\)\s*$/u.exec(label)
+				if (match === null || match[1].trim().toLowerCase() !== wanted) continue
+				// Already open: the next press would close it, and the retry loop would then flip the
+				// card open and shut until the link expired.
+				const card = attemptValue(() => button.closest?.('li'))
+				if (card !== null && card !== undefined) {
+					const open = attemptValue(() => card.querySelector?.('input') !== null || card.querySelector?.('textarea') !== null)
+					if (open === true) return
+				}
+				// The edit control comes before the delete control in a card's actions.
+				if (typeof button.click === 'function') attemptValue(() => button.click())
+				return
+			}
+		}
+
+		/**
+		 * Press one status filter of the automation list.
+		 * @param {string} token - `all`, `active` or `inactive`.
+		 */
+		function clickScheduleFilter(token) {
+			const order = SCHEDULE_FILTERS.indexOf(String(token ?? ''))
+			if (order < 0) return
+			const document = window.document
+			const groups = attemptValue(() => [...(document?.querySelectorAll?.('[role="group"]') ?? [])]) ?? []
+			for (const group of groups) {
+				const inside = attemptValue(() => group?.closest?.(`[${RIGHT_BAR_ATTRIBUTE}]`))
+				if (inside !== null && inside !== undefined) continue
+				const buttons = attemptValue(() => [...(group?.querySelectorAll?.('button') ?? [])]) ?? []
+				if (buttons.length !== SCHEDULE_FILTERS.length) continue
+				if (!buttons.every(button => attemptValue(() => button.getAttribute?.('aria-pressed')) !== null)) continue
+				const button = buttons[order]
+				if (typeof button?.click === 'function') attemptValue(() => button.click())
+				return
+			}
+		}
+
+		/**
+		 * Open one automation task's detail, and the detail tab it names.
+		 * @param {string} id - the task id.
+		 * @param {string} [tab] - `rule` or `records`.
+		 */
+		function clickScheduleTask(id, tab) {
+			const wanted = String(id ?? '')
+			if (wanted === '') return
+			const document = window.document
+			const buttons = attemptValue(() => [...(document?.querySelectorAll?.('button') ?? [])]) ?? []
+			let found = false
+			for (const button of buttons) {
+				const described = attemptValue(() => button.getAttribute?.('aria-describedby'))
+				if (typeof described !== 'string' || !described.endsWith(`-metadata-${wanted}`)) continue
+				found = true
+				if (typeof button.click === 'function') attemptValue(() => button.click())
+				break
+			}
+			// A filter hides the rows it does not match, so a link to a task outside it has nothing
+			// to open. The list is widened to "all" and the next retry finds the row.
+			if (!found) clickScheduleFilter(SCHEDULE_FILTERS[0])
+			if (typeof tab !== 'string' || tab === '' || tab === 'rule') return
+			const tabs = attemptValue(() => [...(document?.querySelectorAll?.(`[${SCHEDULE_TAB_ATTRIBUTE}]`) ?? [])]) ?? []
+			const chosen = tabs.find(candidate => attemptValue(() => candidate.getAttribute?.(SCHEDULE_TAB_ATTRIBUTE)) === tab)
+			if (typeof chosen?.click === 'function') attemptValue(() => chosen.click())
+		}
+
+		/**
+		 * `filter/all` names the state a bare automation list is already in, so a link carrying it
+		 * is read as the bare panel: the router never writes it, and dropping it here keeps the
+		 * link comparable (it lands instead of waiting for a page that will never say `all`).
+		 * @param {string} kind - the route kind.
+		 * @param {string} id - the route identity.
+		 * @param {Array<string>} parts - the inner path segments.
+		 * @returns {Array<string>} the segments to use.
+		 */
+		function normalisePanelInner(kind, id, parts) {
+			if (kind !== 'panel' || id !== SCHEDULES_PANEL_ID) return parts
+			if (parts.length >= 2 && parts[0] === FILTER_SEGMENT && parts[1] === SCHEDULE_FILTERS[0]) return parts.slice(2)
+			return parts
+		}
+
 		/**
 		 * Read a route out of a location fragment.
 		 * @param {string} hash - the raw `window.location.hash`, including the leading `#`.
@@ -608,7 +1538,7 @@ window.__ModuleLoader__.load({
 			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
+			if (match[2] === undefined) return kind === 'settings' || kind === 'power' ? { 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') {
@@ -635,9 +1565,9 @@ window.__ModuleLoader__.load({
 			}
 			const segments = match[2].replace(/\/+$/, '').split('/')
 			const head = segments.shift() ?? ''
-			if (head === '') return kind === 'settings' ? { kind, id: '' } : undefined
+			if (head === '') return kind === 'settings' || kind === 'power' ? { kind, id: '' } : undefined
 			const id = decodePart(head).trim()
-			if (id === '') return kind === 'settings' ? { kind, id: '' } : undefined
+			if (id === '') return kind === 'settings' || kind === 'power' ? { 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
@@ -650,7 +1580,7 @@ window.__ModuleLoader__.load({
 			}
 			// 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() !== '')
+			const inner = normalisePanelInner(kind, id, segments.map(decodePart).filter(segment => segment.trim() !== ''))
 			return { kind, id, inner: inner.length === 0 ? undefined : inner }
 		}
 
@@ -663,6 +1593,10 @@ window.__ModuleLoader__.load({
 		function routeHash(kind, id, inner) {
 			// A modal surface has no identity: `#/settings`, not `#/settings/`.
 			if (kind === 'settings' && (id === undefined || id === '')) return '#/settings'
+			// The power menu has no identity of its own — there is one of it — but an *action* does:
+			// dropping it here would make the bar compare a typed `#/power/restart` against a bare
+			// `#/power` and call a command it had already sent "打不开" (measured 2026-10-29).
+			if (kind === 'power') return powerActionOf(id) === undefined ? '#/power' : `#/power/${encodeURIComponent(id)}`
 			if (kind === 'workspace') {
 				const rest = innerPath(inner)
 				const tail = rest.length === 0 ? '' : `/${rest.map(encodeURIComponent).join('/')}`
@@ -711,6 +1645,27 @@ window.__ModuleLoader__.load({
 			return rowId === '' ? undefined : { packageName: undefined, rowId }
 		}
 
+		/**
+		 * The control that opens the page a plugin row describes.
+		 *
+		 * The manager puts the row's own link first and its enable switch beside it, and both
+		 * are buttons. Clicking the switch on behalf of a pasted link would silently turn a
+		 * plugin off (measured: a component page link did exactly that while the row had no
+		 * configuration), so the switch is never picked. A row whose only button is the switch
+		 * has no page to open, and its link is left to expire with the usual diagnostic.
+		 * @param {object} element - the row, card or list item.
+		 * @returns {object|undefined} the control to click.
+		 */
+		function openControlOf(element) {
+			const buttons = attemptValue(() => [...(element?.querySelectorAll?.('button') ?? [])]) ?? []
+			for (const button of buttons) {
+				const role = typeof button?.getAttribute === 'function' ? button.getAttribute('role') : null
+				if (role === 'switch') continue
+				if (typeof button?.click === 'function') return button
+			}
+			return undefined
+		}
+
 		function innerPath(value) {
 			const parts = Array.isArray(value) ? value : String(value ?? '').split('/')
 			return parts.map(part => String(part).trim()).filter(part => part !== '')
@@ -780,7 +1735,7 @@ window.__ModuleLoader__.load({
 			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: [] }
+			const observed = { foreignFragment: undefined, ignored: [], warnings: [], compat: [] }
 			let rowAnchor
 			/** The pane kind this claim already opened (one drive per claim, see the pane branch). */
 			let paneOpenedFor
@@ -792,6 +1747,8 @@ window.__ModuleLoader__.load({
 			let innerAttempts = 0
 			/** Whether the current link already asked for a modal standing in front of it to go away. */
 			let overlayDismissed = false
+			/** When the compatibility checks last read the page (`-Infinity`: never swept). */
+			let lastCompatSweep = -Infinity
 			/** The view state observed on the previous notification. */
 			let seen = 'none'
 			let cancelTimer
@@ -809,6 +1766,10 @@ window.__ModuleLoader__.load({
 				panelAttempts = 0
 				innerAttempts = 0
 				paneOpenedFor = undefined
+				powerActionSent = false
+				powerActionAttempts = 0
+				linkedTyped = false
+				attemptValue(() => host.resetSettingsDrive?.())
 				dropTimer()
 			}
 			/**
@@ -816,27 +1777,41 @@ window.__ModuleLoader__.load({
 			 * conversation behind it, because the panel is what fills the screen.
 			 */
 			const canonical = () => {
+				// The power menu is a popover, not a surface: it is on top of everything, it closes
+				// the moment the reader touches anything else, and a link can only ever *open* it.
+				// While it is up it names itself, the same way the settings overlay does.
+				if (powerMenuOpenOf(window.document)) return { kind: 'power', id: '' }
 				// 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 (settingsOverlayOf(window.document) !== undefined) {
 					const section = host.activeSettingsSection() ?? ''
-					const tab = section === '' ? undefined : host.activeSettingsTab()
-					return tab === undefined ? { kind: 'settings', id: section } : { kind: 'settings', id: section, inner: [tab] }
+					const levels = section === '' ? [] : (attemptValue(() => host.activeSettingsLevels?.()) ?? [])
+					// A model-provider card whose editor is open is a page of its own: its id rides
+					// after the section (and after the tab, when the section has one).
+					const provider = section === '' ? undefined : host.activeSettingsProvider()
+					const inner = [...levels, ...(provider === undefined ? [] : [PROVIDER_SEGMENT, provider])]
+					return inner.length === 0 ? { kind: 'settings', id: section } : { kind: 'settings', id: section, inner }
 				}
 				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]) }
+					// The panel's own inner page comes first: a panel that reports a page has a page on
+					// screen that the reader can name, and the right-hand pane is a layer *beside* it.
+					// Naming the pane first is what used to hide the automation task's own link behind
+					// `pane/<kind>` (measured live).
 					const page = host.panelPage(id, panelScope)
-					if (page === undefined) return { kind: 'panel', id, inner: undefined }
 					const segments = innerPath(page)
 					// Remember the package a page was opened under, so a bare component page (which
 					// reports only its row) can still be named fully.
 					if (id === PLUGINS_PANEL_ID && segments.length === 1) panelScope = segments[0]
-					return { kind: 'panel', id, inner: segments }
+					// A panel's own page names what the main column shows, and the right-hand pane is
+					// secondary to it: the reader asked for the task (or the plugin row), not for the
+					// pane standing beside it, so the pane gives way. It is named only on a panel that
+					// has no page of its own. A collapsed bar keeps its tabs mounted, so it never
+					// counts at all (measured: the pane segment outlived its own bar).
+					const pane = segments.length > 0 || rightBarCollapsedOf(window.document) ? undefined : host.activePaneKind()
+					const inner = pane === undefined ? segments : [PANE_SEGMENT, pane]
+					return inner.length === 0 ? { kind: 'panel', id, inner: undefined } : { kind: 'panel', id, inner }
 				}
 				const session = host.mainViewSessionId()
 				if (session !== undefined && session !== null) {
@@ -857,7 +1832,14 @@ window.__ModuleLoader__.load({
 					// but never while a turn link is in flight: that link owns the address bar until it lands,
 					// and naming the turn here too is what made it look "landed" before it ever drove.
 					const anchoredTurn = linked === undefined && turnAnchor !== undefined && turnAnchor.session === id && turnAnchor.turn !== undefined && turnAnchor.turn !== '' ? [TURN_SEGMENT, turnAnchor.turn] : []
+					// Whose subagent this conversation is (empty for an ordinary session). It sits right
+					// after the id: everything after it is a position *inside* the conversation. The
+					// parent is decoration — landing compares the child id — so it is written as the
+					// parent's *title* when the catalog has one, and as its id otherwise.
+					const subagentOf = host.subagentParentOf(id)
+					const subagentLabel = subagentOf === undefined ? undefined : subagentDecorationOf(subagentOf)
 					const position = [
+						...(subagentLabel === undefined || subagentLabel === '' ? [] : [SUBAGENT_SEGMENT, subagentLabel]),
 						...(rowAnchor !== undefined && rowAnchor.session === id ? (rowAnchor.turn === undefined || rowAnchor.turn === '' ? [ROW_SEGMENT, ...rowAnchor.parts] : [TURN_SEGMENT, rowAnchor.turn, ROW_SEGMENT, ...rowAnchor.parts]) : []),
 						...(anchoredTurn.length > 0 && rowAnchor !== undefined && rowAnchor.session === id ? [] : anchoredTurn),
 						...(view !== undefined && view.index !== 0 ? [VIEW_SEGMENT, view.id] : []),
@@ -865,7 +1847,8 @@ window.__ModuleLoader__.load({
 					// 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()
+					// A collapsed bar keeps its tabs mounted, so it only counts while it is on screen.
+					const pane = rightBarCollapsedOf(window.document) ? undefined : host.activePaneKind()
 					const tail = pane === undefined ? [] : [PANE_SEGMENT, pane]
 					const workspaceName = host.workspaceNameOf(id)
 					if (workspaceName !== undefined) {
@@ -895,6 +1878,11 @@ window.__ModuleLoader__.load({
 				if (route?.kind === 'session') return route.id
 				return undefined
 			}
+			const subagentParentOfRoute = route => {
+				const parts = innerPath(route?.inner)
+				const at = parts.indexOf(SUBAGENT_SEGMENT)
+				return at < 0 ? undefined : parts[at + 1]
+			}
 			const viewIdOfRoute = route => {
 				const parts = innerPath(route?.inner)
 				const at = parts.indexOf(VIEW_SEGMENT)
@@ -911,6 +1899,27 @@ window.__ModuleLoader__.load({
 				// that is no longer in flight is never "the same route" as anything.
 				if (linked === undefined || linked === null) return false
 				if (routeKey(current) === routeKey(linked)) return true
+				// A panel's page may be *more* specific than the link (`plugins/<pkg>/<row>` for a
+				// `plugins/<pkg>` link), and the right-hand pane is a layer beside that page rather
+				// than part of it — so it is compared only when the link names one. Exact comparison
+				// is what left a link waiting on a page that was already open.
+				if (current?.kind === 'panel' || linked?.kind === 'panel') {
+					if (current?.kind !== linked.kind || current.id !== linked.id) return false
+					const pageOf = route => {
+						const parts = innerPath(route?.inner)
+						const at = parts.indexOf(PANE_SEGMENT)
+						return at < 0 ? parts : parts.slice(0, at)
+					}
+					// A link that names a pane asks for that pane, whatever else it names.
+					const wantedPane = paneOf(linked)
+					if (wantedPane !== undefined && paneOf(current) !== wantedPane) return false
+					const wanted = pageOf(linked)
+					if (wanted.length === 0) return true
+					// A page link is satisfied once that page is on screen; a link may be wider than the
+					// view (an open component satisfies a package link) but never narrower.
+					const shown = pageOf(current)
+					return wanted.length <= shown.length && wanted.every((part, index) => shown[index] === part)
+				}
 				const currentSession = sessionIdOfRoute(current)
 				const linkedSession = sessionIdOfRoute(linked)
 				if (currentSession !== undefined && linkedSession !== undefined) {
@@ -954,8 +1963,15 @@ window.__ModuleLoader__.load({
 				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
+				const wanted = settingsPartsOf(linked.inner)
+				const shown = settingsPartsOf(current.inner)
+				// Every level a link names has to be showing; extra levels on screen are a refinement
+				// of it (the same prefix rule the panel pages use, one row deeper each time).
+				if (wanted.levels.length > shown.levels.length) return false
+				if (!wanted.levels.every((level, index) => level === shown.levels[index])) return false
+				// A provider card is a page one level deeper than its section: a link that names one
+				// has to see that one open (the section alone is satisfied by any of its cards).
+				return wanted.provider === undefined || wanted.provider === shown.provider
 			}
 			/** Write the fragment for the current view, leaving path and query untouched. */
 			const reflect = route => {
@@ -988,6 +2004,7 @@ window.__ModuleLoader__.load({
 			 */
 			const reconcile = (source = 'boot') => {
 				if (disposed) return
+				workCounts.reconciles += 1
 
 				const current = canonical()
 				const currentKey = routeKey(current)
@@ -1000,6 +2017,22 @@ window.__ModuleLoader__.load({
 					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'}`)
 					}
+				// Say each compatibility problem once, before anything else in this step: a screen whose
+				// hooks moved does not throw, it just stops being nameable.
+				const sweepAt = host.now()
+				if (sweepAt - lastCompatSweep >= COMPAT_EVERY_MS) {
+					lastCompatSweep = sweepAt
+					const problems = compatibilityProblems(window.document, {
+						activePanelId: host.activePanelId(),
+						sessions: attemptValue(() => host.listedSessions?.()) ?? 0,
+						views: attemptValue(() => host.conversationViewIds?.())?.length ?? 0,
+					})
+					for (const problem of problems) {
+						if (observed.compat.includes(problem.name)) continue
+						observed.compat.push(problem.name)
+						host.warn(`${TAG} ${COMPAT_MESSAGE}：${problem.name} —— 期望 ${problem.expected}，实际 ${problem.found}。这一层的链接会静默失效，请升级 DSH 或本插件`)
+					}
+				}
 				// A position the previous step asked for: it is driven here, one step later, so the step
 				// that claimed it never drives while it is still running.
 				if (linked === undefined) {
@@ -1010,14 +2043,26 @@ window.__ModuleLoader__.load({
 				// (and re-entry can drop the link), so every read below must use the snapshot: reading the
 				// live binding again is how a drive turned into "Cannot read properties of undefined".
 				const link = linked
+				// The parent a subagent link names (decoration: the child alone is what opens).
+				const linkParent = subagentParentOfRoute(link)
 
 				if (sameRoute(current, link)) {
 					dropRetry()
 					// The link has landed: it stops being authoritative right here, so the user
 					// keeps owning the address bar afterwards (walking deeper inside a panel
 					// updates the URL instead of being pulled back to the link).
+					//
+					// A turn link that was already satisfied (its seat is on screen) still names where
+					// the reader is, so it becomes the anchor: writing the plain view instead is how a
+					// pasted `turn/<n>` link used to lose its turn the instant it landed.
+					const parts = innerPath(link.inner)
+					const at = parts.indexOf(TURN_SEGMENT)
+					if (at >= 0 && parts[at + 1] !== undefined && parts[at + 1] !== '') {
+						const session = link.kind === 'workspace' ? parts[1] : link.id
+						turnAnchor = { session, turn: parts[at + 1] }
+					}
 					dropLink()
-					reflect(current)
+					reflect(canonical())
 					return
 				}
 				if (host.now() >= link.deadline) {
@@ -1060,7 +2105,7 @@ window.__ModuleLoader__.load({
 					const shown = host.mainViewSessionId()
 					if (shown !== rowSession && panelAttempts < INNER_ATTEMPT_LIMIT) {
 						panelAttempts += 1
-						host.openSession(rowSession)
+						host.openSession(rowSession, linkParent)
 					} else if (shown === rowSession && innerAttempts < INNER_ATTEMPT_LIMIT) {
 						innerAttempts += 1
 						if (!host.revealPosition(rowParts.slice(rowAt)) && wantedTurn >= 0) host.revealPosition(rowParts.slice(wantedTurn, wantedTurn + 2), rowSession)
@@ -1076,7 +2121,7 @@ window.__ModuleLoader__.load({
 					const shown = host.mainViewSessionId()
 					if (shown !== wantedSession && panelAttempts < INNER_ATTEMPT_LIMIT) {
 						panelAttempts += 1
-						host.openSession(wantedSession)
+						host.openSession(wantedSession, linkParent)
 					} else if (shown === wantedSession && innerAttempts < INNER_ATTEMPT_LIMIT) {
 						innerAttempts += 1
 						host.openConversationView(wantedView)
@@ -1091,7 +2136,88 @@ window.__ModuleLoader__.load({
 					const shown = host.mainViewSessionId()
 					if (shown !== target && source !== 'hash' && panelAttempts < INNER_ATTEMPT_LIMIT) {
 						panelAttempts += 1
-						host.openSession(target)
+						host.openSession(target, linkParent)
+					}
+					armRetry()
+					return
+				}
+				if (link.kind === 'power') {
+					// `#/power/shutdown` and `#/power/restart` are commands, and they are the one route
+					// that must not be reachable by a link somebody else wrote: a URL is easy to click
+					// by accident, and this one ends the application. So the action runs only for a
+					// fragment the reader typed into the address bar (`typedClaim`), exactly once per
+					// claim — and a hash read lowers the flag, which is what makes a link in a chat
+					// message, a README or an AI reply harmless.
+					const action = powerActionOf(link.id)
+					if (action !== undefined) {
+						if (!linkedTyped || powerActionSent) {
+							// This branch is the one that used to answer a typed command with nothing at
+							// all, and it left no trace: a desktop window has no console, so say it in
+							// the report instead of guessing next time.
+							if (!linkedTyped && !powerIgnored) {
+								powerIgnored = true
+								note(`${TAG} ignoring power action "${action}": this fragment did not come from the address bar`)
+							}
+							armRetry()
+							return
+						}
+						// Refuse only when the address bar names a *different* power action: that is the
+						// claim having gone stale, and running it would fire the wrong command (a shutdown
+						// fired by a link that asked for a restart is not something to be clever about).
+						//
+						// It must not refuse merely because the bar does not name *this* action: the router
+						// itself rewrites the bar to the canonical of what is on screen, and opening the
+						// menu makes that canonical `#/power` — so a stricter rule refused our own first
+						// drive step, and the reader had to press Enter twice (measured 2026-10-29).
+						const typed = parseRoute(String(host.readLocation().hash ?? ''))
+						const namesOtherAction = typed !== undefined && typed.kind === 'power' && typed.id !== '' && typed.id !== link.id
+						if (namesOtherAction) {
+							note(`${TAG} refusing power action "${action}": the address bar names "${String(typed.id)}"`)
+							powerActionSent = true
+							armRetry()
+							return
+						}
+						// The plugin's own path first: its menu, then the item it publishes for this
+						// action — that way its own flow runs (its overlay, and any confirmation it may
+						// add later). The endpoint is the fallback for a menu that never yields the
+						// item, so a command can never end in a silent no-op.
+						if (!powerMenuOpenOf(window.document)) {
+							if (powerActionAttempts < POWER_ACTION_MENU_LIMIT) {
+								powerActionAttempts += 1
+								innerAttempts += 1
+								host.openPowerMenu()
+								// The focus is deliberately left alone: the plugin keeps it on its own
+								// trigger and hangs its arrow-key navigation there (fixed 2026-10-29 by
+								// removing its `first.focus()`), so stealing it back would kill that.
+							} else {
+								note(`${TAG} running power action "${action}" through the plugin endpoint (its menu published no item)`)
+								powerActionSent = true
+								host.powerAction(action)
+							}
+							armRetry()
+							return
+						}
+						if (host.clickPowerItem(action)) {
+							note(`${TAG} running power action "${action}" through the plugin's own menu item`)
+							powerActionSent = true
+							armRetry()
+							return
+						}
+						powerActionAttempts += 1
+						if (powerActionAttempts >= POWER_ACTION_MENU_LIMIT) {
+							note(`${TAG} running power action "${action}" through the plugin endpoint (no menu item published it)`)
+							powerActionSent = true
+							host.powerAction(action)
+						}
+						armRetry()
+						return
+					}
+					// A bare `#/power` only opens the menu. It is a toggle: it is clicked only while it
+					// is closed, so a retry can never open it and close it again. The items inside it
+					// are never clicked — opening a menu is a place, acting on it is a person's call.
+					if (innerAttempts < INNER_ATTEMPT_LIMIT && !powerMenuOpenOf(window.document)) {
+						innerAttempts += 1
+						host.openPowerMenu()
 					}
 					armRetry()
 					return
@@ -1099,7 +2225,8 @@ window.__ModuleLoader__.load({
 				if (link.kind === 'settings') {
 					if (source !== 'hash' && innerAttempts < INNER_ATTEMPT_LIMIT) {
 						innerAttempts += 1
-						host.openSettings(link.id, innerPath(link.inner)[0])
+						const parts = settingsPartsOf(link.inner)
+						host.openSettings(link.id, parts.levels, parts.provider)
 					}
 					armRetry()
 					return
@@ -1143,7 +2270,7 @@ window.__ModuleLoader__.load({
 						// idempotent on a conversation that is not shown yet (no seats, nothing to scroll to, and
 						// the paging path is a no-op too), and waiting for the main-view counter to catch up is
 						// what left a cold-opened turn link doing nothing at all.
-						host.openSession(wantedSession)
+						host.openSession(wantedSession, linkParent)
 						host.revealPosition(innerPath([TURN_SEGMENT, wantedTurn]), wantedSession)
 						// A row may follow the turn (`turn/<n>/row/…`): reveal it after the turn.
 						const rowAt = innerPath(link.inner).indexOf(ROW_SEGMENT)
@@ -1190,7 +2317,16 @@ window.__ModuleLoader__.load({
 					// with a bound so an unopenable page cannot turn into a click loop.
 					if (link.inner !== undefined && routeKey(current) !== routeKey(link) && source !== 'hash' && innerAttempts < INNER_ATTEMPT_LIMIT) {
 						innerAttempts += 1
-						host.openPanelPage(link.id, link.inner)
+						// A pane tail names the right bar, not the panel's page: handing it to the
+						// panel would ask that panel to open a page called `files` (measured on a
+						// link the router itself had written while both were open).
+						const parts = innerPath(link.inner)
+						const paneAt = parts.indexOf(PANE_SEGMENT)
+						const wantedPane = paneAt < 0 ? undefined : parts[paneAt + 1]
+						host.openPanelPage(link.id, paneAt < 0 ? parts : parts.slice(0, paneAt))
+						if (wantedPane !== undefined && host.activePaneKind() !== wantedPane) {
+							host.openPane(wantedPane, 'panel', message => host.warn(message))
+						}
 					}
 					armRetry()
 					return
@@ -1205,7 +2341,7 @@ window.__ModuleLoader__.load({
 				}
 				if ((!claimed || moved) && host.isOpenable(link.id)) {
 					claimed = true
-					host.openSession(link.id)
+					host.openSession(link.id, linkParent)
 				}
 			}
 			/** Adopt the surface the address bar names, if it names one. */
@@ -1239,6 +2375,7 @@ window.__ModuleLoader__.load({
 					return
 				}
 				if (linked === undefined || linked.kind !== parsed.kind || linked.id !== parsed.id) {
+					linkedTyped = typedClaim
 					linked = { kind: parsed.kind, id: parsed.id, inner: parsed.inner, deadline: host.now() + LINK_ENFORCE_WINDOW_MS }
 					if (parsed.kind === 'panel' && parsed.inner !== undefined) panelScope = innerPath(parsed.inner)[0]
 					claimed = false
@@ -1291,7 +2428,43 @@ window.__ModuleLoader__.load({
 				retryTimer?.()
 				retryTimer = undefined
 			}
+			// A power action is honoured only for a fragment the reader typed themselves: the flag is
+			// raised by the address bar's own hand-off and lowered by every browser-driven hash read.
+			let typedClaim = false
+			/**
+			 * The fragment the reader last drove by hand.
+			 *
+			 * Writing the hash makes the browser deliver a `hashchange` of our own write, one task
+			 * later. That echo arrives after the link has already been dropped (a command lands
+			 * immediately, by definition), so it would create a *fresh* claim that is not typed —
+			 * and the command the reader typed was then refused, silently, until they pressed Enter
+			 * a second time (measured 2026-10-29). Recognising the echo keeps the claim theirs.
+			 */
+			let typedEcho = ''
+			/** Whether this claim already said out loud that it was not the reader's. */
+			let powerIgnored = false
+			// Whether *the claim in flight* came from the address bar's own hand-off. The flag above
+			// only survives one read; a command needs its authority for the whole claim, because its
+			// drive retries (that is how the plugin's menu gets its budget).
+			let linkedTyped = false
+			// How many steps the plugin's own menu has had for this claim, before the endpoint takes over.
+			let powerActionAttempts = 0
+			// One action per claim: a POST that is retried because the app is slow to die would
+			// otherwise fire twice.
+			let powerActionSent = false
 			const safeReadLink = () => guard(readLink)
+			/**
+			 * Record a line about a command the reader typed.
+			 *
+			 * A desktop window has no console, so `host.warn` alone leaves no trace anyone can read:
+			 * the observation report is where a person can see what a destructive command actually
+			 * did. Both get the line.
+			 * @param {string} message - the line.
+			 */
+			const note = message => {
+				if (!observed.warnings.includes(message)) observed.warnings.push(message)
+				host.warn(message)
+			}
 			// The desktop address bar hands its fragment over here instead of relying on the
 			// browser: a programmatic hash write fires `hashchange` in a browser, but a hash
 			// equal to the current one fires nothing at all, and the desktop shell serves the
@@ -1299,15 +2472,34 @@ window.__ModuleLoader__.load({
 			// listener uses makes the bar work in both cases. The hash is still written, so the
 			// address bar, Back/Forward and copied links all agree with what is on screen.
 			driveTypedFragment = fragment => {
+				typedClaim = true
+				typedEcho = fragment
+				// A fresh command gets the full menu budget, however many times the reader pastes it.
+				powerActionSent = false
+				powerActionAttempts = 0
+				powerIgnored = false
+				// And it re-arms the claim it names. Without this, a link that had *already* arrived
+				// some other way (a chat message the reader clicked) keeps the claim it made, and the
+				// same fragment typed afterwards found `linked.id === parsed.id`, made no new claim,
+				// and stayed refused — a command the reader typed was answered with nothing at all
+				// (measured 2026-10-29).
+				if (linked !== undefined) linkedTyped = true
 				attemptValue(() => {
 					window.location.hash = fragment
 				})
 				safeReadLink()
+				typedClaim = false
 			}
 			const offPanel = host.onPanelChange(() => safeReconcile('panel'))
 			const offCatalog = host.onCatalogChange(() => safeReconcile('catalog'))
 			const offDom = host.onDomChange(() => safeReconcile('dom'))
-			const offHashChange = host.onHashChange(() => safeReadLink())
+			const offHashChange = host.onHashChange(() => {
+				// A hash read is never a typed link: whoever wrote the fragment (a chat message, a
+				// page, a plugin) does not get to run a command — with one exception, the echo of the
+				// reader's own write, which is what makes a command work on the first Enter.
+				typedClaim = readableFragment(String(attemptValue(() => window.location.hash) ?? '')) === readableFragment(typedEcho)
+				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
@@ -1393,6 +2585,14 @@ window.__ModuleLoader__.load({
 						paneActive: attemptValue(() => host.activePaneKind()) ?? null,
 						paneKinds: attemptValue(() => host.paneKinds?.()) ?? null,
 					},
+					// The address bar's own preferences, so a bug report can say what the bar
+					// was told to do without opening the settings page.
+					preferences: {
+						selectAllOnFocus: readSettings().selectAllOnFocus,
+						recentLimit: readSettings().recentLimit,
+						remembered: recentEntries().length,
+					},
+					work: { reconciles: workCounts.reconciles, placements: workCounts.placements },
 					compat: observed.compat,
 					foreignFragment: observed.foreignFragment,
 					ignoredKinds: observed.ignored,
@@ -1865,7 +3065,15 @@ window.__ModuleLoader__.load({
 				faces: {
 					catalog: list,
 					archivedSessionIds: () => registry.getSnapshot().archivedSessionIds,
-					openSession: id => openSession.call(navigation, id),
+					openSession: (id, parent) => {
+						if (parent === undefined || parent === null || parent === '') return openSession.call(navigation, id)
+						// A subagent view is opened by its address (parent + child + mode), not by the
+						// plain session id: that is the shape `uiWorkspace.openSession` declares
+						// (`SessionTarget = SessionId | SubagentAddress`). The mode is durable in the
+						// catalog, so it is read back rather than guessed.
+						const mode = attemptValue(() => sessions?.subagentAddress?.(id)?.mode) ?? 'unknown'
+						return openSession.call(navigation, { parentSessionId: parent, childSessionId: id, mode })
+					},
 					selectPanel: selectPanel === undefined ? undefined : id => selectPanel(id),
 					beginNavigation: beginNavigation === undefined ? undefined : () => beginNavigation(),
 				openRightbar: openRightbar === undefined ? undefined : track => openRightbar(track),
@@ -1896,12 +3104,27 @@ window.__ModuleLoader__.load({
 					return fallback
 				}
 			}
+			/**
+			 * How many times this link has pressed the settings launcher.
+			 *
+			 * The launcher is a *toggle*, so it may only be pressed while no menu is on screen: a
+			 * press that opened nothing may be retried (bounded), a press that opened something must
+			 * never be repeated — that would close it again. Reset with the claim, never per retry.
+			 */
+			let settingsLauncherPresses = 0
 			const archived = () => {
 				const ids = attempt(() => faces.archivedSessionIds(), [])
 				return Array.isArray(ids) ? ids : []
 			}
 			const host = {
 				mainViewSessionId: () => attempt(() => mainViewSessionId(faces.catalog.getSnapshot().byId), undefined),
+				// How many conversations the catalog lists: the compatibility check uses it to tell
+				// "an empty sidebar" from "a sidebar whose rows are no longer where they were".
+				listedSessions: () => attemptValue(() => {
+					const snapshot = faces.catalog.getSnapshot()
+					if (Array.isArray(snapshot?.ids)) return snapshot.ids.length
+					return Object.keys(snapshot?.byId ?? {}).length
+				}, 0),
 				// 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 => {
@@ -1926,6 +3149,19 @@ window.__ModuleLoader__.load({
 				// The inner page a panel is showing, in that panel's own vocabulary. Each panel
 				// publishes it with a data attribute; reading it is the whole reflect direction.
 				panelPage: (panelId, scope) => {
+					if (panelId === SCHEDULES_PANEL_ID) {
+						// Two dimensions, in one path: the status filter the list shows (the default
+						// `all` is not written) and the task whose detail is open (with its tab).
+						const segments = []
+						const filter = scheduleFilterOf(window.document)
+						if (filter !== undefined && filter !== SCHEDULE_FILTERS[0]) segments.push(FILTER_SEGMENT, filter)
+						const task = scheduleTaskOf(window.document)
+						if (task !== undefined) {
+							segments.push(TASK_SEGMENT, task.id)
+							if (task.tab !== 'rule') segments.push(task.tab)
+						}
+						return segments.length === 0 ? undefined : segments
+					}
 					if (panelId === TASK_BOARD_PANEL_ID) {
 						// The form and a task are mutually exclusive, and the form wins when both
 						// would be reported (it is the page the user is looking at).
@@ -1949,6 +3185,15 @@ window.__ModuleLoader__.load({
 				},
 				openPanelPage: (panelId, inner) => {
 					const asked = innerPath(inner)
+					if (panelId === SCHEDULES_PANEL_ID) {
+						// Oldest first: the filter decides which rows the list holds, so it is pressed
+						// before a task in that list is asked for.
+						const filterAt = asked.indexOf(FILTER_SEGMENT)
+						if (filterAt >= 0) clickScheduleFilter(asked[filterAt + 1])
+						const taskAt = asked.indexOf(TASK_SEGMENT)
+						if (taskAt >= 0 && asked[taskAt + 1] !== undefined) clickScheduleTask(asked[taskAt + 1], asked[taskAt + 2])
+						return
+					}
 					if (panelId === TASK_BOARD_PANEL_ID) {
 						// The task board owns how its overlays open: we hand over the request on its
 						// own contract (window events) and nothing else crosses the seam.
@@ -1974,8 +3219,9 @@ window.__ModuleLoader__.load({
 						const pkg =
 							window.document?.querySelector?.(`li[data-plugin-package="${segments[0]}"]`) ??
 							window.document?.querySelector?.(`li[data-plugin-item="${segments[0]}"]`)
-						const button = pkg?.querySelector?.('button')
-						if (typeof button?.click === 'function') button.click()
+						// Never the enable switch: a link opens a page, it never changes a plugin.
+						const button = openControlOf(pkg)
+						if (button !== undefined) button.click()
 						if (segments.length === 1) return
 					}
 					const rowId = segments[segments.length - 1]
@@ -1983,8 +3229,8 @@ window.__ModuleLoader__.load({
 					for (const row of rows) {
 						const parsed = splitRowHook(typeof row.getAttribute === 'function' ? row.getAttribute('data-plugin-row') : null)
 						if (parsed === undefined || parsed.rowId !== rowId) continue
-						const button = row.querySelector?.('button')
-						if (typeof button?.click === 'function') button.click()
+						const button = openControlOf(row)
+						if (button !== undefined) button.click()
 						return
 					}
 				},
@@ -1999,9 +3245,20 @@ window.__ModuleLoader__.load({
 				// A panel id nobody registered is refused by the layout by THROWING
 				// (`selectPanel: main panel "x" is not registered`), so the claim is
 				// swallowed here and reported as "the view did not move" at expiry.
-				openSession: id => {
-					attempt(() => faces.openSession(id))
+				openSession: (id, parent) => {
+					// A parent segment that is a title (not an id) is a label: the child still opens by
+					// its own id, which is the identity the route carries anyway.
+					attempt(() => faces.openSession(id, isSessionIdLike(parent) ? parent : undefined))
 				},
+				// The parent a subagent session belongs to, from the catalog (no session opened), with the
+				// title the catalog keeps for it — the decoration reads better than a uuid.
+				subagentParentOf: id => attemptValue(() => {
+					const snapshot = faces.catalog.getSnapshot()
+					const parentId = snapshot?.byId?.[id]?.parentSessionId ?? faces.sessions?.subagentAddress?.(id)?.parentSessionId
+					if (parentId === undefined || parentId === null || parentId === '') return undefined
+					const title = snapshot?.byId?.[parentId]?.title
+					return { id: String(parentId), title: typeof title === 'string' ? title : '' }
+				}, undefined),
 				// 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 => {
@@ -2056,6 +3313,7 @@ window.__ModuleLoader__.load({
 				revealPosition: (parts, wantedSession) => {
 					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}]`) ?? []) {
@@ -2088,16 +3346,46 @@ window.__ModuleLoader__.load({
 					// from the catalog here is how this step used to look up "no session".
 					const reference = attemptValue(() => faces.sessions?.retainScope?.(wantedSession, 'url-router'))
 					const session = attemptValue(() => reference?.binding?.session)
-					const loadThrough = attemptValue(() => (session === undefined || session === null ? undefined : session.loadThrough))
 					const outline = attemptValue(() => session?.projections?.faceOf?.('turnOutline')?.getSnapshot?.())
 					const seq = Array.isArray(outline) ? outline.find(entry => entry && String(entry.turn) === String(turn))?.seq : undefined
-					const usable = typeof loadThrough === 'function' && typeof reference?.release === 'function'
+					// The loader is called **on the session**, never through a detached reference:
+					// `loadThrough` is a prototype method in this build and reads `this.openState`, so
+					// destructuring it (`const load = session.loadThrough`) throws on every call.
+					const usable = typeof session?.loadThrough === 'function' && typeof reference?.release === 'function'
 					if (typeof seq !== 'number' || !usable) {
 						attemptValue(() => reference?.release?.())
 						return false
 					}
-					attemptValue(() => loadThrough(seq))
+					// The loader resolves when the pages are in, but the chat renders them on its own
+					// commit — so the seat shows up a frame or two later, and until something scrolls
+					// to it the virtual list simply trims the freshly loaded turns again. The official
+					// chat does the same two steps (`loadThrough(seq)` then `scrollToTurn(turn)`); this
+					// is the scroll half, without a handle on its navigation object.
+					const scrollToSeat = () => {
+						const seat = attemptValue(() => document?.querySelector?.(`[${TURN_ATTRIBUTE}="${turn}"]`))
+						if (seat === null || seat === undefined) return false
+						attempt(() => seat.scrollIntoView?.({ block: 'center' }))
+						return true
+					}
+					const pending = attemptValue(() => session.loadThrough(seq))
 					attemptValue(() => reference.release())
+					if (pending !== undefined && pending !== null && typeof pending.then === 'function') {
+						pending.then(
+							() => {
+								// A few frames of patience: the seat is rendered by the next commit.
+								let tries = 0
+								const tick = () => {
+									tries += 1
+									if (tries > 25 || scrollToSeat()) return
+									attemptValue(() => window.setTimeout?.(tick, 50))
+								}
+								tick()
+							},
+							() => {},
+						)
+					} else {
+						scrollToSeat()
+					}
 					return true
 				},
 				// Which conversation view is showing. The registry is the source of truth for ids
@@ -2117,18 +3405,39 @@ window.__ModuleLoader__.load({
 						break
 					}
 					if (index < 0) return undefined
+					const selected = tabs[index]
+					// The header prints one label per visible tab, and the slot says which id carries
+					// it — that pair survives the "…" overflow, which hides tabs from the DOM while
+					// their views still exist (positional mapping cannot see those at all).
+					const text = typeof selected?.textContent === 'string' ? selected.textContent.trim() : ''
+					const labelled = conversationViewLabelsOf(faces.slots)
+					if (text !== '') {
+						const match = labelled.filter(entry => entry.label === text)
+						if (match.length === 1) {
+							const at = labelled.indexOf(match[0])
+							return { id: match[0].id, index: at, total: labelled.length }
+						}
+					}
+					// No label pair (a build with no slot labels): fall back to registration order,
+					// and only while every view is rendered — a wrong id is worse than none.
 					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 tabs = typeof row?.querySelectorAll === 'function' ? [...row.querySelectorAll('[role="tab"]')] : undefined
+					if (tabs === undefined || tabs.length === 0) return
+					// By label first, for the same reason the reflect side does: the tab's text is
+					// what the reader picks, and the slot says which id sits behind it.
+					const labelled = conversationViewLabelsOf(faces.slots)
+					const entry = labelled.find(item => item.id === viewId)
+					const byLabel = entry === undefined || entry.label === ''
+						? undefined
+						: tabs.find(tab => (typeof tab.textContent === 'string' ? tab.textContent.trim() : '') === entry.label)
 					const ids = conversationViewIdsOf(faces)
-					if (ids === undefined) return
-					const index = ids.indexOf(viewId)
-					const tab = index < 0 ? undefined : tabs[index]
+					const index = ids === undefined ? -1 : ids.indexOf(viewId)
+					const tab = byLabel ?? (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;
@@ -2158,10 +3467,13 @@ window.__ModuleLoader__.load({
 						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
+					// The controller first: it holds the live tab descriptor (`{ id, kind, title }`), so
+					// its kind survives a title that is no longer the kind — a Files tab showing a file
+					// is titled with the file name (`client.js`), and the DOM only carries that title.
 					const fromController = read(faces.sidebarRight)
 					if (fromController !== undefined) return fromController
+					const fromStrip = activePaneTabOf(window.document, paneRegistryOf(faces))
+					if (fromStrip !== undefined) return fromStrip
 					const fromRegistry = read(faces.sidebarRightTabs)
 					if (fromRegistry !== undefined) return fromRegistry
 					// DOM fallback, deliberately narrow: the active-pane marker is shared with the
@@ -2189,18 +3501,12 @@ window.__ModuleLoader__.load({
 					}
 					return undefined
 				},
+				// The model-provider card whose editor is open, when one is (see the helper).
+				activeSettingsProvider: () => openSettingsProviderId(window.document),
 				// The tab a settings section is showing: the same ARIA contract one level deeper.
-				activeSettingsTab: () => {
-					const overlay = settingsOverlayOf(window.document)
-					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
-				},
+				// Every settings row's selected control, in row order: the section's tabs, then the
+				// row a tab reveals, and so on — the path a settings link can name.
+				activeSettingsLevels: () => settingsSelectedLabelsOf(settingsOverlayOf(window.document)),
 				// The overlay is a modal, and the platform's own dismiss path is a document-level
 				// Escape: the shipped modal layer registers `document.addEventListener('keydown',
 				// handler, true)` gated on `key === 'Escape'` and closes the topmost modal there.
@@ -2214,44 +3520,118 @@ window.__ModuleLoader__.load({
 						window.document?.dispatchEvent?.(event)
 					})
 				},
-				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 = settingsOverlayOf(window.document)
-						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())
+				// Run a power action through the power plugin's own published endpoint. The endpoint
+				// answers by ending the application (or relaunching it), so nothing is read back: the
+				// call is fire-and-forget, and a composition without that plugin simply 404s.
+				// Click the item the power plugin publishes for an action. Contract attribute first
+				// (`data-dsh-power-action`), then the item's own label; when neither matches, the
+				// caller falls back to the endpoint rather than guessing at a button.
+				clickPowerItem: action => {
+					if (POWER_ACTIONS[action] === undefined) return false
+					const menu = powerMenuOf(window.document)
+					if (menu === undefined) return false
+					// Contract attribute only. Matching the item by its *label* would be guessing at a
+					// button that ends the application, and the two labels are a hair apart (关闭DSH /
+					// 重启DSH) — a wrong guess is not recoverable, so an unlabelled menu is left to the
+					// endpoint, which names the action in the URL itself.
+					const contracted = attemptValue(() => [...(menu.querySelectorAll?.(`[data-dsh-power-action="${action}"]`) ?? [])])
+					if (!Array.isArray(contracted) || contracted.length === 0) return false
+					pressElement(contracted[0])
+					return true
+				},
+				powerAction: action => {
+					// A wrong base answers 404 and does nothing, so the candidates are tried in order
+					// until one accepts the request. The last failure is named once, because a desktop
+					// window has no console and a silent no-op is the worst possible answer here.
+					const send = index => {
+						if (index >= POWER_ACTION_BASES.length) {
+							host.warn(`${TAG} no power plugin answered ${action}: tried ${POWER_ACTION_BASES.join(', ')}`)
+							return
+						}
+						const endpoint = `${POWER_ACTION_BASES[index]}/${action}`
+						const result = attemptValue(() => window.fetch?.(endpoint, {
+							method: 'POST',
+							credentials: 'same-origin',
+							headers: { 'content-type': 'application/json' },
+							body: '{}',
+						}))
+						if (result === undefined || typeof result.then !== 'function') return
+						result.then(response => {
+							if (response?.ok !== true) send(index + 1)
+						}).catch(() => send(index + 1))
+					}
+					send(0)
+				},
+				// Open the power menu. A link may do this; nothing inside the menu is ever clicked.
+				openPowerMenu: () => {
+					if (powerMenuOpenOf(window.document)) return
+					const trigger = powerTriggerOf(window.document)
+					if (typeof trigger?.click === 'function') attempt(() => trigger.click())
+				},
+				openSettings: (section, levels, provider) => {
+					const overlay = settingsOverlayOf(window.document)
+					if (overlay !== undefined) {
+						// The overlay is what the link asked for. A named section (and its tab, and one of
+						// its cards) is picked inside it; a bare link is already satisfied.
+						settingsLauncherPresses = 0
+						if (typeof section !== 'string' || section === '') return
+						if (typeof overlay.querySelectorAll !== 'function') return
+						const candidates = [...overlay.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') return
+						// The section that is already showing is not pressed again: a section re-render can
+						// close a card editor the link asked for (its drive is retried every half second).
+						const current = candidates.find(candidate => attemptValue(() => candidate.getAttribute?.('aria-current')) === 'true')
+						if (current !== match) attempt(() => match.click())
+						// Deeper levels, in order, each looked up in a row *after* the one the previous
+						// level matched — two rows can share a label (`皮肤` is both a section tab and a
+						// row inside 创意工坊), and a cursor keeps them apart. One level per call: the
+						// row a click reveals arrives with the next render, and the retry picks it up.
+						let cursor = -1
+						for (const level of innerPath(levels)) {
+							const rows = settingsRowsOf(overlay)
+							let hit
+							for (let index = cursor + 1; index < rows.length; index += 1) {
+								const control = settingsControlOf(rows[index], level)
+								if (control !== undefined) {
+									hit = { index, control, row: rows[index] }
+									break
 								}
-								return
 							}
+							if (hit === undefined) break
+							cursor = hit.index
+							if (!controlIsOn(hit.row, hit.control)) attempt(() => hit.control.click())
 						}
+						// And one of its cards may be the page a link named.
+						if (typeof provider === 'string' && provider !== '') clickSettingsProvider(provider)
+						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())
+					// The seat carries the shell's own store, and its actions own the panel's open state and
+					// active section — so the panel is opened through it, without replaying any clicks.
+					if (openSettingsThroughStore(faces, section)) return
+					// Otherwise the reader's own path is replayed. A settings item already on
+					// screen (the reader's menu, or one this link opened) is pressed instead of the launcher;
+					// otherwise the launcher is pressed — never while a menu is up (that would close it
+					// again), and only a bounded number of times (a press that opened nothing is retried).
+					const item = settingsMenuItemOf(window.document)
+					if (item !== undefined) {
+						settingsLauncherPresses = 0
+						pressElement(item)
 						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())
+					if (visibleMenuOf(window.document) !== undefined) return
+					if (settingsLauncherPresses >= SETTINGS_PRESS_LIMIT) return
+					const button = settingsLauncherOf(window.document) ?? labelledSettingsEntryOf(window.document)
+					if (button === undefined) return
+					settingsLauncherPresses += 1
+					pressElement(button)
+				},
+				resetSettingsDrive: () => {
+					settingsLauncherPresses = 0
 				},
 				openPane: (kind, track, warn) => {
 					if (typeof kind !== 'string' || kind === '') return
@@ -2355,7 +3735,22 @@ window.__ModuleLoader__.load({
 					attempt(() => {
 						const root = window.document?.body ?? window.document?.documentElement
 						if (root === undefined || root === null || typeof window.MutationObserver !== 'function') return () => {}
-						const observer = new window.MutationObserver(handler)
+						// One reconcile per frame. A streaming answer mutates the page dozens of times a
+						// second, and every batch re-reads the whole view state (the sidebar's rows
+						// included). A host without frames (tests, a minimal DOM) runs the handler
+						// straight away, which is what the fake DOM relies on.
+						let queued = false
+						const flush = () => {
+							queued = false
+							handler()
+						}
+						const schedule = () => {
+							if (queued) return
+							queued = true
+							const frame = attemptValue(() => window.requestAnimationFrame?.(flush))
+							if (frame === undefined) flush()
+						}
+						const observer = new window.MutationObserver(schedule)
 						// Every published page hook must be watched: a filter that names only some of
 						// them silently starves the retry loop of notifications (real bug: the task
 						// board's drive looked flaky because its attributes were not observed).
@@ -2374,6 +3769,10 @@ window.__ModuleLoader__.load({
 								'aria-current',
 								// Switching a settings *tab* moves this one, for the same reason.
 								'aria-selected',
+								// The automation list's status filter is three buttons whose only state is
+								// this attribute, and pressing one touches nothing else: without it here the
+								// address bar kept the filter it saw first.
+								'aria-pressed',
 								SETTINGS_SURFACE_ATTRIBUTE,
 							],
 						})
@@ -2448,6 +3847,231 @@ window.__ModuleLoader__.load({
 			return undefined
 		}
 
+		/**
+		 * The "Settings" item of the launcher menu, when this build puts the overlay one menu down.
+		 *
+		 * The sidebar gear opens a popover on rc.3 (measured: Settings / Feedback / Sign in), so
+		 * clicking the gear alone leaves the overlay closed and every settings link expires. The
+		 * item's text carries its shortcut (`Settings⌥⌘,`), so only the head of the label matches.
+		 * @param {object} document - the document.
+		 * @returns {object|undefined} the menu item that opens the overlay.
+		 */
+		/**
+		 * Whether an element is really on screen.
+		 *
+		 * The shell keeps closed popovers mounted, so "the selector matches" proves nothing: a
+		 * hidden item is unpressable, and pressing it also stops the launcher from being pressed
+		 * again. `offsetParent` is useless here — a fixed-position popover reports null while it
+		 * is perfectly visible — so the rect list is the test.
+		 * @param {object} node - the element.
+		 * @returns {boolean} whether it is visible.
+		 */
+		function onScreen(node) {
+			if (node === null || node === undefined) return false
+			if (typeof node.closest === 'function' && node.closest('[hidden]') !== null) return false
+			const rects = attemptValue(() => node.getClientRects?.())
+			if (Array.isArray(rects) && rects.length === 0) return false
+			return true
+		}
+
+		/**
+		 * The open popover, when one is on screen.
+		 *
+		 * One selector at a time: a comma list is beyond a small DOM stub.
+		 * @param {object} document - the document.
+		 * @returns {object|undefined} the popover root.
+		 */
+		function visibleMenuOf(document) {
+			for (const selector of ['[role="menu"]']) {
+				const nodes = attemptValue(() => [...(document?.querySelectorAll?.(selector) ?? [])])
+				if (!Array.isArray(nodes)) continue
+				for (const node of nodes) {
+					if (onScreen(node)) return node
+				}
+			}
+			return undefined
+		}
+
+		/**
+		 * The "Settings" item of the launcher menu, when this build puts the overlay one menu down.
+		 *
+		 * The seat is single-occupant, so a shell that seats an account row there turns the gear
+		 * into a menu trigger (measured on the desktop: the trigger is labelled with the account
+		 * name and carries `aria-haspopup="menu"`). The item is matched by its label — its head may
+		 * carry a shortcut (`Settings⌥⌘,`) and it need not be a `menuitem` at all — and only while
+		 * the menu is really on screen.
+		 * @param {object} document - the document.
+		 * @returns {object|undefined} the menu item that opens the overlay.
+		 */
+		function settingsMenuItemOf(document) {
+			const menu = visibleMenuOf(document)
+			const scopes = menu === undefined ? [document] : [menu]
+			for (const scope of scopes) {
+				for (const selector of ['[role="menuitem"]', 'button', '[role="option"]', 'a']) {
+					const nodes = attemptValue(() => [...(scope?.querySelectorAll?.(selector) ?? [])])
+					if (!Array.isArray(nodes)) continue
+					for (const node of nodes) {
+						if (!onScreen(node)) continue
+						const label = String(node.textContent ?? '').trim()
+						if (!/设置|settings/i.test(label)) continue
+						// Outside a menu, only a real menu item counts: a stray button that happens to
+						// be labelled "设置" is not this drive's to press.
+						if (menu === undefined && node.getAttribute?.('role') !== 'menuitem') continue
+						return node
+					}
+				}
+			}
+			return undefined
+		}
+
+		/**
+		 * Whether the power menu is open.
+		 *
+		 * It is the one surface this router reads from another *plugin*, not from the platform, so
+		 * the contract attribute comes first and the plugin's own class names are the fallback for
+		 * a build that predates it. Nothing here writes anything: it only answers "is the popover
+		 * up", which is what makes the menu a routable (if transient) place.
+		 * @param {object} document - the document.
+		 * @returns {boolean} whether the menu is on screen.
+		 */
+		function powerMenuOpenOf(document) {
+			const marked = attemptValue(() => document?.querySelector?.(`[${POWER_MENU_ATTRIBUTE}]`))
+			if (marked !== null && marked !== undefined) {
+				const value = typeof marked.getAttribute === 'function' ? marked.getAttribute(POWER_MENU_ATTRIBUTE) : null
+				return value === null || value === '' || value === 'open'
+			}
+			const menus = attemptValue(() => document?.getElementsByClassName?.(POWER_MENU_CLASS))
+			if (menus !== undefined && menus !== null && menus.length > 0) return true
+			const triggers = attemptValue(() => document?.getElementsByClassName?.(POWER_TRIGGER_CLASS))
+			const trigger = triggers?.[0]
+			if (trigger === undefined || trigger === null) return false
+			return typeof trigger.getAttribute === 'function' && trigger.getAttribute('aria-expanded') === 'true'
+		}
+
+		/**
+		 * Open the settings panel through the shell's own store.
+		 *
+		 * The `sidebar.settings` seat is a single-occupant slot, and the shell's registration carries
+		 * the store that owns the panel: `create().actions.openSection(id)` opens it on a section with
+		 * no clicking at all. Measured 2026-10-28: a seat occupied by an account row opens a popover
+		 * whose item the drive could not press, and every settings link died there — this path does
+		 * not depend on that popover at all.
+		 * @param {object} faces - the probed faces.
+		 * @param {string} section - the section label a link names (empty for a bare link).
+		 * @returns {boolean} whether the store accepted the call.
+		 */
+		function openSettingsThroughStore(faces, section) {
+			const seat = attemptValue(() => faces.slots?.entries?.(SETTINGS_TRIGGER_SLOT)?.[0]?.store)
+			if (seat === undefined || seat === null || typeof seat.create !== 'function') return false
+			const actions = attemptValue(() => seat.create()?.actions)
+			if (actions === undefined || actions === null) return false
+			const wanted = typeof section === 'string' ? section.trim() : ''
+			if (wanted === '') {
+				if (typeof actions.open !== 'function') return false
+				return attemptValue(() => { actions.open(); return true }) === true
+			}
+			const id = settingsSectionIdOf(faces, wanted)
+			if (id === undefined) return false
+			if (typeof actions.openSection !== 'function') return false
+			return attemptValue(() => { actions.openSection(id); return true }) === true
+		}
+
+		/**
+		 * The id of the section a link names, read from the slot the shell renders its nav from.
+		 *
+		 * A link names a section by the label the reader sees (that is the only identity the DOM
+		 * carries), while the store wants the registration id — this is the one place that maps one
+		 * to the other, and it is the same list the shell itself maps over.
+		 * @param {object} faces - the probed faces.
+		 * @param {string} label - the section label.
+		 * @returns {string|undefined} the section id.
+		 */
+		function settingsSectionIdOf(faces, label) {
+			const rows = attemptValue(() => faces.slots?.entries?.(SETTINGS_SECTION_SLOT))
+			if (!Array.isArray(rows)) return undefined
+			const wanted = label.trim().toLowerCase()
+			for (const row of rows) {
+				const id = row === null || typeof row !== 'object' ? undefined : row.options?.id
+				if (typeof id !== 'string' || id === '') continue
+				let text = row.options?.label
+				if (typeof text === 'function') text = attemptValue(() => text())
+				if (typeof text !== 'string') continue
+				if (text.trim().toLowerCase() === wanted) return id
+			}
+			return undefined
+		}
+
+		/**
+		 * The labelled settings entry, for a composition whose seat carries no launcher at all.
+		 * @param {object} document - the document.
+		 * @returns {object|undefined} the entry.
+		 */
+		function labelledSettingsEntryOf(document) {
+			const buttons = attemptValue(() => [...(document?.querySelectorAll?.('button') ?? [])])
+			if (!Array.isArray(buttons)) return undefined
+			return buttons.find(candidate => /^(settings|设置)$/i.test(String(candidate?.textContent ?? '').trim()))
+		}
+
+		/**
+		 * Press an element the way a pointer does.
+		 *
+		 * A popover trigger commonly opens on `pointerdown`/`mousedown`, so a bare `element.click()`
+		 * is a no-op on it (measured: the settings seat's account row opens its menu only for a real
+		 * pointer press — the menu was never opened by the drive, so the link never landed). The
+		 * sequence is dispatched at the element's centre, and a missing constructor is skipped so a
+		 * minimal DOM still works.
+		 * @param {object} element - the element to press.
+		 * @returns {boolean} whether anything was dispatched.
+		 */
+		function pressElement(element) {
+			if (element === null || element === undefined) return false
+			const box = attemptValue(() => element.getBoundingClientRect?.()) ?? { left: 0, top: 0, width: 0, height: 0 }
+			const options = {
+				bubbles: true,
+				cancelable: true,
+				view: window,
+				clientX: (box.left ?? 0) + (box.width ?? 0) / 2,
+				clientY: (box.top ?? 0) + (box.height ?? 0) / 2,
+			}
+			for (const type of ['pointerdown', 'mousedown', 'pointerup', 'mouseup']) {
+				const Constructor = type.startsWith('pointer') ? window.PointerEvent : window.MouseEvent
+				if (typeof Constructor !== 'function') continue
+				attemptValue(() => element.dispatchEvent?.(new Constructor(type, options)))
+			}
+			if (typeof element.click === 'function') attemptValue(() => element.click())
+			return true
+		}
+
+		/**
+		 * The settings launcher: the dialog trigger when the shell seats one, the seat's own button
+		 * otherwise.
+		 *
+		 * A dialog trigger opens the overlay in one press; a menu trigger (the account row some
+		 * shells seat there) needs its menu followed, which the caller does on the next step.
+		 * @param {object} document - the document.
+		 * @returns {object|undefined} the element a reader clicks to reach the settings surface.
+		 */
+		function settingsLauncherOf(document) {
+			const slot = attemptValue(() => document?.querySelector?.(`[data-slot="${SETTINGS_TRIGGER_SLOT}"]`))
+			const dialog = attemptValue(() => slot?.querySelector?.('button[aria-haspopup="dialog"]'))
+			if (dialog !== null && dialog !== undefined) return dialog
+			const own = attemptValue(() => slot?.querySelector?.('button'))
+			if (own !== null && own !== undefined) return own
+			return undefined
+		}
+
+		/**
+		 * The power button, by contract attribute first and by the plugin's class name after it.
+		 * @param {object} document - the document.
+		 * @returns {object|undefined} the element a reader clicks to open the menu.
+		 */
+		function powerTriggerOf(document) {
+			const marked = attemptValue(() => document?.querySelector?.(`[${POWER_TRIGGER_ATTRIBUTE}]`))
+			if (marked !== null && marked !== undefined) return marked
+			const found = attemptValue(() => document?.getElementsByClassName?.(POWER_TRIGGER_CLASS)?.[0])
+			return found === undefined ? undefined : found
+		}
+
 		/**
 		 * The fragment a reader can read: percent escapes decoded, or the raw text when the
 		 * escapes are malformed. Display only — the router still writes the encoded form.
@@ -2487,6 +4111,34 @@ window.__ModuleLoader__.load({
 		 */
 		function landedFragment(wanted, now) {
 			if (String(wanted) === String(now)) return true
+			// A power action is a command, not a place: nothing on screen can ever equal it, so
+			// waiting for a match would make the bar cry "打不开" over the one or two seconds the
+			// application takes to go away. Sending it *is* landing it.
+			const wantedRoute = parseRoute(String(wanted))
+			if (wantedRoute?.kind === 'power' && powerActionOf(wantedRoute.id) !== undefined) return true
+			// The reader hands over what they read — a settings section is raw Chinese — while the
+			// canonical form is percent-encoded, so one route has two spellings. Comparing the raw
+			// strings called a link that had already landed "打不开": the overlay was open on that
+			// very section while the bar said it could not open it (measured 2026-10-28).
+			if (readableFragment(wanted) === readableFragment(now)) return true
+			const nowRoute = parseRoute(String(now))
+			if (wantedRoute === undefined || nowRoute === undefined) return false
+			if (wantedRoute.unknown !== undefined || nowRoute.unknown !== undefined) return false
+			// A section is a refinement of the overlay: a bare settings link is satisfied by any
+			// section, and a named one by that same section.
+			if (wantedRoute.kind === 'settings' && nowRoute.kind === 'settings') {
+				const section = wantedRoute.id ?? ''
+				if (section !== '' && section !== (nowRoute.id ?? '')) return false
+				const wantedLevels = settingsPartsOf(wantedRoute.inner).levels
+				const shownLevels = settingsPartsOf(nowRoute.inner).levels
+				return wantedLevels.length <= shownLevels.length && wantedLevels.every((level, index) => level === shownLevels[index])
+			}
+			// A panel link may be wider than the page on screen (`plugins/<pkg>` for an open row).
+			if (wantedRoute.kind === 'panel' && nowRoute.kind === 'panel' && wantedRoute.id === nowRoute.id) {
+				const wantedPage = innerPath(wantedRoute.inner)
+				const shownPage = innerPath(nowRoute.inner)
+				if (wantedPage.length <= shownPage.length && wantedPage.every((part, index) => shownPage[index] === part)) return true
+			}
 			const target = targetSessionOf(wanted)
 			return target !== undefined && target === targetSessionOf(now)
 		}
@@ -2541,10 +4193,11 @@ window.__ModuleLoader__.load({
 		 * @returns {object|undefined} the trigger element, or undefined when absent.
 		 */
 		function powerTrigger() {
-			if (typeof document?.querySelector !== 'function') return undefined
-			return document.querySelector('[data-dshpm-mount] .dshpm-trigger')
-				?? document.querySelector('.dshpm-trigger')
-				?? document.querySelector('[aria-label="电源菜单"]')
+			const page = attemptValue(() => window.document)
+			if (typeof page?.querySelector !== 'function') return undefined
+			return page.querySelector('[data-dshpm-mount] .dshpm-trigger')
+				?? page.querySelector('.dshpm-trigger')
+				?? page.querySelector('[aria-label="电源菜单"]')
 				?? undefined
 		}
 
@@ -2594,7 +4247,7 @@ window.__ModuleLoader__.load({
 			try {
 				style = document.createElement('style')
 				style.id = TITLEBAR_STYLE_ID
-				style.textContent = macInHeader ? `${TITLEBAR_STYLE_TEXT}\n${MAC_STYLE_TEXT}` : TITLEBAR_STYLE_TEXT
+				style.textContent = `${macInHeader ? `${TITLEBAR_STYLE_TEXT}\n${MAC_STYLE_TEXT}` : TITLEBAR_STYLE_TEXT}\n${RECENT_STYLE_TEXT}`
 				const parent = document.head ?? document.body
 				if (parent !== undefined && parent !== null && typeof parent.appendChild === 'function') parent.appendChild(style)
 			} catch {
@@ -2612,6 +4265,16 @@ window.__ModuleLoader__.load({
 			input.placeholder = TITLEBAR_PLACEHOLDER
 			if (typeof input.setAttribute === 'function') input.setAttribute('aria-label', '地址栏 / address bar')
 			bar.appendChild(input)
+			// The recent list: the drop-down a browser shows when its address bar is focused.
+			// It is a child of the bar so it moves with it and can never end up somewhere
+			// else on a screen where the bar is repositioned.
+			const recentList = document.createElement('div')
+			if (typeof recentList.setAttribute === 'function') {
+				recentList.setAttribute(RECENT_LIST_ATTRIBUTE, '')
+				recentList.setAttribute('role', 'listbox')
+				recentList.setAttribute('aria-label', '最近使用的链接 / recent links')
+			}
+			bar.appendChild(recentList)
 		/**
 		 * The free stretch the bar was last fitted into.
 		 *
@@ -2672,6 +4335,8 @@ window.__ModuleLoader__.load({
 		 * macOS: sit in the free stretch of the header row, on the power button's
 		 * own line.
 		 */
+		/** The shape the last placement was measured from, so an unchanged header is not re-walked. */
+		let lastShape
 		const place = () => {
 			if (macInHeader) {
 				// The bar lives on the header row, on the same line as the power
@@ -2684,6 +4349,20 @@ window.__ModuleLoader__.load({
 				const row = macHeaderRow(trigger)
 				const rowRect = row?.getBoundingClientRect?.()
 				const anchored = rect !== undefined && rect !== null && rect.width > 0
+				// The observer fires for every mutation on the page, and a streaming answer produces
+				// them constantly: walking the row again when nothing that shaped the last placement
+				// moved is pure waste (the walk reads a box per leaf, i.e. forces layout). A screen
+				// with no row to measure is not cached this way — its band is the page's own content,
+				// which changes without moving the row.
+				const shape = [
+					rowRect?.top, rowRect?.left, rowRect?.width, rowRect?.height,
+					rect?.top, rect?.left, rect?.width,
+					Math.round(globalThis.innerWidth ?? 0),
+					(row?.textContent ?? '').length,
+				].join('|')
+				if (anchored && shape === lastShape && bar.style.display !== 'none') return
+				if (anchored) lastShape = shape
+				workCounts.placements += 1
 				// The row is only walked when there is a button to measure from.
 				const gap = anchored ? macFreeGap(macLeaves(row, 0), rect, rowRect) : null
 				if (gap === null) {
@@ -2703,11 +4382,30 @@ window.__ModuleLoader__.load({
 						bar.style.display = 'none'
 						return
 					}
-					const box = fitBar(lastPlacement.gap, lastPlacement.top)
-					const left = Math.max(MAC_BAR_GAP, Math.min(box.left, viewport - box.width - MAC_BAR_GAP))
+					const remembered = fitBar(lastPlacement.gap, lastPlacement.top)
+					// Yield to whatever this screen draws on that line: the bar moves into a free run
+					// of its own instead of being drawn across a control (measured: it sat straight
+					// across the automation task's detail tabs).
+					const runs = []
+					let cursor = 0
+					for (const span of bandSpans(document, bar, remembered.top, MAC_BAR_HEIGHT)) {
+						if (span.left > cursor) runs.push({ left: cursor, right: span.left })
+						cursor = Math.max(cursor, span.right)
+					}
+					if (viewport > cursor) runs.push({ left: cursor, right: viewport })
+					let best = null
+					for (const run of runs) {
+						if (run.right - run.left < MAC_BAR_MIN_WIDTH) continue
+						if (best === null || run.right - run.left > best.right - best.left) best = run
+					}
+					if (best === null) {
+						bar.style.display = 'none'
+						return
+					}
+					const box = fitBar(best, remembered.top)
 					bar.style.display = ''
 					bar.style.top = `${box.top}px`
-					bar.style.left = `${left}px`
+					bar.style.left = `${box.left}px`
 					bar.style.right = 'auto'
 					bar.style.width = `${box.width}px`
 					return
@@ -2744,7 +4442,7 @@ window.__ModuleLoader__.load({
 		let placeFrame
 		const schedulePlace = () => {
 			if (placeFrame !== undefined) return
-			placeFrame = attemptValue(() => globalThis.requestAnimationFrame?.(() => {
+			placeFrame = attemptValue(() => window.requestAnimationFrame?.(() => {
 				placeFrame = undefined
 				place()
 			}))
@@ -2769,6 +4467,11 @@ window.__ModuleLoader__.load({
 			show(window.location?.hash)
 			/** Whether the view has arrived where the link asked, judged by what is on screen. */
 			const arrived = wanted => {
+				// A command is not a place: nothing on screen can ever match it, so it counts as
+				// arrived the moment it is sent — otherwise the bar would cry "打不开" over the
+				// second or two the application takes to go away (measured 2026-10-29).
+				const typed = parseRoute(String(wanted))
+				if (typed?.kind === 'power' && powerActionOf(typed.id) !== undefined) return true
 				const report = attemptValue(() => window.__dshUrlRouter?.report?.())
 				const canonical = report?.canonical
 				if (canonical === undefined || canonical === null) return false
@@ -2810,14 +4513,294 @@ window.__ModuleLoader__.load({
 					input.value = why
 				}, TITLEBAR_SETTLE_MS))
 			}
+			/**
+			 * The chip a remembered link is shown with: what kind of screen it names.
+			 * @param {object|undefined} route - the decoded route.
+			 * @returns {string} the chip's text.
+			 */
+			const recentKind = route => {
+				if (route === undefined || route.unknown !== undefined) return '链接'
+				if (route.kind === 'session') return '会话'
+				if (route.kind === 'workspace') return '工作区'
+				if (route.kind === 'panel') return '面板'
+				if (route.kind === 'settings') return '设置'
+				return '链接'
+			}
+			/** Hide the remembered links. */
+			const hideRecent = () => {
+				if (typeof recentList.removeAttribute === 'function') recentList.removeAttribute('data-open')
+			}
+			/**
+			 * Whether the reader has edited the text since the bar was focused.
+			 *
+			 * The list is narrowed only by text the reader typed. The field always holds the
+			 * current link when it is merely focused, and filtering by that would hide every
+			 * remembered screen but the one on display.
+			 */
+			let narrowed = false
+			/** Empty the list before it is drawn again. */
+			const emptyRecent = () => {
+				while (recentList.firstChild !== null && recentList.firstChild !== undefined) {
+					if (typeof recentList.removeChild !== 'function') break
+					recentList.removeChild(recentList.firstChild)
+				}
+			}
+			/**
+			 * The absolute URL a remembered link stands for.
+			 *
+			 * A copied link has to survive the trip out of this window, so it carries the path
+			 * and the launch query (`?token=…`) exactly the way a row anchor's own "copy link
+			 * address" does — the bare fragment only works inside an already-open page.
+			 * @param {string} hash - the fragment.
+			 * @returns {string} the URL to copy.
+			 */
+			const absoluteLink = hash => {
+				const location = window.location ?? {}
+				return `${location.origin ?? ''}${location.pathname ?? ''}${location.search ?? ''}${hash}`
+			}
+			/** Set while the copy's throw-away field borrows focus, so the bar ignores the swap. */
+			let quietFocus = false
+			/**
+			 * Run something without the bar reading it as the reader leaving or entering the
+			 * field: the copy must neither close the list nor re-select the link.
+			 * @param {Function} run - what to run.
+			 * @returns {*} whatever it returned.
+			 */
+			const quietly = run => {
+				quietFocus = true
+				try {
+					return run()
+				} finally {
+					quietFocus = false
+				}
+			}
+			/**
+			 * Put text on the clipboard the old way: select it in a throw-away field and let the
+			 * command copy it. Used when the window has no clipboard service, or refuses the
+			 * async call — and the reader is put back in the field afterwards, because the field
+			 * was only there to be copied from.
+			 * @param {string} text - what to copy.
+			 * @returns {boolean} whether the copy was accepted.
+			 */
+			const copyBySelection = text => quietly(() => attemptValue(() => {
+				const wasFocused = attemptValue(() => document.activeElement)
+				const area = document.createElement('textarea')
+				area.value = text
+				area.setAttribute?.('readonly', '')
+				if (area.style !== undefined) {
+					area.style.position = 'fixed'
+					area.style.top = '-1000px'
+				}
+				document.body?.appendChild?.(area)
+				area.focus?.()
+				area.select?.()
+				const done = typeof document.execCommand === 'function' && document.execCommand('copy') === true
+				area.remove?.()
+				if (wasFocused === input) attemptValue(() => input.focus?.())
+				return done
+			}, false) ?? false)
+			/**
+			 * Copy a remembered link.
+			 * @param {string} hash - the fragment to copy.
+			 * @returns {Promise<boolean>|boolean} whether the copy was accepted.
+			 */
+			const copyLink = hash => {
+				const text = absoluteLink(hash)
+				const clipboard = attemptValue(() => globalThis.navigator?.clipboard)
+				if (clipboard !== undefined && clipboard !== null && typeof clipboard.writeText === 'function') {
+					let pending
+					try {
+						pending = Promise.resolve(clipboard.writeText(text))
+					} catch {
+						return copyBySelection(text)
+					}
+					// A window that refuses the async call still has the old path. (The fallback
+					// is a function call inside the handler on purpose: evaluating it up front
+					// would run — and focus a throw-away field — on every single copy.)
+					return pending.then(() => true, () => copyBySelection(text))
+				}
+				return copyBySelection(text)
+			}
+			/** Timers that put a "copied" row back, so disposal can clear them. */
+			const copiedTimers = new Set()
+			/** The bar's own confirmation chip: it stays visible even if the list had to close. */
+			const toast = document.createElement('span')
+			toast.className = 'dshur-toast'
+			if (typeof toast.setAttribute === 'function') {
+				toast.setAttribute(TOAST_ATTRIBUTE, '')
+				toast.setAttribute('aria-live', 'polite')
+			}
+			bar.appendChild(toast)
+			let toastTimer
+			/**
+			 * Show one short confirmation in the bar.
+			 * @param {string} text - what to say.
+			 */
+			const flashToast = text => {
+				toast.textContent = text
+				toast.setAttribute?.('data-show', '')
+				if (toastTimer !== undefined) attemptValue(() => window.clearTimeout(toastTimer))
+				toastTimer = attemptValue(() => window.setTimeout(() => {
+					toastTimer = undefined
+					toast.removeAttribute?.('data-show')
+					toast.textContent = ''
+				}, 1200))
+			}
+			/**
+			 * Say so on the row that was copied, then put the link back.
+			 * @param {object} item - the remembered-link row.
+			 * @param {object} link - that row's link text.
+			 */
+			const flashCopied = (item, link) => {
+				const text = readableFragment(attemptValue(() => item.getAttribute(RECENT_ITEM_ATTRIBUTE)) ?? '')
+				link.textContent = '已复制 ✓'
+				item.setAttribute?.('data-copied', '')
+				const timer = attemptValue(() => window.setTimeout(() => {
+					copiedTimers.delete(timer)
+					// A redraw may have replaced the row already; only a live one is restored.
+					link.textContent = text
+					item.removeAttribute?.('data-copied')
+				}, 1200))
+				if (timer !== undefined) copiedTimers.add(timer)
+			}
+			/**
+			 * Draw the remembered links: the screens this bar named and the links pasted into
+			 * it, newest first, narrowed by whatever is typed. Nothing to show means no list.
+			 */
+			const drawRecent = () => {
+				const typed = narrowed ? String(input.value ?? '').trim().toLowerCase() : ''
+				// One scan of the sidebar for the whole list: asking per entry re-walked every row
+				// once per item (and twice per item, since the filter asks too).
+				const titles = sessionTitles()
+				// `recentEntries()` already leaves out the screen on display, so a remembered
+				// link is only narrowed here by what the reader typed.
+				const shown = recentEntries().filter(entry => {
+					if (typed === '') return true
+					return `${entry.hash}\n${recentLabel(entry.hash, titles)}`.toLowerCase().includes(typed)
+				})
+				emptyRecent()
+				for (const entry of shown) {
+					const label = recentLabel(entry.hash, titles)
+					const item = document.createElement('button')
+					item.type = 'button'
+					if (typeof item.setAttribute === 'function') {
+						item.setAttribute(RECENT_ITEM_ATTRIBUTE, entry.hash)
+						item.setAttribute('role', 'option')
+						item.setAttribute('title', `${entry.source === 'paste' ? '粘贴的链接' : '用过的界面'}：${readableFragment(entry.hash)}（右键复制链接）`)
+					}
+					const kind = document.createElement('span')
+					kind.className = 'dshur-kind'
+					kind.textContent = recentKind(parseRoute(entry.hash))
+					item.appendChild(kind)
+					if (label !== '') {
+						const title = document.createElement('span')
+						title.className = 'dshur-title'
+						title.textContent = label
+						item.appendChild(title)
+					}
+					const link = document.createElement('span')
+					link.className = 'dshur-link'
+					link.textContent = readableFragment(entry.hash)
+					item.appendChild(link)
+					item.addEventListener('mousedown', event => {
+						// The click belongs to this list: the input has to keep focus, or the
+						// press would blur it first and the list would be gone before the click.
+						attemptValue(() => event?.preventDefault?.())
+					})
+					item.addEventListener('click', () => {
+						narrowed = false
+						hideRecent()
+						mark('pending', undefined)
+						// The box says where it is going at once; the settle below corrects it to
+						// what actually landed (or says why nothing did).
+						input.value = readableFragment(entry.hash)
+						driveTypedFragment(entry.hash)
+						settle(entry.hash, false)
+					})
+					item.addEventListener('contextmenu', event => {
+						// Right-click copies instead of opening a menu: this list is the one place
+						// where "give me this link" is the action a reader wants, and the browser's
+						// own menu would only offer the same thing one level deeper.
+						attemptValue(() => event?.preventDefault?.())
+						const confirm = accepted => {
+							if (accepted !== true) return
+							flashCopied(item, link)
+							flashToast('已复制链接')
+						}
+						const copied = copyLink(entry.hash)
+						if (typeof copied?.then === 'function') copied.then(confirm)
+						else confirm(copied)
+					})
+					recentList.appendChild(item)
+				}
+				if (shown.length === 0) {
+					hideRecent()
+					return
+				}
+				if (typeof recentList.setAttribute === 'function') recentList.setAttribute('data-open', '')
+			}
+			/**
+			 * Select everything in the bar, the way a browser's address bar does on its first
+			 * click. Off means the reader keeps the caret an ordinary text field gives them.
+			 * @returns {boolean} whether the text was selected.
+			 */
+			const selectAll = () => {
+				if (!readSettings().selectAllOnFocus) return false
+				return attemptValue(() => {
+					if (typeof input.select !== 'function') return false
+					input.select()
+					return true
+				}, false)
+			}
+			const onFocus = () => {
+				// The copy's own field came and went: this is not the reader focusing the bar.
+				if (quietFocus) return
+				narrowed = false
+				revealBar()
+				selectAll()
+				drawRecent()
+			}
+			const onMouseDown = event => {
+				// Already focused: this press is placing a caret inside the link.
+				if (document.activeElement === input) return
+				if (!readSettings().selectAllOnFocus) return
+				narrowed = false
+				// The default of this very press would drop the selection made below.
+				attemptValue(() => event?.preventDefault?.())
+				attemptValue(() => input.focus?.())
+				selectAll()
+				drawRecent()
+			}
+			const onPaste = event => {
+				const pasted = attemptValue(() => event?.clipboardData?.getData?.('text'))
+				const fragment = attemptValue(() => titlebarFragmentOf(pasted))
+				// Remembered as soon as it is a link this bar can open: a link that is already
+				// on screen writes no route later, and would otherwise be forgotten entirely.
+				if (typeof fragment === 'string' && fragment !== '') rememberRecent(fragment, 'paste')
+			}
+			const onInput = () => {
+				narrowed = true
+				drawRecent()
+			}
+			const onBlur = () => {
+				if (quietFocus) return
+				narrowed = false
+				hideRecent()
+				// The pointer may still be on the bar; concealBar() checks that and the list.
+				attemptValue(() => window.setTimeout?.(concealBar, 0))
+			}
 			const onKeyDown = event => {
 				if (event?.key === 'Escape') {
 					stopSettle()
+					narrowed = false
+					hideRecent()
 					mark('idle', undefined)
 					input.value = readableFragment(window.location?.hash)
 					return
 				}
 				if (event?.key !== 'Enter') return
+				narrowed = false
+				hideRecent()
 				const fragment = titlebarFragmentOf(input.value)
 				if (fragment === undefined) {
 					// Nothing here names a route: leave the address bar saying what is on screen.
@@ -2833,7 +4816,47 @@ window.__ModuleLoader__.load({
 				driveTypedFragment(fragment)
 				settle(fragment, false)
 			}
+			/** Whether the bar is asked to stay out of sight until the pointer is on it. */
+			const hoverMode = () => readSettings().hoverReveal === true
+			/** Whether the drop-down is up (a reveal must outlive the pointer leaving). */
+			const recentIsOpen = () => attemptValue(() => recentList.getAttribute?.('data-open') !== null, false)
+			/** Whether the reader is typing in the bar. */
+			const inputIsFocused = () => attemptValue(() => window.document?.activeElement === input, false)
+			/** Show the bar; only meaningful in hover mode (the stylesheet does the rest). */
+			const revealBar = () => {
+				if (!hoverMode()) return
+				attemptValue(() => bar.setAttribute?.(SHOWN_ATTRIBUTE, ''))
+			}
+			/** Hide it again — unless a focused field or an open list still needs it visible. */
+			const concealBar = () => {
+				if (!hoverMode()) return
+				if (inputIsFocused() || recentIsOpen()) return
+				attemptValue(() => bar.removeAttribute?.(SHOWN_ATTRIBUTE))
+			}
+			/**
+			 * Put the bar into the state the preference asks for. Called once at mount, again
+			 * whenever the preference changes, and never while a route is being written (the
+			 * bar's contents are independent of whether it is visible).
+			 */
+			const applyHoverMode = () => {
+				attemptValue(() => {
+					if (hoverMode()) bar.setAttribute?.(HOVER_ATTRIBUTE, '')
+					else {
+						bar.removeAttribute?.(HOVER_ATTRIBUTE)
+						bar.removeAttribute?.(SHOWN_ATTRIBUTE)
+					}
+				})
+			}
+			bar.addEventListener?.('mouseenter', revealBar)
+			bar.addEventListener?.('mouseleave', concealBar)
 			input.addEventListener('keydown', onKeyDown)
+			input.addEventListener('focus', onFocus)
+			input.addEventListener('mousedown', onMouseDown)
+			input.addEventListener('input', onInput)
+			input.addEventListener('paste', onPaste)
+			input.addEventListener('blur', onBlur)
+			applyHoverMode()
+			const offHoverSettings = subscribeSettings(() => applyHoverMode())
 			// Both platforms mount the bar in the body: Windows pins it into the
 			// title-bar strip, macOS pins it over the resident header row.
 			document.body.appendChild(bar)
@@ -2847,9 +4870,12 @@ window.__ModuleLoader__.load({
 			 * node, so what was typed into it survives.
 			 */
 			let headerWatcher
-			if (macInHeader && typeof MutationObserver === 'function') {
+			// The window owns both, so a page that replaces `document` (or a host with its own
+			// observers) still gets the watcher; a global-only read silently found nothing.
+			const Observer = attemptValue(() => window.MutationObserver)
+			if (macInHeader && typeof Observer === 'function') {
 				try {
-					headerWatcher = new MutationObserver(() => schedulePlace())
+					headerWatcher = new Observer(() => schedulePlace())
 					headerWatcher.observe(document.body, { childList: true, subtree: true })
 				} catch {
 					headerWatcher = undefined
@@ -2866,7 +4892,19 @@ window.__ModuleLoader__.load({
 			return () => {
 				offRoute?.()
 				stopSettle()
+				if (placeFrame !== undefined) attemptValue(() => window.cancelAnimationFrame?.(placeFrame))
 				input.removeEventListener?.('keydown', onKeyDown)
+				input.removeEventListener?.('focus', onFocus)
+				input.removeEventListener?.('mousedown', onMouseDown)
+				input.removeEventListener?.('input', onInput)
+				input.removeEventListener?.('paste', onPaste)
+				input.removeEventListener?.('blur', onBlur)
+				bar.removeEventListener?.('mouseenter', revealBar)
+				bar.removeEventListener?.('mouseleave', concealBar)
+				offHoverSettings?.()
+				for (const timer of copiedTimers) attemptValue(() => window.clearTimeout(timer))
+				copiedTimers.clear()
+				if (toastTimer !== undefined) attemptValue(() => window.clearTimeout(toastTimer))
 				if (onResize !== undefined) window.removeEventListener?.('resize', onResize)
 				headerWatcher?.disconnect?.()
 				bar.remove?.()
@@ -2874,6 +4912,173 @@ window.__ModuleLoader__.load({
 			}
 		}
 
+		// ---------------------------------------------------------------------
+		// settings page: the plugin manager's row page is this plugin's settings surface
+		//
+		// The manager dispatches a row's configuration under `<package name>#<row id>` and
+		// renders the entry twice: once as the row's one-line summary and once as the page
+		// the row's configure control opens. Registering here is what turns
+		// `#/panel/plugins/dsh-url-router/dsh-url-router` from a read-only overview into the
+		// page these two preferences are set on — the same shape every other plugin in this
+		// profile has, instead of a settings tab of its own.
+		// ---------------------------------------------------------------------
+		/** The card's stylesheet id, so a re-apply replaces its own rather than stacking copies. */
+		const SETTINGS_STYLE_ID = 'dsh-url-router-settings-style'
+		/** The card's own styles: the manager's class names are hashed, so it cannot borrow them. */
+		const SETTINGS_STYLE_TEXT = [
+			'.dshur{display:flex;flex-direction:column;gap:8px;color:var(--dsw-alias-label-primary,inherit);font-size:13px;line-height:20px}',
+			'.dshur-block{display:flex;flex-direction:column;gap:4px;padding:10px 12px;border:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.26));border-radius:10px}',
+			'.dshur-row{display:flex;align-items:center;gap:10px;justify-content:space-between}',
+			'.dshur-label{display:flex;align-items:center;gap:8px;font-weight:500;cursor:pointer}',
+			'.dshur-check{width:16px;height:16px;margin:0;accent-color:var(--dsw-alias-brand-primary,#4d6bfe)}',
+			'.dshur-number{width:96px;height:28px;box-sizing:border-box;padding:0 8px;border:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.34));border-radius:8px;background:transparent;color:inherit;font:inherit;text-align:right}',
+			'.dshur-number:focus{outline:none;border-color:var(--dsw-alias-brand-primary,#4d6bfe)}',
+			'.dshur-state{color:var(--dsw-alias-label-secondary,#4b5872);font-size:12px}',
+			'.dshur-hint{margin:0;color:var(--dsw-alias-label-tertiary,#81858c);font-size:12px;line-height:18px}',
+			'.dshur-meta{display:flex;align-items:center;gap:10px;color:var(--dsw-alias-label-secondary,#4b5872);font-size:12px}',
+			'.dshur-clear{height:26px;padding:0 10px;border:1px solid var(--dsw-alias-border-l2,rgba(127,127,127,.34));border-radius:7px;background:transparent;color:inherit;font:inherit;font-size:12px;cursor:pointer}',
+			'.dshur-clear:hover{background:var(--dsw-alias-interactive-bg-hover,rgba(127,127,127,.14))}',
+		].join('')
+
+		/**
+		 * The settings card on this plugin's row page.
+		 *
+		 * The manager calls it twice: with `view: 'summary'` for the row's one-liner (it must
+		 * stay cheap — it renders on every row paint and must not touch the disk) and with the
+		 * page's own view for the settings themselves.
+		 * @param {object} props - slot props, `view` names which of the two is wanted.
+		 * @returns {object|string} the element to draw, or the one-liner.
+		 */
+		function RouterSettingsCard({ view }) {
+			const h = react.createElement
+			const [settings, setSettings] = react.useState(readSettings())
+			const [draft, setDraft] = react.useState(String(readSettings().recentLimit))
+			const [remembered, setRemembered] = react.useState(() => recentEntries().length)
+			react.useEffect(() => subscribeSettings(next => {
+				setSettings(next)
+				setDraft(String(next.recentLimit))
+				setRemembered(recentEntries().length)
+			}), [])
+			if (view === 'summary') {
+				return `全选 ${settings.selectAllOnFocus ? '开' : '关'} · 悬浮显示 ${settings.hoverReveal ? '开' : '关'} · 记忆 ${settings.recentLimit} 条`
+			}
+			/**
+			 * Take a typed count: an empty field, a minus sign or anything else unusable is a
+			 * half-typed value and must not be committed as 0.
+			 * @param {string} text - what the field holds.
+			 */
+			const commitCount = text => {
+				setDraft(text)
+				const number = Number(text)
+				if (String(text).trim() === '' || !Number.isFinite(number) || number < 0) return
+				setSettings(updateSettings({ recentLimit: Math.floor(number) }))
+			}
+			return h('div', { className: 'dshur' }, [
+				h('div', { className: 'dshur-block', key: 'select' }, [
+					h('div', { className: 'dshur-row' }, [
+						h('label', { className: 'dshur-label' }, [
+							h('input', {
+								type: 'checkbox',
+								className: 'dshur-check',
+								checked: settings.selectAllOnFocus,
+								onChange: event => setSettings(updateSettings({ selectAllOnFocus: event?.target?.checked === true })),
+							}),
+							h('span', null, '首次点击全选链接'),
+						]),
+						h('span', { className: 'dshur-state' }, settings.selectAllOnFocus ? '开' : '关'),
+					]),
+					h('p', { className: 'dshur-hint' }, '第一次点进去整条选中，直接输入就替换；已在框内再点，才放光标。'),
+				]),
+				h('div', { className: 'dshur-block', key: 'hover' }, [
+					h('div', { className: 'dshur-row' }, [
+						h('label', { className: 'dshur-label' }, [
+							h('input', {
+								type: 'checkbox',
+								className: 'dshur-check',
+								checked: settings.hoverReveal,
+								onChange: event => setSettings(updateSettings({ hoverReveal: event?.target?.checked === true })),
+							}),
+							h('span', null, '悬浮时才显示地址栏'),
+						]),
+						h('span', { className: 'dshur-state' }, settings.hoverReveal ? '开' : '关'),
+					]),
+					h('p', { className: 'dshur-hint' }, '平时隐去，鼠标移到地址栏的位置才出现。'),
+				]),
+				h('div', { className: 'dshur-block', key: 'recent' }, [
+					h('div', { className: 'dshur-row' }, [
+						h('label', { className: 'dshur-label', htmlFor: 'dshur-recent-limit' }, '记住最近链接的条数'),
+						h('input', {
+							id: 'dshur-recent-limit',
+							type: 'number',
+							min: 0,
+							step: 1,
+							inputMode: 'numeric',
+							className: 'dshur-number',
+							value: draft,
+							onChange: event => commitCount(event?.target?.value ?? ''),
+							onBlur: () => setDraft(String(readSettings().recentLimit)),
+						}),
+					]),
+					h('p', { className: 'dshur-hint' }, '下拉框里能看到的条数，默认 8；0 = 不记忆、不弹列表；没有上限。当前界面不占名额。'),
+					h('p', { className: 'dshur-meta' }, [
+						h('span', { key: 'count' }, `已记住 ${remembered} 条`),
+						h('button', {
+							type: 'button',
+							className: 'dshur-clear',
+							key: 'clear',
+							onClick: () => {
+								clearRecent()
+								setRemembered(0)
+							},
+						}, '清空记录'),
+					]),
+				]),
+			])
+		}
+
+		/**
+		 * Register the settings card with the plugin manager.
+		 *
+		 * A composition without the manager, without the slot service, or without React has
+		 * no card and needs none: nothing else in the plugin depends on this.
+		 * @param {object} ctx - client context.
+		 * @returns {() => void} the disposer.
+		 */
+		function startSettingsCard(ctx) {
+			if (react === undefined || typeof window === 'undefined' || window.document === undefined) return () => {}
+			const slots = ctx?.slots
+			if (typeof slots?.inject !== 'function' || typeof slots?.register !== 'function') return () => {}
+			const document = window.document
+			let style
+			try {
+				style = document.createElement('style')
+				style.id = SETTINGS_STYLE_ID
+				style.textContent = SETTINGS_STYLE_TEXT
+				const parent = document.head ?? document.body
+				if (typeof parent?.appendChild === 'function') parent.appendChild(style)
+			} catch {
+				style = undefined
+			}
+			let off
+			try {
+				off = slots.inject('plugins.row.config', () => slots.register({
+					name: 'plugins.row.config',
+					key: ROW_CONFIG_KEY,
+				}, RouterSettingsCard))
+			} catch {
+				// A page that never declares the slot is a page without a card, not a failure.
+				off = undefined
+			}
+			return () => {
+				try {
+					if (typeof off === 'function') off()
+				} catch {
+					// A slot service that is already gone needs no undo.
+				}
+				style?.remove?.()
+			}
+		}
+
 		function apply(ctx) {
 			// Fragment routing: the address bar names the view, and a link opens it.
 			ctx.effect(() => {
@@ -2928,6 +5133,10 @@ window.__ModuleLoader__.load({
 				if (typeof window === 'undefined' || window.document === undefined) return () => {}
 				return startTitlebarAddress(window.document, subscribeRoute)
 			}, 'url-router: desktop address bar')
+			// Settings page: the plugin manager's row page carries the two preferences, so
+			// there is no separate settings tab to find them in.
+			ctx.effect(() => startSettingsCard(ctx), 'url-router: settings card')
+
 		}
 
 		exports.apply = apply