deepseek-harness-background 0.4.0 → 0.4.2

package/lib/client.js

@@ -75,7 +75,13 @@ window.__ModuleLoader__.load({
 		*
 		* Selectors target authored attributes (`data-dsh-bg`, `data-composer-card`,
 		* `data-terminal`…), the `:global` `.md-code-block` anchor, and CSS-module
-		* SUFFIX conventions (`_bubble`, `_newSession`…) audited for collisions:
+		* SUFFIX conventions (`_bubble`, `_newSession`…) audited for collisions.
+		*
+		* MAINTENANCE NOTE: the suffix anchors are the host's only stable-enough
+		* integration surface today, but a host restyle that renames them silently
+		* drops the glass. Upgrade path: once the host ships stable data-* anchors
+		* for these surfaces, swap the selector lists below to them and delete the
+		* suffix entries.
 		* `_bubble` excludes `role="tooltip"` (Tooltip.module.css shares the suffix),
 		* `_add` is scoped under `[data-composer-card]` (DiffBlock line markers share
 		* it), `_newSession` excludes `Label` (the button's inner label span) and
@@ -440,6 +446,8 @@ window.__ModuleLoader__.load({
 			observer;
 			active = false;
 			settings;
+			/** Whether the current section resolves to an actual image source. */
+			hasSource = false;
 			savedTokens = /* @__PURE__ */ new Map();
 			savedVars = /* @__PURE__ */ new Map();
 			/** Remember + hijack a property only once so dispose restores the original. */
@@ -468,6 +476,7 @@ window.__ModuleLoader__.load({
 					this.restoreFrameTokens();
 					this.applySurfaceGlass(settings, true);
 					this.active = false;
+					this.hasSource = false;
 					this.removeLayers();
 					document.body.removeAttribute(ACTIVE_ATTR);
 					return;
@@ -483,10 +492,20 @@ window.__ModuleLoader__.load({
 					this.img.className = IMAGE_CLASS;
 					this.img.alt = "";
 					this.img.referrerPolicy = "no-referrer";
+					this.img.onerror = () => {
+						if (this.img === null || this.img.dataset.failed === "1") return;
+						this.img.dataset.failed = "1";
+						this.img.style.visibility = "hidden";
+						console.warn("[deepseek-harness-background] wallpaper image failed to load:", this.img.getAttribute("src"));
+					};
 					this.layer.appendChild(this.img);
 					document.body.appendChild(this.layer);
 				}
-				if (this.img && this.img.getAttribute("src") !== url) this.img.src = url;
+				if (this.img && this.img.getAttribute("src") !== url) {
+					delete this.img.dataset.failed;
+					this.img.style.visibility = "";
+					this.img.src = url;
+				}
 				if (!this.scrim) {
 					this.scrim = document.createElement("div");
 					this.scrim.className = SCRIM_CLASS;
@@ -494,6 +513,7 @@ window.__ModuleLoader__.load({
 				}
 				document.body.setAttribute(ACTIVE_ATTR, "on");
 				this.active = true;
+				this.hasSource = true;
 				document.body.style;
 				this.setVar("--bg-object-fit", settings.fit);
 				this.setVar("--bg-opacity", String(settings.opacity));
@@ -546,6 +566,15 @@ window.__ModuleLoader__.load({
 					case "scrim":
 						this.setVar("--bg-scrim", String(value));
 						break;
+					case "panelOpacity": {
+						const next = {
+							...this.settings,
+							panelOpacity: Number(value)
+						};
+						this.settings = next;
+						this.applySurfaceGlass(next, !this.hasSource);
+						break;
+					}
 					case "blur":
 						this.setVar("--bg-glass-blur", `${value}px`);
 						this.setVar("--bg-glass-saturate", String(glassSaturate(Number(value))));
@@ -696,14 +725,22 @@ window.__ModuleLoader__.load({
 		const REGISTRY_CSS_TAG = "deepseek-harness-background/glass-registry";
 		/** Plugin identity stamped onto the registry <style> element. */
 		const PLUGIN_ID = "deepseek-harness-background";
-		/** Characters whose presence would let a selector escape its rule context. */
+		/**
+		* Characters whose presence would let a selector escape its rule context.
+		* ',' is refused too: inside the generated rule body
+		* (`body[gate] <selector> { … }`) a comma lets one registration broaden the
+		* rule to ARBITRARY extra subjects (`.x, html body`) — an unintended
+		* widening of the glass sheet beyond the registered surface. Multiple
+		* surfaces stay supported through the selectors ARRAY.
+		*/
 		const FORBIDDEN_SELECTOR_CHARS = [
 			"{",
 			"}",
 			";",
 			"@",
 			"<",
-			">"
+			">",
+			","
 		];
 		/** Hard cap on one selector's length (diagnostics-friendly, abuse-proof). */
 		const MAX_SELECTOR_LENGTH = 500;
@@ -916,7 +953,8 @@ window.__ModuleLoader__.load({
 			"timeline.marksOnly": "★ 只看标记",
 			"timeline.mark": "标记为重点",
 			"timeline.unmark": "取消重点标记",
-			"timeline.noMarks": "还没有标记的重点"
+			"timeline.noMarks": "还没有标记的重点",
+			"timeline.cannotJump": "无法跳转：这条历史消息缺少定位信息"
 		};
 		/** English copy. */
 		const en = {
@@ -952,7 +990,8 @@ window.__ModuleLoader__.load({
 			"timeline.marksOnly": "★ Marked only",
 			"timeline.mark": "Mark as key point",
 			"timeline.unmark": "Unmark key point",
-			"timeline.noMarks": "No marked key points"
+			"timeline.noMarks": "No marked key points",
+			"timeline.cannotJump": "Cannot jump: this history message lacks position info"
 		};
 		//#endregion
 		//#region node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
@@ -1087,40 +1126,40 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var SettingsRow_module_css_default = {
-			"switch": "-ozqdq_switch",
-			"preview": "-ozqdq_preview",
-			"sliderLabel": "-ozqdq_sliderLabel",
-			"segRow": "-ozqdq_segRow",
-			"urlRow": "-ozqdq_urlRow",
-			"previewImg": "-ozqdq_previewImg",
-			"previewGlass": "-ozqdq_previewGlass",
-			"hint": "-ozqdq_hint",
-			"header": "-ozqdq_header",
-			"slider": "-ozqdq_slider",
-			"title": "-ozqdq_title",
+			"switchKnob": "-ozqdq_switchKnob",
 			"segLabel": "-ozqdq_segLabel",
-			"urlInput": "-ozqdq_urlInput",
+			"btnDanger": "-ozqdq_btnDanger",
+			"row": "-ozqdq_row",
+			"previewGlassText": "-ozqdq_previewGlassText",
+			"previewGlass": "-ozqdq_previewGlass",
+			"urlRow": "-ozqdq_urlRow",
+			"clearRow": "-ozqdq_clearRow",
 			"error": "-ozqdq_error",
-			"enabledBadge": "-ozqdq_enabledBadge",
-			"btnPrimary": "-ozqdq_btnPrimary",
-			"clearBtn": "-ozqdq_clearBtn",
-			"sectionLabel": "-ozqdq_sectionLabel",
-			"switchKnob": "-ozqdq_switchKnob",
-			"section": "-ozqdq_section",
+			"sliderLabel": "-ozqdq_sliderLabel",
+			"title": "-ozqdq_title",
+			"sourceRow": "-ozqdq_sourceRow",
 			"sliderValue": "-ozqdq_sliderValue",
-			"row": "-ozqdq_row",
+			"titleRow": "-ozqdq_titleRow",
+			"clearBtn": "-ozqdq_clearBtn",
+			"segGroup": "-ozqdq_segGroup",
+			"segBtn": "-ozqdq_segBtn",
+			"hint": "-ozqdq_hint",
+			"urlInput": "-ozqdq_urlInput",
 			"previewScrim": "-ozqdq_previewScrim",
+			"enabledBadge": "-ozqdq_enabledBadge",
+			"previewImg": "-ozqdq_previewImg",
+			"slider": "-ozqdq_slider",
 			"desc": "-ozqdq_desc",
-			"segGroup": "-ozqdq_segGroup",
-			"clearRow": "-ozqdq_clearRow",
+			"segRow": "-ozqdq_segRow",
 			"segActive": "-ozqdq_segActive",
+			"section": "-ozqdq_section",
+			"btnPrimary": "-ozqdq_btnPrimary",
+			"preview": "-ozqdq_preview",
+			"sectionLabel": "-ozqdq_sectionLabel",
+			"header": "-ozqdq_header",
 			"sliderRow": "-ozqdq_sliderRow",
+			"switch": "-ozqdq_switch",
 			"btn": "-ozqdq_btn",
-			"titleRow": "-ozqdq_titleRow",
-			"btnDanger": "-ozqdq_btnDanger",
-			"previewGlassText": "-ozqdq_previewGlassText",
-			"sourceRow": "-ozqdq_sourceRow",
-			"segBtn": "-ozqdq_segBtn",
 			"previewEmpty": "-ozqdq_previewEmpty"
 		};
 		//#endregion
@@ -1320,8 +1359,7 @@ window.__ModuleLoader__.load({
 				};
 				draftRef.current = next;
 				markEditing();
-				if (key === "panelOpacity") paintBackground(next);
-				else paintBackgroundKnob(key, value);
+				paintBackgroundKnob(key, value);
 				if (previewRef.current) paintPreviewSurface(previewRef.current, next);
 			}, [markEditing]);
 			/** Persist one section through the host route and adopt it on success. */
@@ -1329,6 +1367,7 @@ window.__ModuleLoader__.load({
 				dirtyRef.current = true;
 				const result = await settingsClient.save(next);
 				if (result === "failed") {
+					dirtyRef.current = false;
 					setError(t("background.saveFailed"));
 					return;
 				}
@@ -1877,6 +1916,8 @@ window.__ModuleLoader__.load({
     display: flex; align-items: center; justify-content: flex-end;
   }
   .dsbt-jump:focus-visible { outline: 1px solid currentColor; outline-offset: -1px; border-radius: 6px; }
+  .dsbt-jump:disabled { cursor: default; opacity: .55; }
+  .dsbt-jump:disabled .dsbt-title { text-decoration: line-through; text-decoration-color: currentColor; }
   .dsbt-item:hover { color: var(--dsw-alias-label-primary, rgba(0, 0, 0, .95)); }
   body[data-ds-dark-theme] .dsbt-item { color: rgba(255, 255, 255, .65); }
   body[data-ds-dark-theme] .dsbt-item:hover { color: rgba(255, 255, 255, .95); }
@@ -1973,9 +2014,15 @@ window.__ModuleLoader__.load({
 		* - Key-point bookmarks: star a question in the expanded panel, persisted per
 		*   session in localStorage; marked rows show a golden tick in the capsule
 		*   and a "marked only" filter narrows the list.
-		* - Jump stabilization: the reading-position tracker freezes while a smooth
-		*   jump animates (cleared 150ms after the last scroll event, plus an 800ms
-		*   fallback), so the panel cannot jitter mid-jump.
+		* - Jump stabilization: the reading-position tracker freezes while a jump
+		*   glide animates (cleared 150ms after the last scroll event, plus a 2s
+		*   fallback), so the panel cannot jitter mid-jump. The glide itself is a
+		*   rAF ease-in-out on the conversation scrollport: a ~26px bottom-follow
+		*   detach first settles the official at-bottom flag outside its 25px zone
+		*   (so a tip-moved re-render cannot yank the slide back to the floor — the
+		*   earlier instant+smooth double pass kept the jump working but made the
+		*   slide invisible), and wheel/touch/keyboard input cancels it so the
+		*   reader takes over instantly.
 		* - Rewind integration: messages withdrawn by a rewind command node are
 		*   filtered out of the rail.
 		*
@@ -2048,16 +2095,73 @@ window.__ModuleLoader__.load({
 				else window.localStorage.setItem(MARKS_STORAGE_PREFIX + sessionId, JSON.stringify(marks));
 			} catch {}
 		}
+		/** Parse digits into a finite number (undefined otherwise). */
+		function parseSeqDigits(digits) {
+			if (digits === void 0) return void 0;
+			const n = Number.parseInt(digits, 10);
+			return Number.isFinite(n) ? n : void 0;
+		}
+		/** Extract a seq from a string-ish field ('@42', 'seq 42', '#42', bare 42). */
+		function seqFromStringish(value) {
+			if (typeof value === "number" && Number.isFinite(value)) return value;
+			if (typeof value !== "string") return void 0;
+			const m = /(?:@|seq\s*|#)?(\d+)/i.exec(value);
+			return m === null ? void 0 : parseSeqDigits(m[1]);
+		}
 		/**
-		* Extract the rewind target seq from a rewind outcome text.
+		* Extract the rewind target seq from a rewind outcome text. Multi-pattern
+		* (ported from dsh-chat-timeline v0.1.5): an explicit `seq 42` declaration
+		* wins, then `#42`, then the broad english/chinese verb forms — the old
+		* single "rewound" regex silently missed real success texts like "已撤回
+		* seq 42" / "Withdrawn seq 42" (upstream issue #6).
 		* @param text - the command outcome text.
 		*/
 		function rewindTargetOfOutcome(text) {
 			if (typeof text !== "string") return void 0;
-			const digits = (/rewound.*?(?:target\s+)?(\d+)/i.exec(text) ?? /#(\d+)/.exec(text))?.[1];
-			if (digits === void 0) return void 0;
-			const n = Number.parseInt(digits, 10);
-			return Number.isFinite(n) ? n : void 0;
+			const seqMatch = /seq\s*(\d+)/i.exec(text);
+			if (seqMatch !== null) return parseSeqDigits(seqMatch[1]);
+			const hashMatch = /#(\d+)/.exec(text);
+			if (hashMatch !== null) return parseSeqDigits(hashMatch[1]);
+			const broadMatch = /(?:rewound|withdrawn|已撤回).*?(?:target\s+)?(\d+)/i.exec(text);
+			if (broadMatch !== null) return parseSeqDigits(broadMatch[1]);
+		}
+		/**
+		* Resolve the target of a rewind command: structured fields first
+		* (outcome.targetSeq / outcome.target / args.targetSeq / args.target /
+		* args.seq / args.raw / args[0]), then the outcome text — mirrors upstream
+		* v0.1.5 so locale-independent producers keep parsing without text
+		* heuristics (the args.seq guard skips the command's own seq).
+		* @param command - the command payload.
+		*/
+		function rewindTargetOfCommand(command) {
+			if (command === null || typeof command !== "object") return void 0;
+			const rec = command;
+			const outcome = rec.outcome;
+			if (outcome !== null && typeof outcome === "object") {
+				const o = outcome;
+				if (typeof o.targetSeq === "number" && Number.isFinite(o.targetSeq)) return o.targetSeq;
+				if (typeof o.target === "number" && Number.isFinite(o.target)) return o.target;
+			}
+			const args = rec.args;
+			if (args !== null && typeof args === "object") {
+				const record = args;
+				if (typeof record.targetSeq === "number" && Number.isFinite(record.targetSeq)) return record.targetSeq;
+				if (typeof record.target === "number" && Number.isFinite(record.target)) return record.target;
+				if (typeof record.seq === "number" && Number.isFinite(record.seq) && record.seq !== rec.seq) return record.seq;
+				const rawish = record.raw ?? record["0"] ?? (Array.isArray(args) ? args[0] : void 0);
+				if (rawish !== void 0) {
+					const n = seqFromStringish(rawish);
+					if (n !== void 0) return n;
+				}
+				if (typeof record.target === "string") {
+					const n = seqFromStringish(record.target);
+					if (n !== void 0) return n;
+				}
+			}
+			if (outcome !== null && typeof outcome === "object") {
+				const text = outcome.text;
+				if (typeof text === "string") return rewindTargetOfOutcome(text);
+			}
 		}
 		/**
 		* Is this rewind command a preview/dry-run (marks the target hidden without
@@ -2077,6 +2181,7 @@ window.__ModuleLoader__.load({
 		*/
 		function hiddenSeqsOfChat(chat) {
 			const hidden = rewindHiddenSeqsOfChat(chat);
+			for (const seq of rewindMarkedSeqsOfChat(chat)) hidden.add(seq);
 			const spans = rewindSpansOfChat(chat);
 			if (spans.length === 0) return hidden;
 			const nodes = chat.nodes;
@@ -2090,6 +2195,32 @@ window.__ModuleLoader__.load({
 			return hidden;
 		}
 		/**
+		* Seq numbers of nodes carrying a rewind-hidden marker (upstream v0.1.5):
+		* host/plugin producers can tag the node record itself (rewindHidden), its
+		* data payload, or the payload's attributes map.
+		* @param chat - a chat snapshot (loosely typed on purpose).
+		*/
+		function rewindMarkedSeqsOfChat(chat) {
+			const marked = /* @__PURE__ */ new Set();
+			const nodes = chat.nodes;
+			if (nodes === void 0 || typeof nodes.values !== "function") return marked;
+			for (const node of nodes.values()) {
+				if (node === null || typeof node !== "object") continue;
+				const data = node.data;
+				if (data === null || typeof data !== "object") continue;
+				const record = data;
+				const attrs = record.attributes;
+				if (attrs !== null && typeof attrs === "object" && attrs["data-dsh-rewind-hidden"] === true) {
+					if (typeof node.anchorSeq === "number") marked.add(node.anchorSeq);
+					continue;
+				}
+				if (record["data-dsh-rewind-hidden"] === true || node.rewindHidden === true) {
+					if (typeof node.anchorSeq === "number") marked.add(node.anchorSeq);
+				}
+			}
+			return marked;
+		}
+		/**
 		* Seq numbers a rewind hid directly: successful commands hide their own row;
 		* preview commands hide their target.
 		* @param chat - a chat snapshot (loosely typed on purpose).
@@ -2137,7 +2268,7 @@ window.__ModuleLoader__.load({
 				if (outcome === null || typeof outcome !== "object" || outcome.kind !== "success") continue;
 				const marker = outcome.sourceEventSeq;
 				if (typeof marker !== "number") continue;
-				const target = rewindTargetOfOutcome(outcome.text);
+				const target = rewindTargetOfCommand(command);
 				if (target !== void 0) spans.push({
 					start: target,
 					end: marker
@@ -2175,6 +2306,19 @@ window.__ModuleLoader__.load({
 			out.sort((a, b) => a.seq - b.seq);
 			return out;
 		}
+		/**
+		* Count the user messages the loaded window holds WITHOUT collecting or
+		* sorting them — the fast gate railMessages uses to skip the merge path on
+		* the streaming hot path (see there).
+		* @param chat - the loaded chat snapshot.
+		*/
+		function countWindowUserMessages(chat) {
+			const nodes = chat?.nodes;
+			if (nodes === void 0 || typeof nodes.values !== "function") return 0;
+			let count = 0;
+			for (const node of nodes.values()) if (node !== null && typeof node === "object" && node.kind === "user") count += 1;
+			return count;
+		}
 		/** Resolve the DOM anchor key of one entry (direct key form only). */
 		function resolveAnchorKey(m) {
 			return typeof m.key === "string" && m.key !== "" ? m.key : void 0;
@@ -2219,24 +2363,45 @@ window.__ModuleLoader__.load({
 			return out;
 		}
 		/**
-		* Rail messages with the fastest source first: the host projection covers the
-		* WHOLE session (and already excludes rewind cuts), so it wins whenever it
-		* has anything; otherwise fall back to the loaded chat-node window. The
-		* projection path still applies locally-known rewind hiding so a cut lands
-		* instantly even before the next projection push arrives.
-		* @param snapshot - the session conversation snapshot (node fallback).
+		* Rail messages: the host projection (whole-session index) MERGED with the
+		* loaded chat-node window. The projection normally wins outright, but a
+		* projection that lost its baseline (e.g. the plugin was hot-reloaded after
+		* the session's tail page seeded the client store) can miss early entries —
+		* the window fills those gaps whenever it holds them, and window entries
+		* lend their real anchor key to projected entries whose durable id was
+		* absent (early events without one). Locally-known rewind hiding applies to
+		* the merged list so a cut lands instantly, before the next projection push.
+		* @param snapshot - the session conversation snapshot (node window).
 		* @param projected - the raw bgTimeline projection value.
 		*/
 		function railMessages(snapshot, projected) {
 			const projectedMessages = normalizeProjectedTimeline(projected);
-			if (projectedMessages.length > 0) {
-				const chat = snapshot?.chat;
-				const hidden = rewindHiddenSeqsOfChat(chat);
-				const spans = rewindSpansOfChat(chat);
-				if (hidden.size === 0 && spans.length === 0) return projectedMessages;
-				return projectedMessages.filter((m) => !hidden.has(m.seq) && !spans.some((span) => m.seq >= span.start && m.seq <= span.end));
+			const chat = snapshot?.chat;
+			const hidden = rewindHiddenSeqsOfChat(chat);
+			const marked = rewindMarkedSeqsOfChat(chat);
+			const spans = rewindSpansOfChat(chat);
+			const isHidden = (seq) => hidden.has(seq) || marked.has(seq) || spans.some((span) => seq >= span.start && seq <= span.end);
+			if (projectedMessages.length === 0) return collectMessages(snapshot);
+			const windowUserCount = countWindowUserMessages(chat);
+			const projectionLacksKeys = projectedMessages.some((m) => m.key === void 0);
+			if (windowUserCount <= projectedMessages.length && !projectionLacksKeys) return marked.size === 0 && hidden.size === 0 && spans.length === 0 ? projectedMessages : projectedMessages.filter((m) => !isHidden(m.seq));
+			const windowMessages = collectMessages(snapshot);
+			const bySeq = /* @__PURE__ */ new Map();
+			for (const m of projectedMessages) if (!isHidden(m.seq)) bySeq.set(m.seq, m);
+			for (const m of windowMessages) {
+				if (isHidden(m.seq)) continue;
+				const existing = bySeq.get(m.seq);
+				if (existing === void 0) {
+					bySeq.set(m.seq, m);
+					continue;
+				}
+				if (existing.key === void 0 && m.key !== void 0) bySeq.set(m.seq, {
+					...existing,
+					key: m.key,
+					...existing.text === "" && m.text !== "" ? { text: m.text } : {}
+				});
 			}
-			return collectMessages(snapshot);
+			return [...bySeq.values()].sort((a, b) => a.seq - b.seq);
 		}
 		/**
 		* Outer rail height for a message count: rows + breathing room, clamped so
@@ -2270,29 +2435,221 @@ window.__ModuleLoader__.load({
 			}
 			return Math.round(Math.max(RAIL_MIN_WIDTH, Math.min(RAIL_MAX_WIDTH, widest + 6 + 24 + 16 + 12)));
 		}
-		/** Ensure the target node is loaded, then scroll its row into view. */
-		async function jumpToMessage(sessionsService, sessionId, key) {
+		/** How long one jump may keep paging older history before giving up. */
+		const JUMP_PAGE_DEADLINE_MS = 3e4;
+		/** How long to wait for the chat view to commit the target row. */
+		const JUMP_ROW_WAIT_MS = 3e3;
+		/** How long the jump-stabilization lock may stay engaged without settling. */
+		const JUMP_LOCK_FALLBACK_MS = 2e3;
+		/**
+		* Poll the conversation DOM until the target row is committed. The session
+		* store updates BEFORE React renders the prepended page, so the old one-shot
+		* query right after loadOlder() resolved could miss the row and silently
+		* give up — the reported "click does nothing until the conversation is
+		* nudged (scroll/click)" behavior.
+		* @param key - chat anchor key to look for.
+		* @param timeoutMs - polling budget.
+		*/
+		async function waitForChatRow(key, timeoutMs) {
+			const scrollports = Array.from(document.querySelectorAll("[data-conversation-scroll]"));
+			if (scrollports.length === 0) return null;
+			const selector = `[data-chat-anchor-key="${CSS.escape(key)}"]`;
+			const deadline = Date.now() + timeoutMs;
+			for (;;) {
+				for (const scrollport of scrollports) {
+					const row = scrollport.querySelector(selector);
+					if (row !== null) return row;
+				}
+				if (Date.now() >= deadline) return null;
+				await delay(40);
+			}
+		}
+		/** Official conversation follow threshold: the view keeps bottom-following while within this distance of the floor (dsh-client-ui-conversation, 25px). */
+		const CONVERSATION_FOLLOW_ZONE_PX = 25;
+		/** Distances under this snap instead of animating. */
+		const MIN_GLIDE_DISTANCE_PX = 8;
+		/** Glide duration floor / cap — a far-boundary rail click stays a tangible slide. */
+		const MIN_GLIDE_MS = 280;
+		const MAX_GLIDE_MS = 900;
+		/** Maximum scrollable offset of a conversation scrollport. */
+		function scrollFloorOf(el) {
+			return Math.max(0, el.scrollHeight - el.clientHeight);
+		}
+		/**
+		* Destination scrollTop that centers `row` inside `el` — the same geometry
+		* as scrollIntoView({ block: 'center' }), computed directly so the glide owns
+		* the scroll position instead of the browser.
+		* @param el - the conversation scrollport.
+		* @param row - the target chat row.
+		*/
+		function centeredScrollTopFor(el, row) {
+			const floor = scrollFloorOf(el);
+			const target = el.scrollTop + (row.getBoundingClientRect().top - el.getBoundingClientRect().top) - (el.clientHeight - row.offsetHeight) / 2;
+			if (!Number.isFinite(target)) return el.scrollTop;
+			return Math.max(0, Math.min(floor, target));
+		}
+		/**
+		* Glide duration for a distance: longer slides take longer, bounded to
+		* [MIN_GLIDE_MS, MAX_GLIDE_MS] (a deep-history rail click reads as a
+		* deliberate glide, not a sluggish race).
+		* @param distance - px to travel.
+		*/
+		function glideDurationFor(distance) {
+			if (!Number.isFinite(distance)) return MIN_GLIDE_MS;
+			return Math.round(Math.max(MIN_GLIDE_MS, Math.min(MAX_GLIDE_MS, 240 + Math.abs(distance) * .14)));
+		}
+		/**
+		* Detach the official bottom-follow state when the reader currently sits
+		* inside its follow zone: assign the scroll position just outside the 25px
+		* boundary. That one synchronous scroll event settles at-bottom to false
+		* (moved-by-reader + outside the zone) so a tip-moved re-render cannot yank
+		* the glide back to the floor. No-op when already above the zone or when
+		* the assignment cannot move (content shorter than the viewport).
+		* @param el - the conversation scrollport.
+		*/
+		function detachBottomFollow(el) {
+			const floor = scrollFloorOf(el);
+			if (el.scrollTop < floor - CONVERSATION_FOLLOW_ZONE_PX) return false;
+			const detached = Math.max(0, floor - CONVERSATION_FOLLOW_ZONE_PX - 1);
+			if (Math.abs(el.scrollTop - detached) < 1) return false;
+			el.scrollTop = detached;
+			return true;
+		}
+		/**
+		* Wait until a detach assignment's scroll event has been dispatched AND
+		* consumed by the official scroll handler: scroll events fire on a later
+		* frame than the assignment, and a paging commit's layout effect runs
+		* before that dispatch — it would re-run the follow logic while the
+		* at-bottom flag is still true and drag the viewport to the growing floor,
+		* undoing the detach (two rAFs + a macrotask bracket the dispatch window).
+		*/
+		function settleScrollEvents() {
+			if (typeof requestAnimationFrame !== "function") return Promise.resolve();
+			return new Promise((resolve) => {
+				requestAnimationFrame(() => requestAnimationFrame(() => window.setTimeout(resolve, 0)));
+			});
+		}
+		/**
+		* Animate el.scrollTop toward target with an ease-in-out cubic profile.
+		* Wheel / touch / keyboard-scroll input cancels the glide so the reader
+		* takes over immediately. Resolves true when the glide completed, false
+		* when the reader cancelled it.
+		* @param el - the conversation scrollport.
+		* @param target - destination scrollTop.
+		* @param durationMs - animation budget.
+		*/
+		function animateScrollTop(el, target, durationMs) {
+			return new Promise((resolve) => {
+				const start = el.scrollTop;
+				const delta = target - start;
+				let done = false;
+				let frame = 0;
+				const finish = (completed) => {
+					if (done) return;
+					done = true;
+					el.removeEventListener("wheel", onWheel);
+					el.removeEventListener("touchstart", onTouch);
+					window.removeEventListener("keydown", onKey);
+					if (frame !== 0) cancelAnimationFrame(frame);
+					resolve(completed);
+				};
+				const onWheel = () => finish(false);
+				const onTouch = () => finish(false);
+				const onKey = (e) => {
+					if ([
+						"ArrowUp",
+						"ArrowDown",
+						"PageUp",
+						"PageDown",
+						"Home",
+						"End",
+						" "
+					].includes(e.key)) finish(false);
+				};
+				el.addEventListener("wheel", onWheel, { passive: true });
+				el.addEventListener("touchstart", onTouch, { passive: true });
+				window.addEventListener("keydown", onKey);
+				if (Math.abs(delta) < .5 || durationMs <= 0) {
+					el.scrollTop = target;
+					finish(true);
+					return;
+				}
+				const t0 = performance.now();
+				const ease = (x) => x < .5 ? 4 * x * x * x : 1 - (-2 * x + 2) ** 3 / 2;
+				const step = (now) => {
+					if (done) return;
+					const t = Math.min(1, (now - t0) / durationMs);
+					el.scrollTop = start + delta * ease(t);
+					if (t < 1) frame = requestAnimationFrame(step);
+					else finish(true);
+				};
+				frame = requestAnimationFrame(step);
+			});
+		}
+		/**
+		* Ensure the target node is loaded, wait for the chat view to commit its row
+		* into the DOM, then glide it into view. Paging uses a time budget instead
+		* of the old fixed 120-iteration guard (each in-flight page burned 50ms of
+		* that guard, so slow history could exhaust it and silently fail).
+		*/
+		async function jumpToMessage(sessionsService, sessionId, key, rowWaitMs = JUMP_ROW_WAIT_MS) {
 			const session = sessionsService.binding(sessionId)?.session;
 			if (session === void 0) return false;
-			let guard = 0;
-			while (guard++ < 120) {
+			let detachedAny = false;
+			for (const el of Array.from(document.querySelectorAll("[data-conversation-scroll]"))) if (detachBottomFollow(el)) {
+				el.dispatchEvent(new Event("scroll"));
+				detachedAny = true;
+			}
+			if (detachedAny) await settleScrollEvents();
+			const deadline = Date.now() + JUMP_PAGE_DEADLINE_MS;
+			for (;;) {
 				const snapshot = session.getSnapshot();
 				if (snapshot?.chat?.nodes?.get(key) !== void 0) break;
-				if (snapshot?.hasMore !== true) return false;
+				if (snapshot?.hasMore !== true) break;
+				if (Date.now() >= deadline) break;
 				if (snapshot.loadingOlder === true) {
 					await delay(50);
 					continue;
 				}
-				await session.loadOlder();
+				if (snapshot.openState !== void 0 && snapshot.openState !== "open") {
+					await delay(100);
+					continue;
+				}
+				try {
+					await session.loadOlder();
+				} catch (error) {
+					console.warn("[deepseek-harness-background] timeline jump paging failed:", error);
+					break;
+				}
+			}
+			const row = await waitForChatRow(key, rowWaitMs);
+			if (row === null) {
+				console.warn(`[deepseek-harness-background] timeline jump target never rendered: ${key}`);
+				return false;
 			}
-			const row = document.querySelector("[data-conversation-scroll]")?.querySelector(`[data-chat-anchor-key="${CSS.escape(key)}"]`) ?? null;
-			if (row === null) return false;
 			const reducedMotion = typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-			row.scrollIntoView({
-				behavior: reducedMotion ? "auto" : "smooth",
-				block: "center"
-			});
-			return true;
+			const scroller = row.closest("[data-conversation-scroll]");
+			if (scroller === null) {
+				row.scrollIntoView({
+					behavior: "auto",
+					block: "center"
+				});
+				if (!reducedMotion) row.scrollIntoView({
+					behavior: "smooth",
+					block: "center"
+				});
+				return true;
+			}
+			const target = centeredScrollTopFor(scroller, row);
+			if (reducedMotion || Math.abs(target - scroller.scrollTop) < MIN_GLIDE_DISTANCE_PX) {
+				scroller.scrollTop = target;
+				return true;
+			}
+			if (detachBottomFollow(scroller)) {
+				scroller.dispatchEvent(new Event("scroll"));
+				await settleScrollEvents();
+			}
+			return await animateScrollTop(scroller, target, glideDurationFor(Math.abs(target - scroller.scrollTop)));
 		}
 		/**
 		* Scroll only the rail itself so the active row stays visible (min distance).
@@ -2578,8 +2935,9 @@ window.__ModuleLoader__.load({
 											type: "button",
 											className: "dsbt-jump",
 											ref: isActive ? activeItemRef : void 0,
-											title: `${marked ? "★ " : ""}${m.text === "" ? t("timeline.noText") : m.text}`,
-											"aria-label": `${marked ? "★ " : ""}${t("timeline.roleUser")}: ${m.text.slice(0, 60) || t("timeline.noText")}`,
+											disabled: key === void 0,
+											title: key === void 0 ? t("timeline.cannotJump") : `${marked ? "★ " : ""}${m.text === "" ? t("timeline.noText") : m.text}`,
+											"aria-label": key === void 0 ? `${marked ? "★ " : ""}${t("timeline.roleUser")}: ${t("timeline.cannotJump")}` : `${marked ? "★ " : ""}${t("timeline.roleUser")}: ${m.text.slice(0, 60) || t("timeline.noText")}`,
 											"aria-current": isActive ? "location" : void 0,
 											onClick: () => {
 												if (key === void 0) return;
@@ -2588,8 +2946,14 @@ window.__ModuleLoader__.load({
 												jumpFallbackRef.current = window.setTimeout(() => {
 													jumpFallbackRef.current = void 0;
 													jumpPendingRef.current = false;
-												}, 800);
-												jumpToMessage(sessionsService, sessionId, key).catch(() => {});
+												}, JUMP_LOCK_FALLBACK_MS);
+												jumpToMessage(sessionsService, sessionId, key).catch(() => {}).finally(() => {
+													if (jumpFallbackRef.current !== void 0) {
+														clearTimeout(jumpFallbackRef.current);
+														jumpFallbackRef.current = void 0;
+													}
+													jumpPendingRef.current = false;
+												});
 											},
 											children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 												className: "dsbt-title",