dsh-url-router 0.4.0 → 0.4.2

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
@@ -126,19 +141,39 @@ window.__ModuleLoader__.load({
 		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.0'
+		const ROUTER_VERSION = '0.4.2'
 		/**
 		 * 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'
+		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.12'
 
 		const TAG = '[url-router]'
 
@@ -153,12 +188,234 @@ 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. */
-		const TITLEBAR_GAP = 8
-		/** How long the bar waits for a handed-over link to land before it says it did not. */
-		const TITLEBAR_SETTLE_MS = 900
+	/** Gap between the shell's menu and the bar. */
+	const TITLEBAR_GAP = 8
+	/**
+	 * macOS has no in-page title-bar strip, so the bar cannot borrow window chrome
+	 * the way the Windows build does. It borrows the next best thing: the shell's
+	 * resident header row, which exists on every screen. The bar stays mounted in
+	 * the body with fixed positioning — exactly the Windows approach — and `place`
+	 * measures the title cluster and the right-hand cluster to get its insets.
+	 */
+	const MAC_BAR_HEIGHT = 26
+	/** The least room the bar will draw itself into; below this it stays hidden. */
+	const MAC_BAR_MIN_WIDTH = 120
+	/** The breathing space the bar keeps from whatever stands next to it. */
+	const MAC_BAR_GAP = 8
+	/** The margin the bar leaves inside the free stretch, on each side. */
+	const MAC_BAR_INSET = 25
+	/**
+	 * The bar's own length.
+	 *
+	 * The free stretch begins wherever the conversation's title happens to end, so
+	 * without a length of its own the bar would grow and shrink as titles change.
+	 * It stops here instead, and only gets shorter when the row cannot spare this
+	 * much.
+	 */
+	const MAC_BAR_MAX_WIDTH = 1150
+	/**
+	 * How much the window may change before a remembered stretch stops counting.
+	 *
+	 * The stretch was measured against one window; a different one moves the
+	 * header's buttons, and there is nothing to re-measure from on a screen that
+	 * has no power button. A couple of pixels is rounding, more is a resize.
+	 */
+	const MAC_BAR_RESIZE_SLACK = 8
+	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)}`,
+	].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'
+	/**
+	 * Describe one element: what it is, and where it sits.
+	 * @param {object} el - the element to describe.
+	 * @returns {object|null} the description, or null when there is no element.
+	 */
+	function macDescribe(el) {
+		if (el === null || el === undefined) return null
+		const rect = el.getBoundingClientRect?.()
+		const cls = el.className?.baseVal ?? el.className ?? ''
+		return {
+			tag: String(el.tagName ?? '?').toLowerCase(),
+			cls: typeof cls === 'string' ? cls.slice(0, 70) : '',
+			rect: rect === undefined || rect === null
+				? null
+				: { top: Math.round(rect.top), left: Math.round(rect.left), width: Math.round(rect.width), height: Math.round(rect.height) },
+		}
+	}
+	/**
+	 * Every descendant of an element that carries text of its own or answers a
+	 * click — the header's real contents, so the bar can find the gap between
+	 * them instead of guessing where it is.
+	 * @param {object} el - the element to walk.
+	 * @param {number} depth - how far down to walk.
+	 * @returns {Array<object>} the leaves, with their boxes.
+	 */
+	function macLeaves(el, depth) {
+		const leaves = []
+		if (el === null || el === undefined || depth > 6) return leaves
+		for (const child of el.children ?? []) {
+			const own = ownText(child)
+			const interactive = typeof child.closest === 'function'
+				&& child.matches?.('button, a, input, [role="button"], [role="tab"], img, svg') === true
+			if (own !== '' || interactive || child.children.length === 0) {
+				leaves.push({ ...macDescribe(child), own: own.slice(0, 40) })
+			} else {
+				leaves.push(...macLeaves(child, depth + 1))
+			}
+		}
+		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.
+	 *
+	 * The shell names the row in its stylesheet, so that name is tried first; when
+	 * it has changed, the row is taken from the power button's own corner, whose
+	 * parent is the row the button was mounted on.
+	 *
+	 * @param {object} trigger - the power-menu trigger.
+	 * @returns {object|undefined} the row element, or undefined when there is none.
+	 */
+	function macHeaderRow(trigger) {
+		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
+			if (typeof named.contains !== 'function' || named.contains(trigger)) return named
+		}
+		return corner?.parentElement ?? undefined
+	}
+	/**
+	 * The free stretch of the header row the bar can live in.
+	 *
+	 * The row is measured rather than guessed: every leaf that shares the power
+	 * button's row — the title text, the mode label, the header's own buttons — is
+	 * turned into an interval, overlapping intervals are merged, and the widest
+	 * stretch between them is the one the bar goes into. Nothing is covered,
+	 * because that stretch holds nothing; nothing is pushed, because the bar is a
+	 * fixed-position layer of its own.
+	 *
+	 * @param {Array<object>} leaves - the row's measured contents.
+	 * @param {object} rect - the power button's rectangle, which ends the search.
+	 * @param {object} [bounds] - the row's own rectangle, which begins it.
+	 * @returns {{left: number, right: number}|null} the stretch, or null when the row has no room.
+	 */
+	function macFreeGap(leaves, rect, bounds) {
+		if (rect === undefined || rect === null) return null
+		const rowTop = rect.top
+		const rowBottom = rect.top + rect.height
+		// The power button is the anchor: the bar never reaches past its left edge.
+		const limit = Math.round(rect.left)
+		const occupied = []
+		for (const leaf of leaves ?? []) {
+			const box = leaf?.rect
+			if (box === undefined || box === null) continue
+			if (!(box.width > 0) || !(box.height > 0)) continue
+			// Only what stands on the power button's row can be in the way.
+			if (box.top >= rowBottom || box.top + box.height <= rowTop) continue
+			const left = Math.round(box.left)
+			const right = Math.round(box.left + box.width)
+			if (right <= 0 || left >= limit) continue
+			occupied.push({ left, right })
+		}
+		occupied.sort((a, b) => a.left - b.left)
+		// Merge what overlaps, so a box inside another cannot split a stretch.
+		const merged = []
+		for (const span of occupied) {
+			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 })
+		}
+		// The row begins at its own left edge when that is known, and at the first
+		// thing standing on it otherwise.
+		const start = bounds !== undefined && bounds !== null && bounds.left > 0
+			? Math.round(bounds.left)
+			: (merged[0]?.left ?? limit)
+		const runs = []
+		let cursor = start
+		for (const span of merged) {
+			if (span.left > cursor) runs.push({ left: cursor, right: span.left })
+			if (span.right > cursor) cursor = span.right
+		}
+		if (limit > cursor) runs.push({ left: cursor, right: limit })
+		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
+		}
+		return best
+	}
+	/** How long the bar waits for a handed-over link to land before it says it did not. */
+	const TITLEBAR_SETTLE_MS = 900
 		/** What the address bar accepts, said in its placeholder. */
 		const TITLEBAR_PLACEHOLDER = '#/session/… · #/panel/… · #/settings · 会话 id · 链接'
 		/** The strip belongs to the shell, so only the bar itself is styled. */
@@ -168,6 +425,24 @@ window.__ModuleLoader__.load({
 			`#${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)}`,
 		].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()
 		/**
@@ -175,6 +450,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)
@@ -200,6 +478,282 @@ 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, 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, 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,
+				// 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, 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 ?? '')
+			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.
@@ -284,12 +838,6 @@ window.__ModuleLoader__.load({
 			return undefined
 		}
 
-		/**
-		 * The kind inside a tab id: the bar builds one as `sidebar://<kind>` and appends a uuid for
-		 * kinds that may be opened more than once, so the kind is right there in the address.
-		 * @param {string} value - a tab id.
-		 * @returns {string|undefined} the kind, when the value is one of these addresses.
-		 */
 		/**
 		 * The right bar's registry, normalised: one row per page type with its kind, the label
 		 * the tab shows, whether more than one may be open, and its empty-state card (measured
@@ -297,36 +845,6 @@ window.__ModuleLoader__.load({
 		 * @param {object} faces - the probed host faces.
 		 * @returns {{kind: string, label: string|undefined, multiple: boolean}[]|undefined} the rows.
 		 */
-		/**
-		 * The seq of a turn's start event, from the `turnOutline` projection.
-		 *
-		 * The projection is a public read on the session controller (the core reads it the same
-		 * way: `session.projections.faceOf("turnOutline").getSnapshot()`), and each entry carries
-		 * the `seq` of that turn's `turn/start` — which is exactly what `loadThrough` pages back
-		 * to. Reading it is what makes a turn link work for a turn that is not loaded yet.
-		 * @param {object} faces - the probed host faces.
-		 * @param {string|undefined} sessionId - the session the turn belongs to.
-		 * @param {string} turn - the turn number.
-		 * @returns {number|undefined} the seq, when the projection names that turn.
-		 */
-		function turnSeqOf(faces, sessionId, turn) {
-			if (typeof sessionId !== 'string' || sessionId === '') return undefined
-			// Reached by retaining the session's scope: `sessions.binding(id)` answers undefined
-			// for a session nobody materialised yet (measured), while `retainScope(id, source)`
-			// materialises it and returns a reference whose `binding` is the live one. Released here
-			// because only the projection is read.
-			const reference = attemptValue(() => faces.sessions?.retainScope?.(sessionId, 'url-router'))
-			const outline = attemptValue(() => session?.projections?.faceOf?.('turnOutline')?.getSnapshot?.())
-			attempt(() => reference?.release?.())
-			if (!Array.isArray(outline)) return undefined
-			const wanted = String(turn)
-			for (const entry of outline) {
-				if (entry === null || typeof entry !== 'object') continue
-				if (String(entry.turn) !== wanted) continue
-				return typeof entry.seq === 'number' ? entry.seq : undefined
-			}
-			return undefined
-		}
 
 		function paneRegistryOf(faces) {
 			const rows = attemptValue(() => faces.sidebarRightTabs?.entries?.())
@@ -392,6 +910,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.
@@ -430,7 +1014,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')))
@@ -444,6 +1032,206 @@ 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.
+		 */
+		function settingsPartsOf(inner) {
+			const parts = innerPath(inner)
+			const at = parts.indexOf(PROVIDER_SEGMENT)
+			if (at < 0) return { tab: parts[0], provider: undefined }
+			return { tab: at > 0 ? parts[0] : undefined, provider: 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 `#`.
@@ -523,7 +1311,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 }
 		}
 
@@ -584,6 +1372,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 !== '')
@@ -653,7 +1462,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
@@ -665,6 +1474,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
@@ -694,22 +1505,32 @@ window.__ModuleLoader__.load({
 				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] }
+					// 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 = [...(tab === undefined ? [] : [tab]), ...(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) {
@@ -738,7 +1559,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) {
@@ -784,6 +1606,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) {
@@ -827,8 +1670,12 @@ 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)
+				if (wanted.tab !== undefined && wanted.tab !== shown.tab) 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 => {
@@ -861,6 +1708,7 @@ window.__ModuleLoader__.load({
 			 */
 			const reconcile = (source = 'boot') => {
 				if (disposed) return
+				workCounts.reconciles += 1
 
 				const current = canonical()
 				const currentKey = routeKey(current)
@@ -873,6 +1721,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) {
@@ -889,8 +1753,18 @@ window.__ModuleLoader__.load({
 					// 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) {
@@ -972,7 +1846,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.tab, parts.provider)
 					}
 					armRetry()
 					return
@@ -1063,7 +1938,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
@@ -1266,6 +2150,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,
@@ -1775,6 +2667,13 @@ window.__ModuleLoader__.load({
 			}
 			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 => {
@@ -1799,6 +2698,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).
@@ -1822,6 +2734,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.
@@ -1847,8 +2768,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]
@@ -1856,8 +2778,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
 					}
 				},
@@ -1929,6 +2851,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}]`) ?? []) {
@@ -1961,16 +2884,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
@@ -2031,10 +2984,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
@@ -2062,6 +3018,8 @@ 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)
@@ -2087,7 +3045,7 @@ window.__ModuleLoader__.load({
 						window.document?.dispatchEvent?.(event)
 					})
 				},
-				openSettings: (section, tab) => {
+				openSettings: (section, tab, provider) => {
 					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)
@@ -2100,7 +3058,11 @@ window.__ModuleLoader__.load({
 							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 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, so pressing twice would flap).
+								const current = candidates.find(candidate => attemptValue(() => candidate.getAttribute?.('aria-current')) === 'true')
+								if (current !== match) 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()
@@ -2108,6 +3070,8 @@ window.__ModuleLoader__.load({
 									const matchTab = tabs.find(candidate => (candidate.textContent ?? '').trim().toLowerCase() === wantedTab)
 									if (matchTab !== undefined && typeof matchTab.click === 'function') attempt(() => matchTab.click())
 								}
+								// And one of its cards may be the page a link named.
+								if (typeof provider === 'string' && provider !== '') clickSettingsProvider(provider)
 								return
 							}
 						}
@@ -2228,7 +3192,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).
@@ -2247,6 +3226,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,
 							],
 						})
@@ -2383,6 +3366,56 @@ window.__ModuleLoader__.load({
 			return `打不开 ${name}（当前 ${shown}，侧栏 ${rows} 行）`
 		}
 
+		/**
+		 * Whether this window is the macOS desktop build.
+		 *
+		 * The macOS desktop shell draws a native title bar and publishes no in-page
+		 * strip, so the Windows marker is absent there — which used to mean "draw
+		 * nothing". Two facts together identify a macOS desktop window: the shell marks
+		 * `<html data-platform="darwin">` (or the user agent says Mac), and the window
+		 * is the application rather than a browser tab (Electron in the user agent, or
+		 * the page served over the app's own `dsh-app:` scheme). The plain web app in a
+		 * browser satisfies neither and stays empty, as before.
+		 *
+		 * @param {object} root - `document.documentElement`.
+		 * @returns {boolean} true when the address bar belongs on screen.
+		 */
+		function macDesktopWindow(root) {
+			const ua = typeof navigator === 'object' && navigator !== null ? String(navigator.userAgent ?? '') : ''
+			const platform = typeof root?.getAttribute === 'function' ? root.getAttribute('data-platform') : null
+			const isMac = platform === 'darwin' || /Mac OS X|Macintosh/u.test(ua)
+			if (!isMac) return false
+			const protocol = String(globalThis.location?.protocol ?? '')
+			return /Electron\/\d/u.test(ua) || protocol.startsWith('dsh-app')
+		}
+
+
+		/**
+		 * The power-menu trigger, the one element that is guaranteed to sit on the
+		 * same row on every screen. The address bar anchors to it.
+		 *
+		 * @returns {object|undefined} the trigger element, or undefined when absent.
+		 */
+		function powerTrigger() {
+			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
+		}
+
+		/** An element's own text, ignoring the text of its children. */
+		function ownText(el) {
+			if (el === null || el === undefined || typeof el.childNodes !== 'object') return ''
+			let text = ''
+			for (const node of el.childNodes) {
+				if (node !== null && node.nodeType === 3) text += node.textContent ?? ''
+			}
+			return text.trim()
+		}
+
+
 		/**
 		 * Draw the address bar into the desktop window's title bar strip.
 		 * @param {object} document - the document to draw into.
@@ -2393,14 +3426,32 @@ window.__ModuleLoader__.load({
 			if (document === undefined || document === null) return () => {}
 			const root = document.documentElement
 			// The marker is the shell's own statement that this page has a title bar drawn
-			// inside it. Without it there is no strip, and nothing is drawn.
-			if (typeof root?.getAttribute !== 'function' || root.getAttribute(WINDOWS_TITLEBAR_ATTRIBUTE) === null) return () => {}
+			// inside it. Without it there is no strip — but the macOS desktop build still
+			// gets a bar, drawn into the session header row instead.
+			const windowsStrip = typeof root?.getAttribute === 'function' && root.getAttribute(WINDOWS_TITLEBAR_ATTRIBUTE) !== null
+			const macInHeader = !windowsStrip && macDesktopWindow(root)
+			if (!windowsStrip && !macInHeader) return () => {}
 			if (typeof document.createElement !== 'function' || typeof document.body?.appendChild !== 'function') return () => {}
+			// One bar, one stylesheet — however many times this runs.
+			//
+			// The effect that draws the bar can run again in a live window (a hot
+			// reload of this plugin re-applies it), and a second mount would leave a
+			// second box on screen. Both are identified by id, so anything already
+			// there is taken down before the new one goes up: the platform split
+			// decides *where* the one bar lives, never how many there are.
+			try {
+				const staleBar = document.getElementById?.(TITLEBAR_BAR_ID)
+				if (staleBar !== null && staleBar !== undefined) staleBar.remove?.()
+				const staleStyle = document.getElementById?.(TITLEBAR_STYLE_ID)
+				if (staleStyle !== null && staleStyle !== undefined) staleStyle.remove?.()
+			} catch {
+				// A document without getElementById keeps the disposer as its only guard.
+			}
 			let style
 			try {
 				style = document.createElement('style')
 				style.id = TITLEBAR_STYLE_ID
-				style.textContent = 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 {
@@ -2408,26 +3459,201 @@ window.__ModuleLoader__.load({
 			}
 			const bar = document.createElement('div')
 			bar.id = TITLEBAR_BAR_ID
-			if (typeof bar.setAttribute === 'function') bar.setAttribute('data-dsh-part', TITLEBAR_PART)
+			if (typeof bar.setAttribute === 'function') {
+				bar.setAttribute('data-dsh-part', TITLEBAR_PART)
+				bar.setAttribute('data-dsh-url-router-platform', macInHeader ? 'mac' : 'windows')
+			}
 			const input = document.createElement('input')
 			input.type = 'text'
 			input.spellcheck = false
 			input.placeholder = TITLEBAR_PLACEHOLDER
 			if (typeof input.setAttribute === 'function') input.setAttribute('aria-label', '地址栏 / address bar')
 			bar.appendChild(input)
-			/** Start after the shell's menu, stop before its window buttons. */
-			const place = () => {
-				let menuWidth = 0
-				try {
-					const menu = typeof document.querySelector === 'function' ? document.querySelector(`[${WINDOWS_MENU_ATTRIBUTE}]`) : null
-					if (menu !== null && menu !== undefined && typeof menu.getBoundingClientRect === 'function') menuWidth = menu.getBoundingClientRect().width || 0
-				} catch {
-					menuWidth = 0
+			// 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.
+		 *
+		 * A screen with no power button — a panel, the plugins page, settings — has
+		 * nothing to align to. The bar keeps this stretch there, so changing views
+		 * neither moves it nor makes it vanish. The stretch is also kept on disk, so
+		 * a window that starts on such a screen still gets the bar where it belongs;
+		 * and because the box is fitted from the stretch each time, a change to the
+		 * bar's margins applies there too, without waiting for a conversation.
+		 */
+		let lastPlacement = attemptValue(() => {
+			const raw = globalThis.localStorage?.getItem?.(MAC_PLACEMENT_KEY)
+			if (raw === null || raw === undefined || raw === '') return null
+			const parsed = JSON.parse(raw)
+			const gap = parsed?.gap
+			if (typeof parsed?.top !== 'number' || typeof parsed?.viewport !== 'number') return null
+			if (typeof gap?.left !== 'number' || typeof gap?.right !== 'number') return null
+			return { top: parsed.top, viewport: parsed.viewport, gap: { left: gap.left, right: gap.right } }
+		}) ?? null
+		/**
+		 * Fit the bar into a free stretch of the header row.
+		 *
+		 * The bar takes the whole stretch bar a margin on each side, so it is as
+		 * long as the row can spare without touching what stands beside it. A
+		 * narrow row keeps the whole stretch rather than a sliver of it.
+		 *
+		 * @param {{left: number, right: number}} gap - the free stretch.
+		 * @param {number} top - the row's line, already centred on the power button.
+		 * @returns {{left: number, top: number, width: number}} the box to draw.
+		 */
+		const fitBar = (gap, top) => {
+			const right = gap.right - MAC_BAR_GAP - MAC_BAR_INSET
+			const room = gap.left + MAC_BAR_INSET
+			const available = right - room
+			const width = available >= MAC_BAR_MIN_WIDTH
+				? Math.round(Math.min(MAC_BAR_MAX_WIDTH, available))
+				: Math.round(gap.right - MAC_BAR_GAP - gap.left)
+			return { left: Math.round(right - width), top, width }
+		}
+		/**
+		 * Remember the stretch the bar went into, and put it on disk when it moved.
+		 * @param {object} placement - the line and the stretch just used.
+		 */
+		const remember = placement => {
+			const previous = lastPlacement
+			lastPlacement = placement
+			if (previous !== null
+				&& previous.top === placement.top
+				&& previous.viewport === placement.viewport
+				&& previous.gap.left === placement.gap.left
+				&& previous.gap.right === placement.gap.right) return
+			attemptValue(() => globalThis.localStorage?.setItem?.(MAC_PLACEMENT_KEY, JSON.stringify(placement)))
+		}
+		/**
+		 * Put the bar where it belongs.
+		 *
+		 * Windows: start after the shell's menu, stop before its window buttons.
+		 * 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
+				// button, in the free stretch between the title text and the
+				// header's own buttons. The row's real contents are measured and the
+				// widest free stretch is chosen, so the bar covers nothing — and,
+				// being a fixed-position layer, it pushes nothing either.
+				const trigger = powerTrigger()
+				const rect = trigger?.getBoundingClientRect?.()
+				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) {
+					// Nothing on this screen to align to. Keep the stretch the
+					// conversation gave the bar, so switching views does not move it
+					// and does not make it disappear.
+					//
+					// Only while the window is still the one that stretch was measured
+					// in: the header's buttons sit at the right end of the window, so a
+					// resize moves them, and reusing an old stretch would draw the bar
+					// straight across the title and the buttons. With no button to
+					// measure from there is nothing to re-derive it from either, so a
+					// resized window hides the bar until a conversation places it again.
+					const viewport = Math.round(globalThis.innerWidth ?? 0)
+					if (lastPlacement === null || viewport <= 0
+						|| Math.abs(viewport - lastPlacement.viewport) > MAC_BAR_RESIZE_SLACK) {
+						bar.style.display = 'none'
+						return
+					}
+					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 = `${box.left}px`
+					bar.style.right = 'auto'
+					bar.style.width = `${box.width}px`
+					return
 				}
-				bar.style.left = `${WINDOWS_MENU_START + menuWidth + TITLEBAR_GAP}px`
-				bar.style.right = `${TITLEBAR_CAPTION_WIDTH}px`
+				const top = Math.round(rect.top + (rect.height - MAC_BAR_HEIGHT) / 2)
+				const box = fitBar(gap, top)
+				bar.style.display = ''
+				bar.style.top = `${box.top}px`
+				bar.style.left = `${box.left}px`
+				bar.style.right = 'auto'
+				bar.style.width = `${box.width}px`
+				remember({ top, viewport: Math.round(globalThis.innerWidth ?? 0), gap })
+				return
 			}
-			place()
+			let menuWidth = 0
+			try {
+				const menu = typeof document.querySelector === 'function' ? document.querySelector(`[${WINDOWS_MENU_ATTRIBUTE}]`) : null
+				if (menu !== null && menu !== undefined && typeof menu.getBoundingClientRect === 'function') menuWidth = menu.getBoundingClientRect().width || 0
+			} catch {
+				menuWidth = 0
+			}
+			bar.style.left = `${WINDOWS_MENU_START + menuWidth + TITLEBAR_GAP}px`
+			bar.style.right = `${TITLEBAR_CAPTION_WIDTH}px`
+			bar.style.width = 'auto'
+		}
+		/**
+		 * Place the bar at most once per frame.
+		 *
+		 * A streaming answer mutates the document constantly, and every mutation
+		 * would otherwise re-measure the header row. Coalescing the runs into one
+		 * frame keeps the bar where it belongs without measuring the header dozens
+		 * of times a second.
+		 */
+		let placeFrame
+		const schedulePlace = () => {
+			if (placeFrame !== undefined) return
+			placeFrame = attemptValue(() => window.requestAnimationFrame?.(() => {
+				placeFrame = undefined
+				place()
+			}))
+			// No animation frames in this host: place it straight away.
+			if (placeFrame === undefined) place()
+		}
+		place()
 			/** How the bar looks right now: idle, waiting for a link to land, or refused. */
 			const mark = (state, hint) => {
 				if (typeof bar.setAttribute === 'function') bar.setAttribute('data-dsh-url-router-state', state)
@@ -2486,14 +3712,291 @@ 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
+				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()
+			}
 			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.
@@ -2510,11 +4013,39 @@ window.__ModuleLoader__.load({
 				settle(fragment, false)
 			}
 			input.addEventListener('keydown', onKeyDown)
+			input.addEventListener('focus', onFocus)
+			input.addEventListener('mousedown', onMouseDown)
+			input.addEventListener('input', onInput)
+			input.addEventListener('paste', onPaste)
+			input.addEventListener('blur', onBlur)
+			// 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)
+			// The first placement measured the header before the bar was in the
+			// document. Place it again now that it is, so the bar's own box is laid
+			// out and can be checked, and so the first paint is already correct.
+			place()
+			/**
+			 * The shell re-renders the session header whenever the view changes, which
+			 * takes the bar with it. A watcher puts it back where it belongs — the same
+			 * node, so what was typed into it survives.
+			 */
+			let headerWatcher
+			// 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 Observer(() => schedulePlace())
+					headerWatcher.observe(document.body, { childList: true, subtree: true })
+				} catch {
+					headerWatcher = undefined
+				}
+			}
 			const offRoute = subscribe(show)
 			let onResize
 			try {
-				onResize = () => place()
+				onResize = () => schedulePlace()
 				window.addEventListener('resize', onResize)
 			} catch {
 				onResize = undefined
@@ -2522,13 +4053,175 @@ 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)
+				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?.()
 				style?.remove?.()
 			}
 		}
 
+		// ---------------------------------------------------------------------
+		// 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.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: '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 条（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(() => {
@@ -2583,6 +4276,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