dsh-smooth-stream 0.3.1 → 0.3.3

package/lib/client.js

@@ -10,7 +10,7 @@ window.__ModuleLoader__.load({
 		let react_jsx_runtime = require("react/jsx-runtime");
 		let _deepseek_ai_dsh_client_runtime_client = require("@deepseek-ai/dsh-client-runtime/client");
 		//#region \0dsh-css:/Users/dzlin/work/project/dsh-smooth-stream/src/client/TypewriterAssistantNodeView.module.css.mjs
-		const css$1 = ".I17U7q_root{min-width:0;color:var(--dsw-alias-label-primary);flex-direction:column;font-size:16px;line-height:28px;display:flex}.I17U7q_body{flex-direction:column;gap:16px;min-width:0;display:flex}.I17U7q_think{flex-direction:column;display:flex}.I17U7q_thinkRow{position:relative;overflow:hidden}.I17U7q_think[data-state=running] .I17U7q_thinkRow:after{content:\"\";inset-block:0;background:linear-gradient(90deg, transparent 0%, color-mix(in srgb, var(--dsw-alias-bg-base) 60%, transparent) 55%, transparent 100%);pointer-events:none;width:300px;animation:2.6s ease-out infinite I17U7q_dsh-smooth-stream-think-sweep;position:absolute;left:0}@keyframes I17U7q_dsh-smooth-stream-think-sweep{0%{left:-300px}90%,to{left:100%}}.I17U7q_thinkLeading{flex-shrink:0}.I17U7q_thinkChevron{color:var(--dsw-alias-label-secondary)}.I17U7q_thinkTitle{font-weight:400}.I17U7q_thinkSeparator{background:var(--dsw-alias-label-caption);border-radius:1px;flex:none;width:2px;height:2px;margin:0 8px}.I17U7q_thinkSummary{min-width:0;color:var(--dsw-alias-label-tertiary);text-overflow:ellipsis;white-space:nowrap;flex:auto;font-size:14px;line-height:24px;overflow:hidden}.I17U7q_thinkSummary[data-follow-end]{text-overflow:clip}.I17U7q_thinkBody{color:var(--dsw-alias-label-tertiary);white-space:pre-wrap;word-break:break-word;padding:4px 0 4px 22px;font-size:14px;line-height:24px}.I17U7q_disclosureRoot{flex-direction:column;width:100%;min-width:0;display:flex}.I17U7q_disclosureRow{cursor:pointer;align-items:center;min-width:0;height:24px;display:flex;position:relative;overflow:hidden}.I17U7q_disclosureLeading{width:16px;height:16px;color:var(--dsw-alias-label-tertiary);flex:none;justify-content:center;align-items:center;margin-right:6px;display:inline-flex;position:relative}.I17U7q_disclosureIconIdle{opacity:1;transition:opacity .1s;display:inline-flex}.I17U7q_disclosureChevronHover{opacity:0;margin:auto;transition:opacity .1s;position:absolute;inset:0}.I17U7q_disclosureRow:hover .I17U7q_disclosureIconIdle{opacity:0}.I17U7q_disclosureRow:hover .I17U7q_disclosureChevronHover{opacity:1}.I17U7q_disclosureTitle{color:var(--dsw-alias-label-secondary);flex:none;font-size:14px;line-height:24px}.I17U7q_disclosureContent{visibility:visible;transition:grid-template-rows var(--ds-transition-duration,.2s) var(--ds-ease-in-out,cubic-bezier(.4, 0, .2, 1)), visibility 0s;grid-template-rows:1fr;display:grid}.I17U7q_disclosureContent[data-collapsed]{visibility:hidden;transition:grid-template-rows var(--ds-transition-duration,.2s) var(--ds-ease-in-out,cubic-bezier(.4, 0, .2, 1)), visibility 0s var(--ds-transition-duration,.2s);grid-template-rows:0fr}.I17U7q_disclosureContent>*{min-height:0;overflow:hidden}@media (prefers-reduced-motion:reduce){.I17U7q_think[data-state=running] .I17U7q_thinkRow:after{animation:none}.I17U7q_disclosureContent,.I17U7q_disclosureContent[data-collapsed]{transition:none}}.I17U7q_stopped{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-tertiary);border-radius:6px;align-self:flex-start;padding:0 6px;font-size:11px;line-height:18px}.I17U7q_visuallyHidden{clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.I17U7q_follow{min-width:0}@supports (text-box-trim:trim-both){.I17U7q_root :is(p,h1,h2,h3,h4,h5,h6,li,blockquote){text-box-trim:trim-both;text-box-edge:text}}";
+		const css$1 = ".I17U7q_root{min-width:0;color:var(--dsw-alias-label-primary);flex-direction:column;font-size:16px;line-height:28px;display:flex}.I17U7q_body{flex-direction:column;gap:16px;min-width:0;display:flex}.I17U7q_think{flex-direction:column;display:flex}.I17U7q_thinkRow{position:relative;overflow:hidden}.I17U7q_think[data-state=running] .I17U7q_thinkRow:after{content:\"\";inset-block:0;background:linear-gradient(90deg, transparent 0%, color-mix(in srgb, var(--dsw-alias-bg-base) 60%, transparent) 55%, transparent 100%);pointer-events:none;width:300px;animation:2.6s ease-out infinite I17U7q_dsh-smooth-stream-think-sweep;position:absolute;left:0}@keyframes I17U7q_dsh-smooth-stream-think-sweep{0%{left:-300px}90%,to{left:100%}}.I17U7q_thinkLeading{flex-shrink:0}.I17U7q_thinkChevron{color:var(--dsw-alias-label-secondary)}.I17U7q_thinkTitle{font-weight:400}.I17U7q_thinkSeparator{background:var(--dsw-alias-label-caption);border-radius:1px;flex:none;width:2px;height:2px;margin:0 8px}.I17U7q_thinkSummary{min-width:0;color:var(--dsw-alias-label-tertiary);text-overflow:ellipsis;white-space:nowrap;flex:auto;font-size:14px;line-height:24px;overflow:hidden}.I17U7q_thinkSummary[data-follow-end]{text-overflow:clip}.I17U7q_thinkBody{color:var(--dsw-alias-label-tertiary);white-space:pre-wrap;word-break:break-word;padding:4px 0 4px 22px;font-size:14px;line-height:24px}.I17U7q_disclosureRoot{flex-direction:column;width:100%;min-width:0;display:flex}.I17U7q_disclosureRow{cursor:pointer;align-items:center;min-width:0;height:24px;display:flex;position:relative;overflow:hidden}.I17U7q_disclosureLeading{width:16px;height:16px;color:var(--dsw-alias-label-tertiary);flex:none;justify-content:center;align-items:center;margin-right:6px;display:inline-flex;position:relative}.I17U7q_disclosureIconIdle{opacity:1;transition:opacity .1s;display:inline-flex}.I17U7q_disclosureChevronHover{opacity:0;margin:auto;transition:opacity .1s;position:absolute;inset:0}.I17U7q_disclosureRow:hover .I17U7q_disclosureIconIdle{opacity:0}.I17U7q_disclosureRow:hover .I17U7q_disclosureChevronHover{opacity:1}.I17U7q_disclosureTitle{color:var(--dsw-alias-label-secondary);flex:none;font-size:14px;line-height:24px}.I17U7q_disclosureContent{visibility:visible;transition:grid-template-rows var(--ds-transition-duration,.2s) var(--ds-ease-in-out,cubic-bezier(.4, 0, .2, 1)), visibility 0s;grid-template-rows:1fr;display:grid}.I17U7q_disclosureContent[data-collapsed]{visibility:hidden;transition:grid-template-rows var(--ds-transition-duration,.2s) var(--ds-ease-in-out,cubic-bezier(.4, 0, .2, 1)), visibility 0s var(--ds-transition-duration,.2s);grid-template-rows:0fr}.I17U7q_disclosureContent>*{min-height:0;overflow:hidden}@media (prefers-reduced-motion:reduce){.I17U7q_think[data-state=running] .I17U7q_thinkRow:after{animation:none}.I17U7q_disclosureContent,.I17U7q_disclosureContent[data-collapsed]{transition:none}}.I17U7q_stopped{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-tertiary);border-radius:6px;align-self:flex-start;padding:0 6px;font-size:11px;line-height:18px}.I17U7q_visuallyHidden{clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.I17U7q_follow{contain:layout style;min-width:0}@supports (text-box-trim:trim-both){.I17U7q_root :is(p,h1,h2,h3,h4,h5,h6,li,blockquote){text-box-trim:trim-both;text-box-edge:text}}";
 		const tagId$1 = "dsh-smooth-stream/TypewriterAssistantNodeView.module.css";
 		if (typeof document !== "undefined") {
 			let tag = document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$1) + "]");
@@ -23,27 +23,27 @@ window.__ModuleLoader__.load({
 			tag.textContent = css$1;
 		}
 		var TypewriterAssistantNodeView_module_css_default = {
+			"disclosureRoot": "I17U7q_disclosureRoot",
 			"root": "I17U7q_root",
-			"dsh-smooth-stream-think-sweep": "I17U7q_dsh-smooth-stream-think-sweep",
+			"thinkRow": "I17U7q_thinkRow",
+			"thinkChevron": "I17U7q_thinkChevron",
+			"disclosureRow": "I17U7q_disclosureRow",
 			"disclosureLeading": "I17U7q_disclosureLeading",
+			"dsh-smooth-stream-think-sweep": "I17U7q_dsh-smooth-stream-think-sweep",
+			"disclosureTitle": "I17U7q_disclosureTitle",
+			"disclosureIconIdle": "I17U7q_disclosureIconIdle",
+			"thinkSeparator": "I17U7q_thinkSeparator",
+			"thinkSummary": "I17U7q_thinkSummary",
+			"follow": "I17U7q_follow",
+			"thinkTitle": "I17U7q_thinkTitle",
+			"disclosureContent": "I17U7q_disclosureContent",
 			"thinkBody": "I17U7q_thinkBody",
+			"thinkLeading": "I17U7q_thinkLeading",
 			"disclosureChevronHover": "I17U7q_disclosureChevronHover",
-			"disclosureContent": "I17U7q_disclosureContent",
 			"stopped": "I17U7q_stopped",
-			"thinkTitle": "I17U7q_thinkTitle",
-			"thinkSeparator": "I17U7q_thinkSeparator",
-			"think": "I17U7q_think",
-			"disclosureTitle": "I17U7q_disclosureTitle",
-			"disclosureRoot": "I17U7q_disclosureRoot",
 			"visuallyHidden": "I17U7q_visuallyHidden",
-			"thinkChevron": "I17U7q_thinkChevron",
-			"follow": "I17U7q_follow",
-			"disclosureIconIdle": "I17U7q_disclosureIconIdle",
 			"body": "I17U7q_body",
-			"thinkSummary": "I17U7q_thinkSummary",
-			"disclosureRow": "I17U7q_disclosureRow",
-			"thinkLeading": "I17U7q_thinkLeading",
-			"thinkRow": "I17U7q_thinkRow"
+			"think": "I17U7q_think"
 		};
 		//#endregion
 		//#region src/client/AnimatedDisclosure.tsx
@@ -123,7 +123,6 @@ window.__ModuleLoader__.load({
 				maxActiveCps: 360,
 				maxCps: 240,
 				maxFlushCps: 480,
-				minCommitIntervalMs: 16,
 				minCps: 24,
 				settleAfterMs: 280,
 				settleDrainMaxMs: 420,
@@ -139,7 +138,6 @@ window.__ModuleLoader__.load({
 				maxActiveCps: 480,
 				maxCps: 320,
 				maxFlushCps: 640,
-				minCommitIntervalMs: 16,
 				minCps: 32,
 				settleAfterMs: 200,
 				settleDrainMaxMs: 280,
@@ -155,7 +153,6 @@ window.__ModuleLoader__.load({
 				maxActiveCps: 280,
 				maxCps: 180,
 				maxFlushCps: 400,
-				minCommitIntervalMs: 16,
 				minCps: 20,
 				settleAfterMs: 360,
 				settleDrainMaxMs: 520,
@@ -163,23 +160,28 @@ window.__ModuleLoader__.load({
 				targetBufferMs: 56
 			}
 		};
-		const MAX_COMMIT_INTERVAL_MS = 16;
-		const QUEUE_FRAME_MS = 16.67;
+		const QUEUE_ACCEL_EXPONENT = 1.25;
+		const QUEUE_PRESSURE_FACTOR = .85;
 		const CATCHUP_SECONDS = .15;
-		const clamp$1 = (value, min, max) => {
+		const clamp = (value, min, max) => {
 			return Math.min(max, Math.max(min, value));
 		};
-		/**
-		* Demo per-frame reveal: drain `backlog / 8` characters, at least 1, scaled
-		* by frame time. A small queue types one glyph per frame; a burst raises the
-		* step so the display does not fall behind.
-		* @param backlog - Unrevealed characters.
-		* @param dtMs - Frame delta in ms.
-		* @returns Characters to reveal this frame.
-		*/
-		function computeQueueReveal(backlog, dtMs) {
-			if (backlog <= 0 || dtMs <= 0) return 0;
-			return Math.min(backlog, Math.max(1, Math.ceil(backlog / 8 * (dtMs / QUEUE_FRAME_MS))));
+		/** Float-debt queue integration from `ultimate_stream_physics_scroller.html`. */
+		function computeAdaptiveQueueStep(backlog, dtMs, debt, revealScale = 1) {
+			if (backlog <= 0 || dtMs <= 0) return {
+				revealChars: 0,
+				debt: 0,
+				speedCps: 0
+			};
+			const speedCps = Math.min(600, 90 + Math.pow(backlog, QUEUE_ACCEL_EXPONENT) * QUEUE_PRESSURE_FACTOR);
+			const effectiveScale = clamp(revealScale, .05, 1);
+			const accumulated = Math.max(0, debt) + speedCps * effectiveScale * (dtMs / 1e3);
+			const revealChars = Math.min(backlog, Math.floor(accumulated));
+			return {
+				revealChars,
+				debt: revealChars >= backlog ? 0 : accumulated - revealChars,
+				speedCps
+			};
 		}
 		/** Counts user-perceived characters (code points), not UTF-16 units. */
 		const countChars = (text) => {
@@ -191,9 +193,20 @@ window.__ModuleLoader__.load({
 		function computeSettleDrain(config, input) {
 			if (input.inputActive || !input.settling) return 0;
 			const overflowCps = Math.max(0, input.backlog - 300) * 1e3 / 2;
-			const drainTargetMs = clamp$1(input.backlog * 8, config.settleDrainMinMs, config.settleDrainMaxMs);
+			const drainTargetMs = clamp(input.backlog * 8, config.settleDrainMinMs, config.settleDrainMaxMs);
 			const settleCps = input.backlog * 1e3 / drainTargetMs;
-			return clamp$1(Math.max(settleCps, overflowCps), config.flushCps, config.maxFlushCps);
+			return clamp(Math.max(settleCps, overflowCps), config.flushCps, config.maxFlushCps);
+		}
+		/** Fixed velocity that closes a producer-complete queue within its deadline. */
+		function computeCompletionDrain(config, backlog) {
+			if (backlog <= 0) return 0;
+			const drainTargetMs = clamp(backlog * 8, config.settleDrainMinMs, config.settleDrainMaxMs);
+			const deadlineCps = backlog * 1e3 / drainTargetMs;
+			return Math.max(deadlineCps, computeSettleDrain(config, {
+				backlog,
+				inputActive: false,
+				settling: true
+			}));
 		}
 		/**
 		* Drain rate multiplier once the input ends: leftover backlog reveals at
@@ -202,16 +215,20 @@ window.__ModuleLoader__.load({
 		const SETTLE_DRAIN_MULTIPLIER = 1.8;
 		/** Pure per-frame reveal decision shared by the loop and its tests. */
 		function computeRevealStep(config, input, dtSeconds) {
-			const baseCps = clamp$1(Math.max(input.emaCps, input.arrivalCpsEma), config.minCps, config.maxFlushCps);
+			const trackedCps = Math.max(input.emaCps, input.arrivalCpsEma);
+			const baseCps = clamp(trackedCps, config.minCps, config.maxFlushCps);
 			const targetLagChars = input.inputActive ? Math.max(2, Math.round(baseCps * config.targetBufferMs / 1e3)) : 0;
 			let currentCps;
-			if (input.steadyCps !== void 0) currentCps = input.inputActive || input.settling ? clamp$1(input.steadyCps * (input.inputActive ? 1 : SETTLE_DRAIN_MULTIPLIER), config.minCps, config.maxFlushCps) : 0;
+			if (input.steadyCps !== void 0) currentCps = input.inputActive || input.settling ? clamp(input.steadyCps * (input.inputActive ? 1 : SETTLE_DRAIN_MULTIPLIER), config.minCps, config.maxFlushCps) : 0;
 			else if (input.inputActive) {
 				const overflow = Math.max(0, input.backlog - 32);
 				const catchup = overflow > 0 ? overflow / CATCHUP_SECONDS : 0;
-				currentCps = clamp$1(baseCps * 1.08 + catchup, config.minCps, config.maxFlushCps);
+				currentCps = clamp(baseCps * 1.08 + catchup, config.minCps, config.maxFlushCps);
 			} else if (input.settling) currentCps = computeSettleDrain(config, input);
-			else currentCps = clamp$1(Math.max(config.flushCps, baseCps * 1.8, input.arrivalCpsEma * .8), config.flushCps, config.maxFlushCps);
+			else {
+				const idleFlushCps = Math.max(config.flushCps, baseCps * 1.8, input.arrivalCpsEma * .8);
+				currentCps = clamp(idleFlushCps, config.flushCps, config.maxFlushCps);
+			}
 			const minRevealChars = input.inputActive ? 1 : 2;
 			return {
 				revealChars: Math.max(minRevealChars, Math.round(currentCps * dtSeconds)),
@@ -225,35 +242,35 @@ window.__ModuleLoader__.load({
 		* @param options - Preset, guard, and steady-rate wiring.
 		* @returns The displayed content, revealed at the smoothed cadence.
 		*/
-		function useSmoothStreamContent(content, { enabled = true, preset = "balanced", shouldHoldBack, steadyCps, defaultCps, speedCpsRef } = {}) {
+		function useSmoothStreamContent(content, { enabled = true, inputComplete = false, preset = "balanced", shouldHoldBack, steadyCps, defaultCps, speedCpsRef, revealScaleRef } = {}) {
 			const config = PRESET_CONFIG[preset];
 			const seedCps = defaultCps ?? config.defaultCps;
-			const [displayedContent, setDisplayedContent] = (0, react.useState)(content);
-			const displayedContentRef = (0, react.useRef)(content);
-			const displayedCountRef = (0, react.useRef)(countChars(content));
-			const targetContentRef = (0, react.useRef)(content);
-			const targetCharsRef = (0, react.useRef)([...content]);
-			const targetCountRef = (0, react.useRef)(countChars(content));
+			const initialContent = enabled ? "" : content;
+			const [displayedContent, setDisplayedContent] = (0, react.useState)(initialContent);
+			const displayedContentRef = (0, react.useRef)(initialContent);
+			const displayedCountRef = (0, react.useRef)(countChars(initialContent));
+			const targetContentRef = (0, react.useRef)(initialContent);
+			const targetCharsRef = (0, react.useRef)([...initialContent]);
+			const targetCountRef = (0, react.useRef)(countChars(initialContent));
 			const emaCpsRef = (0, react.useRef)(seedCps);
 			const lastInputTsRef = (0, react.useRef)(0);
-			const lastInputCountRef = (0, react.useRef)(countChars(content));
+			const lastInputCountRef = (0, react.useRef)(countChars(initialContent));
 			const chunkSizeEmaRef = (0, react.useRef)(1);
 			const arrivalCpsEmaRef = (0, react.useRef)(seedCps);
 			const rafRef = (0, react.useRef)(null);
 			const lastFrameTsRef = (0, react.useRef)(null);
-			const wakeTimerRef = (0, react.useRef)(null);
+			const queueDebtRef = (0, react.useRef)(0);
+			const settleCpsRef = (0, react.useRef)(null);
 			const holdBackRef = (0, react.useRef)(shouldHoldBack);
 			const speedOutRef = (0, react.useRef)(speedCpsRef);
 			speedOutRef.current = speedCpsRef;
+			const revealScaleOutRef = (0, react.useRef)(revealScaleRef);
+			revealScaleOutRef.current = revealScaleRef;
+			const inputCompleteRef = (0, react.useRef)(inputComplete);
+			inputCompleteRef.current = inputComplete;
 			(0, react.useEffect)(() => {
 				holdBackRef.current = shouldHoldBack;
 			}, [shouldHoldBack]);
-			const clearWakeTimer = (0, react.useCallback)(() => {
-				if (wakeTimerRef.current !== null) {
-					clearTimeout(wakeTimerRef.current);
-					wakeTimerRef.current = null;
-				}
-			}, []);
 			const stopFrameLoop = (0, react.useCallback)(() => {
 				if (rafRef.current !== null) {
 					cancelAnimationFrame(rafRef.current);
@@ -261,20 +278,9 @@ window.__ModuleLoader__.load({
 				}
 				lastFrameTsRef.current = null;
 			}, []);
-			const stopScheduling = (0, react.useCallback)(() => {
-				stopFrameLoop();
-				clearWakeTimer();
-			}, [clearWakeTimer, stopFrameLoop]);
 			const startFrameLoopRef = (0, react.useRef)(() => {});
-			const scheduleFrameWake = (0, react.useCallback)((delayMs) => {
-				clearWakeTimer();
-				wakeTimerRef.current = setTimeout(() => {
-					wakeTimerRef.current = null;
-					startFrameLoopRef.current();
-				}, Math.max(1, Math.ceil(delayMs)));
-			}, [clearWakeTimer]);
 			const syncImmediate = (0, react.useCallback)((nextContent) => {
-				stopScheduling();
+				stopFrameLoop();
 				const chars = [...nextContent];
 				const now = performance.now();
 				targetContentRef.current = nextContent;
@@ -282,43 +288,64 @@ window.__ModuleLoader__.load({
 				targetCountRef.current = chars.length;
 				displayedContentRef.current = nextContent;
 				displayedCountRef.current = chars.length;
+				queueDebtRef.current = 0;
+				settleCpsRef.current = null;
+				const speedOut = speedOutRef.current;
+				if (speedOut !== void 0) speedOut.current = seedCps;
 				setDisplayedContent(nextContent);
 				emaCpsRef.current = seedCps;
 				chunkSizeEmaRef.current = 1;
 				arrivalCpsEmaRef.current = seedCps;
 				lastInputTsRef.current = now;
 				lastInputCountRef.current = chars.length;
-			}, [seedCps, stopScheduling]);
+			}, [seedCps, stopFrameLoop]);
+			(0, react.useLayoutEffect)(() => {
+				if (!enabled || !inputComplete || displayedContentRef.current === content) return;
+				syncImmediate(content);
+			}, [
+				content,
+				enabled,
+				inputComplete,
+				syncImmediate
+			]);
 			const startFrameLoop = (0, react.useCallback)(() => {
-				clearWakeTimer();
 				if (rafRef.current !== null) return;
-				const tick = () => {
+				const tick = (now) => {
 					const targetCount = targetCountRef.current;
 					const displayedCount = displayedCountRef.current;
 					const backlog = targetCount - displayedCount;
 					if (backlog <= 0) {
+						queueDebtRef.current = 0;
+						settleCpsRef.current = null;
+						const speedOut = speedOutRef.current;
+						if (speedOut !== void 0) speedOut.current = seedCps;
 						stopFrameLoop();
 						return;
 					}
-					const now = performance.now();
 					if (lastFrameTsRef.current === null) {
 						lastFrameTsRef.current = now;
 						rafRef.current = requestAnimationFrame(tick);
 						return;
 					}
-					const commitIntervalMs = Math.min(MAX_COMMIT_INTERVAL_MS, config.minCommitIntervalMs);
 					const frameIntervalMs = Math.max(0, now - lastFrameTsRef.current);
-					if (frameIntervalMs < commitIntervalMs) {
-						rafRef.current = requestAnimationFrame(tick);
-						return;
-					}
 					const dtSeconds = Math.max(.001, Math.min(frameIntervalMs / 1e3, .12));
 					lastFrameTsRef.current = now;
 					const idleMs = now - lastInputTsRef.current;
-					const inputActive = idleMs <= config.activeInputWindowMs;
-					const settling = !inputActive && idleMs >= config.settleAfterMs;
+					const producerComplete = inputCompleteRef.current;
+					const inputActive = !producerComplete && idleMs <= config.activeInputWindowMs;
+					const settling = producerComplete || !inputActive && idleMs >= config.settleAfterMs;
+					if (!producerComplete) settleCpsRef.current = null;
 					let revealChars;
-					if (steadyCps !== void 0) {
+					let revealSpeedCps;
+					let nextQueueDebt = 0;
+					if (producerComplete) {
+						const settleCps = settleCpsRef.current ?? computeCompletionDrain(config, backlog);
+						settleCpsRef.current = settleCps;
+						const accumulated = Math.max(0, queueDebtRef.current) + settleCps * dtSeconds;
+						revealChars = Math.min(backlog, Math.floor(accumulated));
+						revealSpeedCps = settleCps;
+						nextQueueDebt = revealChars >= backlog ? 0 : accumulated - revealChars;
+					} else if (steadyCps !== void 0) {
 						const step = computeRevealStep(config, {
 							backlog,
 							chunkSizeEma: chunkSizeEmaRef.current,
@@ -329,15 +356,23 @@ window.__ModuleLoader__.load({
 							steadyCps
 						}, dtSeconds);
 						revealChars = Math.min(step.revealChars, backlog);
-					} else revealChars = computeQueueReveal(backlog, frameIntervalMs);
+						revealSpeedCps = frameIntervalMs > 0 ? revealChars * 1e3 / frameIntervalMs : 0;
+					} else {
+						const step = computeAdaptiveQueueStep(backlog, frameIntervalMs, queueDebtRef.current, revealScaleOutRef.current?.current ?? 1);
+						revealChars = step.revealChars;
+						revealSpeedCps = step.speedCps;
+						nextQueueDebt = step.debt;
+					}
 					if (holdBackRef.current?.() === true) {
 						rafRef.current = requestAnimationFrame(tick);
 						return;
 					}
+					queueDebtRef.current = nextQueueDebt;
 					const speedOut = speedOutRef.current;
-					if (speedOut !== void 0 && frameIntervalMs > 0) {
-						const instantCps = revealChars * 1e3 / frameIntervalMs;
-						speedOut.current = speedOut.current * .92 + instantCps * .08;
+					if (speedOut !== void 0) speedOut.current = revealSpeedCps;
+					if (revealChars <= 0) {
+						rafRef.current = requestAnimationFrame(tick);
+						return;
 					}
 					const nextCount = displayedCount + revealChars;
 					const segment = targetCharsRef.current.slice(displayedCount, nextCount).join("");
@@ -356,9 +391,7 @@ window.__ModuleLoader__.load({
 				rafRef.current = requestAnimationFrame(tick);
 			}, [
 				config,
-				scheduleFrameWake,
 				stopFrameLoop,
-				clearWakeTimer,
 				steadyCps
 			]);
 			(0, react.useEffect)(() => {
@@ -381,14 +414,16 @@ window.__ModuleLoader__.load({
 				targetContentRef.current = content;
 				targetCharsRef.current.push(...appendedChars);
 				targetCountRef.current += appendedCount;
+				settleCpsRef.current = null;
 				const hadSample = lastInputTsRef.current > 0;
 				const deltaChars = targetCountRef.current - lastInputCountRef.current;
 				const deltaMs = Math.max(1, now - lastInputTsRef.current);
 				if (hadSample && deltaChars > 0) {
-					const normalizedInstantCps = clamp$1(deltaChars * 1e3 / deltaMs, config.minCps, config.maxFlushCps * 3);
+					const instantCps = deltaChars * 1e3 / deltaMs;
+					const normalizedInstantCps = clamp(instantCps, config.minCps, config.maxFlushCps * 3);
 					const chunkEmaAlpha = .45;
-					chunkSizeEmaRef.current = chunkSizeEmaRef.current * (1 - chunkEmaAlpha) + appendedCount * chunkEmaAlpha;
-					arrivalCpsEmaRef.current = arrivalCpsEmaRef.current * (1 - chunkEmaAlpha) + normalizedInstantCps * chunkEmaAlpha;
+					chunkSizeEmaRef.current = chunkSizeEmaRef.current * .55 + appendedCount * chunkEmaAlpha;
+					arrivalCpsEmaRef.current = arrivalCpsEmaRef.current * .55 + normalizedInstantCps * chunkEmaAlpha;
 					emaCpsRef.current = emaCpsRef.current * (1 - config.emaAlpha) + normalizedInstantCps * config.emaAlpha;
 				}
 				lastInputTsRef.current = now;
@@ -403,9 +438,9 @@ window.__ModuleLoader__.load({
 			]);
 			(0, react.useEffect)(() => {
 				return () => {
-					stopScheduling();
+					stopFrameLoop();
 				};
-			}, [stopScheduling]);
+			}, [stopFrameLoop]);
 			return displayedContent;
 		}
 		//#endregion
@@ -488,268 +523,465 @@ window.__ModuleLoader__.load({
 		/**
 		* Conversation-port follow while an assistant reply streams.
 		*
-		* The demo's damped-spring lerp is driven from a float `animatedH` — the
-		* smoothed content height — never from the rounded `scrollTop` the browser
-		* reports back. A wrap raises the content height by a line; if the engine
-		* were allowed to snap `scrollTop` to the new floor, the previous line would
-		* hop up in one frame. This overlay:
+		* A sub-stepped spring physics engine drives a float `animatedH`, rather
+		* than restarting native smooth-scroll animations as every glyph lands.
+		* Remaining lag rides a small compositor transform while the real scrollport
+		* stays at its floor. The transform is bounded by the measured paint gap
+		* before conversation chrome. This follower:
 		*
-		* - owns follow via `data-follow-owned` so ChatView does not snap;
+		* - marks programmatic writes via `data-follow-owned` for compatible hosts;
 		* - sets `overflow-anchor: none` so CSS scroll-anchoring does not snap;
 		* - restores `animatedH` in a ResizeObserver (before paint) so a layout
 		*   pass cannot flash a snapped frame;
-		* - while the port has scroll room, writes the interpolated lag as
-		*   `translate3d` on `[data-chat-transcript]` (message rows only), so the
-		*   turn-status chrome stays pinned at the floor;
-		* - before the port has scroll room (content shorter than the viewport), the
-		*   same lag is a content-height lag written as a negative translate on
-		*   `[data-chat-turn-status]`, so the status label descends smoothly with
-		*   each wrap instead of hopping a line at a time.
+		* - expresses safe lag as a compositor transform on message rows;
+		* - opens a speed-adaptive layout runway before fast output wraps, preserving
+		*   the reference spring constants at every reveal speed;
+		* - catches up any lag that cannot fit before turn status / composer chrome,
+		*   so fixed chrome never has to counter-shift and the host stays at-bottom;
+		* - never clips or overlays streamed text.
 		*
-		* Handing the port back to the reader (unpin, or the owner going inactive)
-		* first writes the effective visual top (`engine - lag`) into `scrollTop`
-		* before clearing the transform, so the frame stays continuous. That write
-		* also lands in ChatView's observed-top ledger as reader input beyond
-		* `FOLLOW_THRESHOLD`, releasing its native snap-follow instead of fighting
-		* the gesture for the port.
+		* A real reader gesture receives the effective visual position before the
+		* transform clears. Lifecycle completion instead settles at the floor.
 		*
-		* Unpin is a real gesture (wheel / touch / pointer / key) that leaves the
-		* floor; a `scrollTop` delta from our own write must not release the pin.
+		* Directional wheel/touch intent unpins immediately; pointer/key input falls
+		* back to an upward scroll delta from the engine's own written position. A
+		* reader release re-acquires only after returning to the real floor.
 		*/
 		/**
-		* Matches ChatView's `FOLLOW_OWNED_ATTR`. The overlay writes the last
-		* programmatic `scrollTop` here so ChatView yields snap-follow and does not
-		* treat the write as reader input.
+		* Programmatic follow marker retained for hosts that recognize external
+		* scroll ownership. Current Harness also sees the write land at the floor.
 		*/
 		const FOLLOW_OWNED_ATTR = "data-follow-owned";
-		/** Floor / ceiling of the per-frame lerp fraction before the dt term. */
-		const FOLLOW_LERP_MIN = .05;
-		const FOLLOW_LERP_MAX = .25;
-		const FOLLOW_SPEED_FACTOR_MIN = .7;
-		const FOLLOW_SPEED_FACTOR_MAX = 2.2;
+		/** Sub-pixel settle threshold; clearing below this cannot produce a visible rebound. */
+		const FOLLOW_SETTLE_EPSILON_PX = .25;
+		/** Lowest reveal rate retained while the spring is short on paint room. */
+		const FOLLOW_REVEAL_MIN_SCALE = .55;
+		/** Safe-lag occupancy band over which reveal pressure is progressively reduced. */
+		const FOLLOW_BACKPRESSURE_START_RATIO = .25;
 		const GESTURE_EVENTS = [
 			"wheel",
+			"touchstart",
 			"touchmove",
+			"touchend",
+			"touchcancel",
 			"pointerdown",
 			"keydown"
 		];
-		function clamp(value, min, max) {
-			return Math.min(max, Math.max(min, value));
+		/** Visible runway needed for the current reveal pressure. */
+		function computeFollowReserve(speedCps, runwayPx = 48) {
+			const available = Math.max(0, runwayPx);
+			if (available <= 0) return 0;
+			if (speedCps <= 90) return 0;
+			const normalized = Math.min(1, Math.max(0, (speedCps - 90) / 510));
+			const minimum = Math.min(available, 16);
+			return minimum + normalized * (available - minimum);
+		}
+		/**
+		* Reveal-rate multiplier needed to retain one-wrap headroom for the spring.
+		* Throttling starts only after a quarter of the safe transform is occupied;
+		* a constrained paint lands at the minimum immediately so the next reveal
+		* commit cannot keep feeding an already-full visual buffer.
+		*/
+		function computeFollowRevealScale(lagPx, capacityPx, constrained = false) {
+			if (constrained) return FOLLOW_REVEAL_MIN_SCALE;
+			if (!Number.isFinite(capacityPx)) return 1;
+			if (capacityPx <= 0) return lagPx > 0 ? FOLLOW_REVEAL_MIN_SCALE : 1;
+			const ratio = Math.min(1, Math.max(0, lagPx / capacityPx));
+			if (ratio >= .75) return FOLLOW_REVEAL_MIN_SCALE;
+			const progress = Math.min(1, Math.max(0, (ratio - FOLLOW_BACKPRESSURE_START_RATIO) / .5));
+			return 1 - .44999999999999996 * (progress * progress * (3 - 2 * progress));
 		}
 		/**
-		* One spring-lerp frame from the silky markdown demo.
+		* Semi-implicit spring integration with four substeps per <=32ms slice.
 		* @param dtMs - Frame delta in ms.
-		* @param input - Current lag (from the float top, not the rounded engine top) and reveal-speed EMA.
-		* @returns The fractional advance and the lerp fraction.
+		* @param input - Current visible lag and carried physics velocity.
+		* @returns The position advance, its fraction, and next velocity.
 		*/
 		function computeFollowStep(dtMs, input) {
 			if (input.lag <= .1 || dtMs <= 0) return {
 				advancePx: 0,
-				lerpStep: 0
+				lerpStep: 0,
+				velocityPxPerSec: 0
 			};
-			const speedFactor = clamp((input.speedEma > 0 ? input.speedEma : 35) / 35, FOLLOW_SPEED_FACTOR_MIN, FOLLOW_SPEED_FACTOR_MAX);
-			const lerpStep = clamp(input.lag / 160 * speedFactor, FOLLOW_LERP_MIN, FOLLOW_LERP_MAX) * (1 - Math.exp(-dtMs / 18));
+			let lag = input.lag;
+			let velocity = Math.max(0, input.velocityPxPerSec ?? 0);
+			const elapsedMs = Math.min(32, dtMs);
+			const slices = Math.max(1, Math.ceil(elapsedMs / 32));
+			const subDt = elapsedMs / 1e3 / slices / 4;
+			for (let slice = 0; slice < slices; slice += 1) for (let substep = 0; substep < 4; substep += 1) {
+				const acceleration = (130 * lag - 24 * velocity) / 1;
+				velocity = Math.max(0, velocity + acceleration * subDt);
+				const advance = velocity * subDt;
+				if (advance >= lag) return {
+					advancePx: input.lag,
+					lerpStep: 1,
+					velocityPxPerSec: 0
+				};
+				lag -= advance;
+			}
+			const advancePx = input.lag - lag;
 			return {
-				advancePx: input.lag * lerpStep,
-				lerpStep
+				advancePx,
+				lerpStep: advancePx / input.lag,
+				velocityPxPerSec: velocity
 			};
 		}
-		/** The message-rows box the lag transform rides on, when the host has one. */
-		function shiftRootOf(port) {
-			return port.querySelector("[data-chat-transcript]");
-		}
-		/**
-		* Row wrappers that carry only messages/tools. Hosts without a transcript
-		* box keep the turn-status chrome as a sibling of the rows inside
-		* `[data-chat-flow]`, so shifting that whole flow would drag the chrome
-		* along; shifting the rows individually leaves every non-message sibling
-		* (turn status, steering bubbles) pinned while the text glides.
-		*
-		* Only the outermost rows are shifted: a tool call nests its subcalls as
-		* descendant `[data-chat-anchor-key]` rows, and writing the lag on each of
-		* them would double (or further multiply) the shift, tearing the subcalls
-		* away from their parent every frame. Descendants ride the parent's
-		* transform instead.
-		*/
-		function shiftRowsOf(port) {
-			return [...port.querySelectorAll("[data-chat-anchor-key]")].filter((row) => row.parentElement?.closest("[data-chat-anchor-key]") === null);
-		}
 		/** Element whose resize signals flow growth for the before-paint restore. */
 		function resizeProxyOf(port) {
 			return port.querySelector("[data-chat-transcript]") ?? port.querySelector("[data-chat-flow]");
 		}
-		/** True when the glide expresses its lag as transforms instead of engine top. */
-		function hasShiftSurface(port) {
-			return shiftRootOf(port) !== null || shiftRowsOf(port).length > 0;
+		/** Outermost message surfaces; nested tool rows ride their parent. */
+		function shiftSurfacesOf(port) {
+			const transcript = port.querySelector("[data-chat-transcript]");
+			if (transcript !== null) return [transcript];
+			return [...port.querySelectorAll("[data-chat-anchor-key]")].filter((row) => row.parentElement?.closest("[data-chat-anchor-key]") === null);
+		}
+		function currentShiftOf(element) {
+			return Number(/translate3d\(0(?:px)?,\s*(-?[\d.]+)px,\s*0(?:px)?\)/.exec(element.style.transform)?.[1] ?? 0);
 		}
-		function setShift(element, px, negative = false) {
-			const value = negative ? -px : px;
-			if (Math.abs(value) > .01) {
-				element.style.transform = `translate3d(0, ${value}px, 0)`;
+		function setShift(element, px) {
+			if (Math.abs(px) > .01) {
+				if (Math.abs(currentShiftOf(element) - px) <= .01 && element.style.willChange === "transform" && element.style.clipPath === "") return;
+				element.style.transform = `translate3d(0, ${px}px, 0)`;
 				element.style.willChange = "transform";
 			} else {
+				if (element.style.transform === "" && element.style.willChange === "" && element.style.clipPath === "") return;
 				element.style.transform = "";
 				element.style.willChange = "";
 			}
+			element.style.clipPath = "";
+		}
+		function turnStatusOf(port) {
+			return port.querySelector("[data-chat-turn-status], [data-chat-flow] > [role=\"status\"]");
+		}
+		/** Height committed by one newly mounted Chat row, including its flex gap. */
+		function entranceExtentOf(root) {
+			const row = root.closest("[data-chat-flow-key]") ?? root;
+			const rect = row.getBoundingClientRect();
+			const height = Math.max(0, rect.height, rect.bottom - rect.top, row.offsetHeight);
+			let previous = row.previousElementSibling;
+			while (previous instanceof HTMLElement) {
+				const previousRect = previous.getBoundingClientRect();
+				if (previousRect.height > 0 || previousRect.bottom > previousRect.top) return Math.max(height, rect.bottom - previousRect.bottom);
+				previous = previous.previousElementSibling;
+			}
+			return height;
+		}
+		const followRunways = /* @__PURE__ */ new WeakMap();
+		const followPaintLimits = /* @__PURE__ */ new WeakMap();
+		function invalidatePaintLimit(port) {
+			followPaintLimits.delete(port);
+		}
+		/** Logical position and velocity survive a React owner handoff and finish. */
+		const followMotionStates = /* @__PURE__ */ new WeakMap();
+		function restoreRunway(port) {
+			const runway = followRunways.get(port);
+			if (runway === void 0) return;
+			runway.element.style[runway.property] = runway.original;
+			followRunways.delete(port);
+			invalidatePaintLimit(port);
+		}
+		function ensureRunway(port, surfaces) {
+			const status = turnStatusOf(port);
+			const composer = port.querySelector("[data-composer-seat]");
+			const target = status === null ? {
+				element: composer === null ? void 0 : surfaces.at(-1),
+				property: "marginBottom"
+			} : {
+				element: status,
+				property: "marginTop"
+			};
+			if (target.element === void 0) {
+				restoreRunway(port);
+				return;
+			}
+			const element = target.element;
+			const current = followRunways.get(port);
+			if (current?.element === element && current.property === target.property) return;
+			restoreRunway(port);
+			const beforeHeight = port.scrollHeight;
+			const original = element.style[target.property];
+			element.style[target.property] = original === "" ? `48px` : `calc(${original} + 48px)`;
+			const offset = Math.max(0, port.scrollHeight - beforeHeight);
+			followRunways.set(port, {
+				element,
+				offset,
+				property: target.property,
+				original
+			});
+			invalidatePaintLimit(port);
+		}
+		function runwayOffsetOf(port) {
+			return followRunways.get(port)?.offset ?? 0;
+		}
+		/** Available paint room below the last message before fixed conversation chrome. */
+		function safeShiftLimit(port, surfaces) {
+			const last = surfaces.at(-1);
+			if (last === void 0) return 0;
+			const status = turnStatusOf(port);
+			const composer = port.querySelector("[data-composer-seat]");
+			const cached = followPaintLimits.get(port);
+			if (cached !== void 0 && performance.now() - cached.measuredAtMs <= 250 && cached.clientHeight === port.clientHeight && cached.surface === last && cached.status === status && cached.composer === composer) return cached.limit;
+			const ceiling = [status, composer].filter((element) => element !== null).map((element) => ({
+				element,
+				rect: element.getBoundingClientRect()
+			})).filter(({ rect }) => Number.isFinite(rect.top) && Number.isFinite(rect.bottom) && rect.bottom > rect.top).sort((first, second) => first.rect.top - second.rect.top)[0];
+			if (ceiling === void 0) return status === null && composer === null ? Number.POSITIVE_INFINITY : runwayOffsetOf(port);
+			const ceilingTop = ceiling.rect.top - currentShiftOf(ceiling.element);
+			const naturalBottom = last.getBoundingClientRect().bottom - currentShiftOf(last);
+			const limit = Math.max(0, ceilingTop - naturalBottom - 1);
+			followPaintLimits.set(port, {
+				clientHeight: port.clientHeight,
+				limit,
+				measuredAtMs: performance.now(),
+				composer,
+				status,
+				surface: last
+			});
+			return limit;
+		}
+		function setFollowScrollTop(port, nextTop) {
+			if (Math.abs(port.scrollTop - nextTop) > .01) port.scrollTop = nextTop;
+			followScrollLedgers.set(port, port.scrollTop);
+			const ownedTop = String(port.scrollTop);
+			if (port.getAttribute(FOLLOW_OWNED_ATTR) !== ownedTop) port.setAttribute(FOLLOW_OWNED_ATTR, ownedTop);
 		}
 		/**
-		* The running-turn label. Before the port scrolls (content shorter than the
-		* viewport) the content-height lag has no `scrollTop` room to ride, so it is
-		* expressed as a negative translate on this sibling: the label descends
-		* smoothly with each wrap instead of hopping down a line at a time.
+		* Last scrollTop this engine wrote or accepted, per port. Reader intent is a
+		* real upward delta from this ledger; a key press or touch while pinned
+		* (typing in the composer) must not release the pin, because a released pin
+		* can never re-acquire while content streams away from the reader position.
 		*/
-		function chromeShiftOf(port) {
-			return port.querySelector("[data-chat-turn-status]");
+		const followScrollLedgers = /* @__PURE__ */ new WeakMap();
+		const followActivityAt = /* @__PURE__ */ new WeakMap();
+		/** Whether this port was owned recently enough to identify a closing tail row. */
+		function hasRecentConversationFollow(port, windowMs = 250) {
+			const last = followActivityAt.get(port);
+			return last !== void 0 && performance.now() - last <= windowMs;
+		}
+		function readerScrolledUp(port) {
+			return port.scrollTop < (followScrollLedgers.get(port) ?? 0) - 8;
 		}
 		/**
-		* Render the single smoothed extent `animatedH`. Before the port scrolls
-		* (content shorter than the viewport) `animatedH` is clamped to the content
-		* height and the content-height lag rides a negative translate on the
-		* turn-status label; once the port has scroll room the engine is pinned at
-		* the floor and the lag rides `[data-chat-transcript]` (or each message row
-		* when the host has no transcript box) so the chrome stays put. Without any
-		* shift surface the engine itself carries the interpolated top.
+		* Paint a bounded visual lag and return the effective logical extent.
+		*
+		* This is the final geometry invariant, not merely an animation preference:
+		* any lag beyond the real gap to status/composer chrome is caught up in the
+		* same frame. Carrying that excess in `scrollTop` would move the transcript
+		* toward fixed chrome and also make the host expose jump-to-bottom.
 		*/
-		function applyVisual(port, animatedH) {
+		function applyVisual(port, animatedH, reservePx, velocityPxPerSec = 0) {
+			const surfaces = shiftSurfacesOf(port);
+			ensureRunway(port, surfaces);
 			const contentHeight = Math.max(0, port.scrollHeight);
+			const runwayOffset = runwayOffsetOf(port);
+			const targetHeight = Math.max(0, contentHeight - runwayOffset);
 			const floor = Math.max(0, contentHeight - port.clientHeight);
-			const extent = Math.min(contentHeight, Math.max(0, animatedH));
-			const lag = contentHeight - extent;
-			port.style.overflowAnchor = "none";
-			port.style.scrollBehavior = "auto";
-			const shiftRoot = shiftRootOf(port);
-			if (shiftRoot !== null) {
-				if (floor <= 0) {
-					port.scrollTop = 0;
-					port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
-					const chrome = chromeShiftOf(port);
-					if (chrome !== null) setShift(chrome, lag, true);
-					setShift(shiftRoot, 0);
-					return;
-				}
-				port.scrollTop = floor;
-				port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
-				setShift(shiftRoot, lag);
-				return;
-			}
-			const rows = shiftRowsOf(port);
-			if (rows.length > 0) {
-				if (floor <= 0) {
-					port.scrollTop = 0;
-					port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
-					const chrome = chromeShiftOf(port);
-					if (chrome !== null) setShift(chrome, lag, true);
-					for (const row of rows) setShift(row, 0);
-					return;
-				}
-				port.scrollTop = floor;
-				port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
-				for (const row of rows) setShift(row, lag);
-				return;
+			const extent = Math.min(targetHeight, Math.max(0, animatedH));
+			if (port.style.overflowAnchor !== "none") port.style.overflowAnchor = "none";
+			if (port.style.scrollBehavior !== "auto") port.style.scrollBehavior = "auto";
+			if (floor <= 0) {
+				setFollowScrollTop(port, 0);
+				followMotionStates.set(port, {
+					capacityPx: Number.POSITIVE_INFINITY,
+					constrained: false,
+					extent: targetHeight,
+					lagPx: 0,
+					reservePx: 0,
+					velocityPxPerSec: 0
+				});
+				for (const surface of surfaces) setShift(surface, 0);
+				const status = turnStatusOf(port);
+				if (status !== null) setShift(status, 0);
+				return targetHeight;
 			}
-			port.scrollTop = Math.min(floor, Math.max(0, extent));
-			port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
+			setFollowScrollTop(port, floor);
+			const limit = floor > 0 ? safeShiftLimit(port, surfaces) : 0;
+			const visibleReserve = Math.min(runwayOffset, Math.max(0, reservePx));
+			const baselineShift = runwayOffset - visibleReserve;
+			const requestedLag = Math.max(0, targetHeight - extent);
+			const shift = Math.min(baselineShift + requestedLag, Math.max(0, limit));
+			const effectiveLag = Math.max(0, shift - baselineShift);
+			const capacityPx = Math.max(0, limit - baselineShift);
+			const effectiveExtent = targetHeight - effectiveLag;
+			followMotionStates.set(port, {
+				capacityPx,
+				constrained: requestedLag > effectiveLag + FOLLOW_SETTLE_EPSILON_PX,
+				extent: effectiveExtent,
+				lagPx: effectiveLag,
+				reservePx: visibleReserve,
+				velocityPxPerSec
+			});
+			for (const surface of surfaces) setShift(surface, shift);
+			const status = turnStatusOf(port);
+			if (status !== null) setShift(status, 0);
+			return effectiveExtent;
 		}
-		function clearVisual(port) {
+		function clearMotion(port) {
 			port.removeAttribute(FOLLOW_OWNED_ATTR);
 			port.style.overflowAnchor = "";
 			port.style.scrollBehavior = "";
-			const shiftRoot = shiftRootOf(port);
-			if (shiftRoot !== null) {
-				shiftRoot.style.transform = "";
-				shiftRoot.style.willChange = "";
-			} else for (const row of shiftRowsOf(port)) {
-				row.style.transform = "";
-				row.style.willChange = "";
-			}
-			const chrome = chromeShiftOf(port);
-			if (chrome !== null) {
-				chrome.style.transform = "";
-				chrome.style.willChange = "";
-			}
+			for (const surface of shiftSurfacesOf(port)) setShift(surface, 0);
+			const status = turnStatusOf(port);
+			if (status !== null) setShift(status, 0);
+		}
+		function clearVisual(port) {
+			clearMotion(port);
+			restoreRunway(port);
+			followMotionStates.delete(port);
+			invalidatePaintLimit(port);
 		}
-		/** Live follow hosts per conversation port so one unmount does not clear another. */
-		const followOwners = /* @__PURE__ */ new WeakMap();
-		function acquireFollow(port) {
-			followOwners.set(port, (followOwners.get(port) ?? 0) + 1);
+		/** Keep an already-promoted surface at zero until one stable final paint lands. */
+		function holdCompositorAtRest(element) {
+			element.style.transform = "translate3d(0, 0px, 0)";
+			element.style.willChange = "transform";
+			element.style.clipPath = "";
 		}
-		function releaseFollow(port) {
-			const next = (followOwners.get(port) ?? 1) - 1;
-			if (next <= 0) {
-				followOwners.delete(port);
-				return 0;
+		/** Remove equal offsets, land on the floor, then retire the compositor quietly. */
+		function finishAtNaturalFloor(port) {
+			const surfaces = shiftSurfacesOf(port);
+			const status = turnStatusOf(port);
+			const promoted = [...surfaces, ...status === null ? [] : [status]].filter((element) => element.style.transform !== "" || element.style.willChange === "transform");
+			const promotedSet = new Set(promoted);
+			restoreRunway(port);
+			settleAtFloor(port);
+			port.removeAttribute(FOLLOW_OWNED_ATTR);
+			port.style.overflowAnchor = "";
+			port.style.scrollBehavior = "";
+			for (const surface of surfaces) if (promotedSet.has(surface)) holdCompositorAtRest(surface);
+			else setShift(surface, 0);
+			if (status !== null) {
+				if (promotedSet.has(status)) holdCompositorAtRest(status);
+				else setShift(status, 0);
 			}
-			followOwners.set(port, next);
-			return next;
+			followMotionStates.delete(port);
+			if (promoted.length === 0) return;
+			requestAnimationFrame(() => {
+				requestAnimationFrame(() => {
+					if (port.hasAttribute(FOLLOW_OWNED_ATTR)) return;
+					for (const element of promoted) if (Math.abs(currentShiftOf(element)) <= .01) setShift(element, 0);
+				});
+			});
+		}
+		function settleAtFloor(port) {
+			setFollowScrollTop(port, Math.max(0, port.scrollHeight - port.clientHeight));
 		}
+		/** Only the newest active follower may write one port's shared visual state. */
+		const followLeaders = /* @__PURE__ */ new WeakMap();
+		let followGeneration = 0;
 		/**
 		* Own the conversation scrollport's bottom-follow while `active` is true.
 		*
 		* @param rootRef - An element inside the conversation scrollport.
 		* @param active - True while the reply is still revealing.
 		* @param speedCpsRef - Live reveal-rate EMA from the smoother.
+		* @param revealScaleRef - Optional backpressure control for text reveal.
+		* @param predictive - Whether to reserve paint room ahead of growth.
+		* @param entrance - Whether the first committed row height should glide in.
+		* @param onEntranceSettled - Releases a one-shot entrance owner after catch-up.
+		* @param predictiveRef - Optional live visibility gate for predictive runway.
+		* @param entranceExtentRef - Optional measured growth delta for a generic row.
 		*/
-		function useConversationFollow(rootRef, active, speedCpsRef) {
+		function useConversationFollow(rootRef, active, speedCpsRef, revealScaleRef, predictive = true, entrance = false, onEntranceSettled, predictiveRef, entranceExtentRef) {
 			const activeRef = (0, react.useRef)(active);
+			const entranceRef = (0, react.useRef)(entrance);
+			const onEntranceSettledRef = (0, react.useRef)(onEntranceSettled);
+			entranceRef.current = entrance;
+			onEntranceSettledRef.current = onEntranceSettled;
 			(0, react.useEffect)(() => {
 				activeRef.current = active;
 			}, [active]);
-			(0, react.useEffect)(() => {
+			(0, react.useLayoutEffect)(() => {
 				if (!active) return;
+				const owner = {};
+				const generation = ++followGeneration;
 				let rafId = 0;
 				let last = performance.now();
 				let following = true;
 				let primed = false;
 				let animatedH = 0;
+				let reservePx = 0;
+				let velocityPxPerSec = 0;
 				let interacting = false;
+				let readerGestureIntent = false;
+				let readerReleased = false;
+				let touchStartY = null;
 				let interactTimer = null;
 				let port = null;
 				let resize = null;
 				let holding = null;
-				let awayPx = 0;
+				let entrancePending = entranceRef.current;
+				const finishEntrance = () => {
+					if (!entrancePending) return;
+					entrancePending = false;
+					onEntranceSettledRef.current?.();
+				};
+				const updateRevealScale = (next, elapsedMs, urgent = false) => {
+					if (revealScaleRef === void 0) return;
+					const state = followMotionStates.get(next);
+					const target = state === void 0 ? 1 : computeFollowRevealScale(state.lagPx, state.capacityPx, state.constrained);
+					const current = Math.min(1, Math.max(FOLLOW_REVEAL_MIN_SCALE, revealScaleRef.current));
+					if (target < current || urgent) {
+						revealScaleRef.current = Math.min(current, target);
+						return;
+					}
+					const releaseStep = 1 - Math.exp(-Math.max(0, elapsedMs) / 240);
+					revealScaleRef.current = current + (target - current) * releaseStep;
+				};
+				const releaseRevealScale = () => {
+					if (revealScaleRef !== void 0) revealScaleRef.current = 1;
+				};
+				const isLeader = (next) => followLeaders.get(next)?.owner === owner;
 				const hold = (next) => {
-					if (holding === next) return;
-					if (holding !== null) releaseFollow(holding);
-					acquireFollow(next);
+					followActivityAt.set(next, performance.now());
+					if (holding === next && isLeader(next)) return;
 					holding = next;
+					const leader = followLeaders.get(next);
+					if (leader === void 0 || generation > leader.generation) followLeaders.set(next, {
+						generation,
+						owner
+					});
 				};
 				const drop = (next) => {
-					if (holding === next) {
-						releaseFollow(next);
-						holding = null;
+					if (holding === next) holding = null;
+					if (isLeader(next)) {
+						clearMotion(next);
+						followMotionStates.delete(next);
+						releaseRevealScale();
 					}
-					clearVisual(next);
 				};
-				/**
-				* Give the reader the visual position the glide was showing before the
-				* transforms go away. While transforms carry the lag, the engine sits at
-				* the floor and the effective visual top is `engine - lag`; writing that
-				* keeps the handover frame-continuous, and the write shows up in
-				* ChatView's ledger as reader movement, disarming its snap-follow.
-				* Without a shift surface the engine already holds the interpolated top,
-				* so there is nothing to compensate.
-				*/
 				const handBackVisual = (next) => {
-					if (!hasShiftSurface(next)) return;
+					const shift = currentShiftOf(shiftSurfacesOf(next).at(-1) ?? next);
+					const visualTop = Math.max(0, next.scrollTop - Math.max(0, shift));
 					const floor = Math.max(0, next.scrollHeight - next.clientHeight);
-					if (floor <= 0) return;
-					const lag = Math.max(0, next.scrollHeight - animatedH);
-					next.scrollTop = Math.min(floor, Math.max(0, next.scrollTop - lag));
+					next.scrollTop = Math.min(visualTop, Math.max(0, floor - 26));
+					followScrollLedgers.set(next, next.scrollTop);
 				};
 				const markGesture = (event) => {
 					interacting = true;
-					if (event instanceof WheelEvent && event.deltaY < 0) awayPx += -event.deltaY;
-					else if (event.type === "touchmove" || event.type === "keydown") awayPx += 8;
+					if (event.type === "wheel") {
+						const deltaY = event.deltaY;
+						if (Number.isFinite(deltaY) && deltaY < 0) readerGestureIntent = true;
+					} else if (event.type === "touchstart") touchStartY = event.touches[0]?.clientY ?? null;
+					else if (event.type === "touchmove") {
+						const touch = event.touches[0];
+						if (touch !== void 0) {
+							if (touchStartY === null) touchStartY = touch.clientY;
+							if (touch.clientY - touchStartY > 1) readerGestureIntent = true;
+						}
+					} else if (event.type === "touchend" || event.type === "touchcancel") touchStartY = null;
 					if (interactTimer !== null) clearTimeout(interactTimer);
 					interactTimer = setTimeout(() => {
 						interacting = false;
+						readerGestureIntent = false;
 						interactTimer = null;
-						awayPx = 0;
 					}, 800);
 				};
 				const restoreBeforePaint = () => {
-					if (!following || port === null) return;
-					applyVisual(port, animatedH);
+					if (!following || port === null || !isLeader(port)) return;
+					invalidatePaintLimit(port);
+					animatedH = applyVisual(port, animatedH, reservePx, velocityPxPerSec);
+					updateRevealScale(port, 0, true);
 				};
 				const bindPort = (next) => {
 					if (port === next) return;
@@ -758,6 +990,7 @@ window.__ModuleLoader__.load({
 						resize?.disconnect();
 					}
 					port = next;
+					invalidatePaintLimit(port);
 					for (const name of GESTURE_EVENTS) port.addEventListener(name, markGesture, { passive: true });
 					if (typeof ResizeObserver !== "undefined") {
 						resize = new ResizeObserver(restoreBeforePaint);
@@ -768,48 +1001,96 @@ window.__ModuleLoader__.load({
 				};
 				const frame = (now) => {
 					rafId = requestAnimationFrame(frame);
-					const dt = Math.min(50, now - last);
+					const elapsedMs = Math.max(.001, now - last);
+					const dt = Math.min(32, elapsedMs);
 					last = now;
 					const root = rootRef.current;
 					if (root === null) return;
 					const nextPort = root.closest("[data-conversation-scroll]");
 					if (nextPort === null) return;
 					bindPort(nextPort);
+					if (nextPort.clientHeight <= 0) return;
 					const reportedLag = Math.max(0, nextPort.scrollHeight - nextPort.clientHeight) - nextPort.scrollTop;
 					const extent = Math.min(nextPort.scrollHeight, Math.max(0, nextPort.scrollHeight - reportedLag));
 					if (!primed) {
-						animatedH = extent;
-						following = reportedLag <= 25;
+						const inherited = nextPort.hasAttribute(FOLLOW_OWNED_ATTR) ? followMotionStates.get(nextPort) : void 0;
+						if (inherited === void 0) {
+							const entranceExtent = entrancePending ? entranceExtentRef?.current ?? entranceExtentOf(root) : 0;
+							animatedH = Math.max(0, nextPort.scrollHeight - entranceExtent);
+							reservePx = 0;
+							velocityPxPerSec = 0;
+							following = Math.max(0, reportedLag - entranceExtent) <= 25;
+						} else {
+							animatedH = Math.min(nextPort.scrollHeight, inherited.extent);
+							reservePx = inherited.reservePx;
+							velocityPxPerSec = inherited.velocityPxPerSec;
+							following = true;
+						}
 						if (following) {
 							hold(nextPort);
-							applyVisual(nextPort, animatedH);
-						}
+							if (isLeader(nextPort)) {
+								animatedH = applyVisual(nextPort, animatedH, reservePx, velocityPxPerSec);
+								updateRevealScale(nextPort, elapsedMs);
+								const runwayOffset = runwayOffsetOf(nextPort);
+								if (Math.max(0, nextPort.scrollHeight - animatedH - runwayOffset) <= .25) finishEntrance();
+							} else finishEntrance();
+						} else finishEntrance();
 						primed = true;
 						return;
 					}
-					if (!following && !interacting && reportedLag <= 25) {
+					if (!following && !interacting && reportedLag <= (readerReleased ? 1 : 25)) {
 						following = true;
+						readerReleased = false;
 						animatedH = extent;
+						reservePx = 0;
+						velocityPxPerSec = 0;
+						followScrollLedgers.set(nextPort, nextPort.scrollTop);
 						hold(nextPort);
-					} else if (following && interacting && awayPx >= 8) {
+					} else if (following && interacting && (readerGestureIntent || readerScrolledUp(nextPort))) {
 						following = false;
-						awayPx = 0;
+						readerGestureIntent = false;
+						readerReleased = true;
 						handBackVisual(nextPort);
 						animatedH = nextPort.scrollHeight;
+						reservePx = 0;
+						velocityPxPerSec = 0;
 						drop(nextPort);
+						finishEntrance();
+					}
+					if (!activeRef.current || !following) {
+						followScrollLedgers.set(nextPort, nextPort.scrollTop);
+						return;
 					}
-					if (!activeRef.current || !following) return;
 					hold(nextPort);
-					const lag = nextPort.scrollHeight - animatedH;
+					if (!isLeader(nextPort)) {
+						finishEntrance();
+						return;
+					}
+					const runwayOffset = runwayOffsetOf(nextPort);
+					const contentHeight = nextPort.scrollHeight;
+					const lag = Math.max(0, contentHeight - animatedH - runwayOffset);
+					const predictGrowth = predictiveRef?.current ?? predictive;
+					const reserveTarget = !predictGrowth ? 0 : computeFollowReserve(speedCpsRef.current, runwayOffset);
+					const reserveStep = 1 - Math.exp(-elapsedMs / 180);
+					reservePx += (reserveTarget - reservePx) * reserveStep;
 					const step = computeFollowStep(dt, {
 						lag,
-						speedEma: speedCpsRef.current
+						speedEma: speedCpsRef.current,
+						velocityPxPerSec
 					});
-					if (lag <= .1) animatedH = nextPort.scrollHeight;
-					else animatedH = Math.min(nextPort.scrollHeight, animatedH + step.advancePx);
-					applyVisual(nextPort, animatedH);
+					if (lag <= .1) {
+						animatedH = contentHeight - runwayOffset;
+						velocityPxPerSec = 0;
+					} else {
+						const minimumLag = predictGrowth ? 0 : Math.max(0, reservePx);
+						animatedH = Math.min(contentHeight - runwayOffset - minimumLag, animatedH + step.advancePx);
+						velocityPxPerSec = step.velocityPxPerSec;
+					}
+					animatedH = applyVisual(nextPort, animatedH, reservePx, velocityPxPerSec);
+					updateRevealScale(nextPort, elapsedMs);
+					if (Math.max(0, nextPort.scrollHeight - animatedH - runwayOffsetOf(nextPort)) <= .25) finishEntrance();
 				};
-				rafId = requestAnimationFrame(frame);
+				frame(performance.now());
 				return () => {
 					cancelAnimationFrame(rafId);
 					if (interactTimer !== null) clearTimeout(interactTimer);
@@ -817,26 +1098,125 @@ window.__ModuleLoader__.load({
 					if (port !== null) for (const name of GESTURE_EVENTS) port.removeEventListener(name, markGesture);
 					const host = rootRef.current?.closest("[data-conversation-scroll]") ?? port;
 					if (host === null) return;
-					if (following) handBackVisual(host);
-					const remaining = holding === host ? releaseFollow(host) : followOwners.get(host) ?? 0;
 					holding = null;
-					if (remaining === 0) clearVisual(host);
+					if (!isLeader(host)) return;
+					const preserveReader = interacting && (readerGestureIntent || readerScrolledUp(host));
+					if (!following || !primed) {
+						clearVisual(host);
+						followLeaders.delete(host);
+						releaseRevealScale();
+						return;
+					}
+					if (preserveReader) {
+						handBackVisual(host);
+						clearVisual(host);
+						followLeaders.delete(host);
+						releaseRevealScale();
+						return;
+					}
+					ensureRunway(host, shiftSurfacesOf(host));
+					const completionRunway = runwayOffsetOf(host);
+					const completionMinimumLag = Math.max(0, reservePx);
+					animatedH = Math.min(animatedH, host.scrollHeight - completionRunway - completionMinimumLag);
+					settleAtFloor(host);
+					animatedH = applyVisual(host, animatedH, reservePx, velocityPxPerSec);
+					const runwayOffset = runwayOffsetOf(host);
+					if (Math.max(0, host.scrollHeight - animatedH - runwayOffset) <= .25 && reservePx <= .25) {
+						finishAtNaturalFloor(host);
+						followLeaders.delete(host);
+						releaseRevealScale();
+						return;
+					}
+					for (const name of GESTURE_EVENTS) host.addEventListener(name, markGesture, { passive: true });
+					const stopSettleListeners = () => {
+						for (const name of GESTURE_EVENTS) host.removeEventListener(name, markGesture);
+						if (interactTimer !== null) {
+							clearTimeout(interactTimer);
+							interactTimer = null;
+						}
+					};
+					let settleLast = performance.now();
+					const settleFrame = (now) => {
+						if (!isLeader(host)) {
+							stopSettleListeners();
+							return;
+						}
+						if (interacting && (readerGestureIntent || readerScrolledUp(host))) {
+							readerGestureIntent = false;
+							handBackVisual(host);
+							clearVisual(host);
+							followLeaders.delete(host);
+							releaseRevealScale();
+							stopSettleListeners();
+							return;
+						}
+						const dt = Math.min(32, Math.max(0, now - settleLast));
+						settleLast = now;
+						const runwayOffset = runwayOffsetOf(host);
+						const lag = Math.max(0, host.scrollHeight - animatedH - runwayOffset);
+						const reserveStep = 1 - Math.exp(-dt / 180);
+						reservePx += (0 - reservePx) * reserveStep;
+						if (lag <= .25 && reservePx <= .25) {
+							animatedH = host.scrollHeight - runwayOffset;
+							reservePx = 0;
+							velocityPxPerSec = 0;
+							finishAtNaturalFloor(host);
+							followLeaders.delete(host);
+							releaseRevealScale();
+							stopSettleListeners();
+							return;
+						}
+						const step = computeFollowStep(dt, {
+							lag,
+							speedEma: speedCpsRef.current,
+							velocityPxPerSec
+						});
+						const minimumLag = Math.max(0, reservePx);
+						animatedH = Math.min(host.scrollHeight - runwayOffset - minimumLag, animatedH + step.advancePx);
+						velocityPxPerSec = step.velocityPxPerSec;
+						settleAtFloor(host);
+						animatedH = applyVisual(host, animatedH, reservePx, velocityPxPerSec);
+						requestAnimationFrame(settleFrame);
+					};
+					requestAnimationFrame(settleFrame);
 				};
 			}, [
 				active,
 				rootRef,
-				speedCpsRef
+				speedCpsRef,
+				revealScaleRef,
+				predictive,
+				predictiveRef
 			]);
 		}
 		//#endregion
 		//#region src/client/FollowHost.tsx
 		/**
 		* Document-flow host that owns conversation-port follow while `active`.
-		* Shared by assistant blocks and every other growing Chat row.
+		* Shared by assistant blocks and every other Agent Chat row. `onGrowth` lets
+		* generic wrapped renderers re-arm one glide when their DOM grows without
+		* requiring a business-kind-specific lifecycle predicate.
 		*/
-		function FollowHost({ active, speedCpsRef, children }) {
-			const rootRef = (0, react.useRef)(null);
-			useConversationFollow(rootRef, active, speedCpsRef);
+		function FollowHost({ active, entrance = false, onEntranceSettled, onGrowth, entranceExtentRef, speedCpsRef, revealScaleRef, predictive = true, predictiveRef, hostRef, children }) {
+			const localRootRef = (0, react.useRef)(null);
+			const rootRef = hostRef ?? localRootRef;
+			useConversationFollow(rootRef, active || entrance, speedCpsRef, revealScaleRef, predictive, entrance, onEntranceSettled, predictiveRef, entranceExtentRef);
+			(0, react.useEffect)(() => {
+				if (onGrowth === void 0 || typeof ResizeObserver === "undefined") return;
+				const root = rootRef.current;
+				if (root === null) return;
+				let previousHeight = null;
+				const observer = new ResizeObserver((entries) => {
+					const nextHeight = entries[0]?.contentRect.height ?? root.getBoundingClientRect().height;
+					if (!Number.isFinite(nextHeight)) return;
+					if (previousHeight !== null && nextHeight > previousHeight + .5) onGrowth(nextHeight - previousHeight);
+					previousHeight = nextHeight;
+				});
+				observer.observe(root);
+				return () => {
+					observer.disconnect();
+				};
+			}, [onGrowth]);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 				ref: rootRef,
 				className: TypewriterAssistantNodeView_module_css_default.follow,
@@ -876,6 +1256,45 @@ window.__ModuleLoader__.load({
 			}, []);
 			return reduced;
 		}
+		/** Conservative fallback before the streaming Markdown tail has geometry. */
+		const PREDICTIVE_WRAP_FALLBACK_CHARS = 32;
+		function approximateInlineWidth(text, emPx) {
+			let width = 0;
+			for (const char of text) if (/\s/u.test(char)) width += emPx * .33;
+			else if (/^[\x00-\x7f]$/u.test(char)) width += emPx * .56;
+			else width += emPx;
+			return width;
+		}
+		/** Whether buffered source can reach a new visual line before it drains. */
+		function pendingTextCanGrow(root, pending) {
+			if (pending === "") return false;
+			if (/[\r\n]/u.test(pending)) return true;
+			const pendingChars = [...pending];
+			if (root === null || typeof document.createTreeWalker !== "function" || typeof NodeFilter === "undefined") return pendingChars.length >= PREDICTIVE_WRAP_FALLBACK_CHARS;
+			const rootRect = root.getBoundingClientRect();
+			const rootWidth = Math.max(0, rootRect.width, rootRect.right - rootRect.left, root.clientWidth);
+			if (rootWidth <= 0) return pendingChars.length >= PREDICTIVE_WRAP_FALLBACK_CHARS;
+			const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+			let tail = null;
+			for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) if ((node.textContent ?? "").length > 0) tail = node;
+			const parent = tail?.parentElement ?? root;
+			const fontSize = Number.parseFloat(getComputedStyle(parent).fontSize) || 14;
+			const pendingWidth = approximateInlineWidth(pending, fontSize);
+			if (tail === null || typeof document.createRange !== "function") return pendingWidth >= rootWidth;
+			try {
+				const length = tail.textContent?.length ?? 0;
+				if (length <= 0) return pendingWidth >= rootWidth;
+				const range = document.createRange();
+				range.setStart(tail, Math.max(0, length - 1));
+				range.setEnd(tail, length);
+				const tailRect = range.getBoundingClientRect();
+				const contentRight = rootRect.right;
+				if (!Number.isFinite(tailRect.right) || tailRect.right <= rootRect.left || contentRight <= rootRect.left) return pendingWidth >= rootWidth;
+				return pendingWidth >= Math.max(0, contentRight - tailRect.right) + fontSize * .35;
+			} catch {
+				return pendingWidth >= rootWidth;
+			}
+		}
 		/**
 		* Smooth streaming text arm. While the reply runs, the accumulated source is
 		* revealed through the smoother at a rate that tracks the model's arrival
@@ -887,18 +1306,39 @@ window.__ModuleLoader__.load({
 		* drains, the settled full parse (KaTeX math, fence highlighting, file
 		* mentions) swaps in exactly once.
 		*/
-		function AnimatedMarkdownText({ text, codeLabels, fileMentions, streaming, announce, ownFollow, preset, shouldHoldBack }) {
+		function AnimatedMarkdownText({ text, codeLabels, fileMentions, streaming, announce, ownFollow, followSpeedCpsRef, followRevealScaleRef, onPredictiveChange, preset, shouldHoldBack }) {
 			const reduced = usePrefersReducedMotion();
 			const [typing, setTyping] = (0, react.useState)(streaming);
-			const speedCpsRef = (0, react.useRef)(35);
+			const localSpeedCpsRef = (0, react.useRef)(35);
+			const followRootRef = (0, react.useRef)(null);
+			const predictionSourceRef = (0, react.useRef)(null);
+			const predictionStateRef = (0, react.useRef)(false);
+			const speedCpsRef = followSpeedCpsRef ?? localSpeedCpsRef;
 			const displayed = useSmoothStreamContent(text, {
 				enabled: typing && !reduced,
+				inputComplete: !streaming,
 				preset,
 				shouldHoldBack,
-				speedCpsRef
+				speedCpsRef,
+				revealScaleRef: followRevealScaleRef
 			});
 			const shown = reduced ? text : displayed;
 			const live = typing && !reduced;
+			(0, react.useLayoutEffect)(() => {
+				if (onPredictiveChange === void 0) return;
+				const pending = text.slice(shown.length);
+				const sourceChanged = predictionSourceRef.current !== text;
+				const next = !live || !streaming || pending === "" ? false : sourceChanged ? pendingTextCanGrow(followRootRef.current, pending) : predictionStateRef.current;
+				predictionSourceRef.current = text;
+				predictionStateRef.current = next;
+				onPredictiveChange(next);
+			}, [
+				live,
+				onPredictiveChange,
+				shown,
+				streaming,
+				text
+			]);
 			(0, react.useEffect)(() => {
 				if (typing && !streaming && shown.length === text.length) setTyping(false);
 			}, [
@@ -907,24 +1347,23 @@ window.__ModuleLoader__.load({
 				text,
 				typing
 			]);
-			if (live) return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [announce && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [live && announce && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 				className: TypewriterAssistantNodeView_module_css_default.visuallyHidden,
 				"aria-live": "polite",
 				children: text
 			}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FollowHost, {
-				active: ownFollow,
+				active: live && ownFollow,
 				speedCpsRef,
+				revealScaleRef: followRevealScaleRef,
+				predictive: streaming,
+				hostRef: followRootRef,
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.MarkdownText, {
-					text: shown,
-					streaming: true,
-					codeLabels
+					text: live ? shown : text,
+					streaming: live,
+					codeLabels,
+					fileMentions: live ? void 0 : fileMentions
 				})
 			})] });
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.MarkdownText, {
-				text,
-				codeLabels,
-				fileMentions
-			});
 		}
 		function imageLabels(t) {
 			return {
@@ -957,30 +1396,32 @@ window.__ModuleLoader__.load({
 		* or the assistant node settling — not when the rest of the reply is
 		* still streaming.
 		*/
-		function AnimatedReasoning({ text, running, preset, thinkAutoExpand, shouldHoldBack, t }) {
+		function AnimatedReasoning({ text, running, preset, thinkAutoExpand, shouldHoldBack, followSpeedCpsRef, followRevealScaleRef, onExpandedChange, t }) {
 			const reduced = usePrefersReducedMotion();
 			const [expanded, setExpanded] = (0, react.useState)(running && thinkAutoExpand);
 			const summaryRef = (0, react.useRef)(null);
-			const speedCpsRef = (0, react.useRef)(35);
 			const displayed = useSmoothStreamContent(text, {
 				enabled: running && !reduced,
 				preset,
 				shouldHoldBack,
-				speedCpsRef
+				speedCpsRef: followSpeedCpsRef,
+				revealScaleRef: followRevealScaleRef
 			});
 			const shown = running && !reduced ? displayed : text;
 			const summary = running ? latestLine(shown) : firstLine(text);
-			(0, react.useEffect)(() => {
+			(0, react.useLayoutEffect)(() => {
 				if (thinkAutoExpand) setExpanded(running);
 			}, [running, thinkAutoExpand]);
+			(0, react.useLayoutEffect)(() => {
+				onExpandedChange?.(expanded);
+			}, [expanded, onExpandedChange]);
 			(0, react.useEffect)(() => {
 				const element = summaryRef.current;
 				if (element === null) return;
 				element.scrollLeft = running ? element.scrollWidth - element.clientWidth : 0;
 			}, [running, summary]);
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FollowHost, {
-				active: running,
-				speedCpsRef,
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: TypewriterAssistantNodeView_module_css_default.follow,
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 					className: TypewriterAssistantNodeView_module_css_default.think,
 					"data-variant": "think",
@@ -1021,16 +1462,33 @@ window.__ModuleLoader__.load({
 		* streaming is revealed by the smoother through the Harness Markdown
 		* renderer at a rate that tracks arrival. Reasoning blocks keep the
 		* built-in Think disclosure and only receive a smoothed text feed; the
-		* last text or reasoning block owns conversation-port follow so wraps
-		* glide. The FPS guard holds offscreen
-		* reveals when the frame rate is degraded. Settled text renders with the
-		* full Markdown pipeline.
+		* outer node owns conversation-port follow while streaming; the final text
+		* block keeps ownership while its settled reveal queue drains. The FPS guard
+		* holds offscreen reveals when the frame rate is degraded. Settled text
+		* renders with the full Markdown pipeline.
 		*/
 		const TypewriterAssistantNodeView = (0, react.memo)(function TypewriterAssistantNodeView({ mode: _mode = DEFAULT_STREAM_CONFIG.mode, preset = DEFAULT_STREAM_CONFIG.preset, revealCharsPerSec: _revealCharsPerSec = DEFAULT_STREAM_CONFIG.revealCharsPerSec, scrollSpeedPxPerSec: _scrollSpeedPxPerSec = DEFAULT_STREAM_CONFIG.scrollSpeedPxPerSec, maxScrollSpeedPxPerSec: _maxScrollSpeedPxPerSec = DEFAULT_STREAM_CONFIG.maxScrollSpeedPxPerSec, thinkAutoExpand = DEFAULT_STREAM_SETTINGS.thinkAutoExpand, node, useTurnData, openFile, loadImage, fileMentions, t }) {
 			const data = node.data;
 			const streaming = data.status === "running";
+			const reduced = usePrefersReducedMotion();
 			const { ref: guardRef, shouldHoldBack } = useFpsGuard(streaming);
 			const rootSpeedRef = (0, react.useRef)(35);
+			const rootRevealScaleRef = (0, react.useRef)(1);
+			const reasoningTailIndex = streaming && data.blocks[data.blocks.length - 1]?.kind === "reasoning" ? data.blocks.length - 1 : -1;
+			const reasoningOwnsSpeed = reasoningTailIndex !== -1;
+			const rootPredictiveRef = (0, react.useRef)(false);
+			const previousReasoningTailRef = (0, react.useRef)(-1);
+			if (reasoningTailIndex !== previousReasoningTailRef.current) {
+				rootPredictiveRef.current = reasoningOwnsSpeed ? thinkAutoExpand : false;
+				if (!reasoningOwnsSpeed) rootSpeedRef.current = 35;
+				previousReasoningTailRef.current = reasoningTailIndex;
+			}
+			const updateReasoningExpanded = (0, react.useMemo)(() => (expanded) => {
+				rootPredictiveRef.current = expanded;
+			}, []);
+			const updateTextPrediction = (0, react.useMemo)(() => (predictive) => {
+				rootPredictiveRef.current = predictive;
+			}, []);
 			const turn = node.location.kind === "turn" || node.location.kind === "step" ? node.location.turn : void 0;
 			const tail = useTurnData("turn-tail");
 			const owner = (0, react.useMemo)(() => {
@@ -1075,6 +1533,9 @@ window.__ModuleLoader__.load({
 							streaming,
 							announce: index === last,
 							ownFollow: !streaming && index === lastFollow,
+							followSpeedCpsRef: index === lastFollow ? rootSpeedRef : void 0,
+							followRevealScaleRef: index === lastFollow ? rootRevealScaleRef : void 0,
+							onPredictiveChange: index === lastFollow ? updateTextPrediction : void 0,
 							preset,
 							shouldHoldBack
 						}, index));
@@ -1086,6 +1547,9 @@ window.__ModuleLoader__.load({
 							preset,
 							thinkAutoExpand,
 							shouldHoldBack,
+							followSpeedCpsRef: reasoningOwnsSpeed && index === last ? rootSpeedRef : void 0,
+							followRevealScaleRef: reasoningOwnsSpeed && index === last ? rootRevealScaleRef : void 0,
+							onExpandedChange: index === reasoningTailIndex ? updateReasoningExpanded : void 0,
 							t
 						}, index));
 						break;
@@ -1107,13 +1571,11 @@ window.__ModuleLoader__.load({
 						break;
 					}
 					case "tool-call": break;
-					case "other":
-						rendered.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.JsonBlock, {
-							label: t("message.unknownBlock"),
-							payload: block.block,
-							truncatedLabel: (total) => t("json.truncated", { total })
-						}, index));
-						break;
+					case "other": rendered.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.JsonBlock, {
+						label: t("message.unknownBlock"),
+						payload: block.block,
+						truncatedLabel: (total) => t("json.truncated", { total })
+					}, index));
 				}
 			}
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
@@ -1121,8 +1583,10 @@ window.__ModuleLoader__.load({
 				className: TypewriterAssistantNodeView_module_css_default.root,
 				"data-streaming": streaming || void 0,
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FollowHost, {
-					active: streaming,
+					active: streaming && !reduced,
 					speedCpsRef: rootSpeedRef,
+					revealScaleRef: rootRevealScaleRef,
+					predictiveRef: rootPredictiveRef,
 					children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 						className: TypewriterAssistantNodeView_module_css_default.body,
 						children: [rendered, data.status === "interrupted" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
@@ -1134,11 +1598,210 @@ window.__ModuleLoader__.load({
 			});
 		});
 		//#endregion
+		//#region src/client/useProgressiveDomText.ts
+		/**
+		* Progressive text reveal for opaque Agent renderers.
+		*
+		* Slot renderers own arbitrary React trees, so the generic integration cannot
+		* clone or classify their business components. This hook leaves that tree and
+		* all of its event handlers in place, and only paces visible Text node data
+		* while the row belongs to the live Agent turn. No clip, mask, overlay, or
+		* duplicate accessibility tree is introduced.
+		*/
+		const SKIP_TEXT_SELECTOR = [
+			"[aria-hidden=\"true\"]",
+			"[aria-live]",
+			"[contenteditable=\"true\"]",
+			"script",
+			"style",
+			"textarea"
+		].join(",");
+		function revealable(node, root) {
+			if (node.data.trim() === "") return false;
+			const parent = node.parentElement;
+			return parent !== null && root.contains(parent) && parent.closest(SKIP_TEXT_SELECTOR) === null;
+		}
+		function commonPrefix(left, right) {
+			const limit = Math.min(left.length, right.length);
+			let index = 0;
+			while (index < limit && left[index] === right[index]) index += 1;
+			return index;
+		}
+		/**
+		* Pace text inside a renderer whose React component is intentionally opaque.
+		* Initial content is revealed only for a genuinely new row; later mutations
+		* stay paced until `enabled` becomes false, at which point the full renderer
+		* content is restored synchronously before paint.
+		*/
+		function useProgressiveDomText(rootRef, enabled, revealInitial, speedCpsRef, onSettled) {
+			(0, react.useLayoutEffect)(() => {
+				if (!enabled) return;
+				const root = rootRef.current;
+				if (root === null || typeof document === "undefined") return;
+				const records = /* @__PURE__ */ new Map();
+				const pending = /* @__PURE__ */ new Set();
+				const internalWrites = /* @__PURE__ */ new WeakMap();
+				let rafId = 0;
+				let lastFrame = null;
+				let debt = 0;
+				let stopped = false;
+				let announcedSettled = false;
+				const announceSettled = () => {
+					lastFrame = null;
+					debt = 0;
+					speedCpsRef.current = 35;
+					if (announcedSettled) return;
+					announcedSettled = true;
+					onSettled?.();
+				};
+				const write = (node, value) => {
+					if (node.data === value) return;
+					internalWrites.set(node, value);
+					node.data = value;
+				};
+				const enqueue = (node, full, preserve) => {
+					if (!revealable(node, root)) return;
+					const chars = [...full];
+					const preserved = preserve === void 0 ? 0 : Math.min(preserve.shown, commonPrefix(preserve.chars, chars));
+					const record = {
+						chars,
+						full,
+						shown: preserved
+					};
+					records.set(node, record);
+					if (preserved < chars.length) {
+						pending.add(node);
+						announcedSettled = false;
+					} else pending.delete(node);
+					write(node, chars.slice(0, preserved).join(""));
+				};
+				const visit = (from, reveal) => {
+					if (from.nodeType === Node.TEXT_NODE) {
+						const text = from;
+						if (reveal) enqueue(text, text.data, records.get(text));
+						return;
+					}
+					const walker = document.createTreeWalker(from, NodeFilter.SHOW_TEXT);
+					let current = walker.nextNode();
+					while (current !== null) {
+						const text = current;
+						if (reveal) enqueue(text, text.data, records.get(text));
+						current = walker.nextNode();
+					}
+				};
+				const scheduleFrame = () => {
+					if (stopped || pending.size === 0 || rafId !== 0) return;
+					rafId = requestAnimationFrame(frame);
+				};
+				const frame = (now) => {
+					rafId = 0;
+					if (stopped) return;
+					if (pending.size === 0) {
+						announceSettled();
+						return;
+					}
+					announcedSettled = false;
+					if (lastFrame === null) {
+						lastFrame = now;
+						scheduleFrame();
+						return;
+					}
+					const elapsed = Math.max(0, now - lastFrame);
+					lastFrame = now;
+					let backlog = 0;
+					for (const node of pending) {
+						const record = records.get(node);
+						if (record !== void 0) backlog += record.chars.length - record.shown;
+					}
+					const step = computeAdaptiveQueueStep(backlog, elapsed, debt);
+					debt = step.debt;
+					speedCpsRef.current = step.speedCps;
+					let remaining = step.revealChars;
+					for (const node of [...pending]) {
+						if (remaining <= 0) break;
+						const record = records.get(node);
+						if (record === void 0 || !node.isConnected) {
+							pending.delete(node);
+							continue;
+						}
+						const amount = Math.min(remaining, record.chars.length - record.shown);
+						const shown = record.shown + amount;
+						const next = {
+							...record,
+							shown
+						};
+						records.set(node, next);
+						write(node, next.chars.slice(0, shown).join(""));
+						remaining -= amount;
+						if (shown >= next.chars.length) pending.delete(node);
+					}
+					if (pending.size === 0) announceSettled();
+					else scheduleFrame();
+				};
+				if (revealInitial) visit(root, true);
+				const observer = typeof MutationObserver === "undefined" ? null : new MutationObserver((mutations) => {
+					for (const mutation of mutations) {
+						if (mutation.type === "characterData") {
+							const node = mutation.target;
+							if (internalWrites.get(node) === node.data) {
+								internalWrites.delete(node);
+								continue;
+							}
+							enqueue(node, node.data, records.get(node));
+							continue;
+						}
+						for (const added of mutation.addedNodes) visit(added, true);
+					}
+					if (pending.size === 0) announceSettled();
+					else scheduleFrame();
+				});
+				observer?.observe(root, {
+					childList: true,
+					characterData: true,
+					subtree: true
+				});
+				if (pending.size === 0) announceSettled();
+				else scheduleFrame();
+				return () => {
+					stopped = true;
+					cancelAnimationFrame(rafId);
+					observer?.disconnect();
+					for (const [node, record] of records) {
+						const controlled = record.chars.slice(0, record.shown).join("");
+						if (node.isConnected && node.data === controlled) write(node, record.full);
+					}
+					pending.clear();
+					speedCpsRef.current = 35;
+				};
+			}, [
+				enabled,
+				onSettled,
+				revealInitial,
+				rootRef,
+				speedCpsRef
+			]);
+		}
+		//#endregion
 		//#region src/client/TypewriterToolNodeView.tsx
+		function openAgentLocation(node) {
+			if (node === null || typeof node !== "object" || !("location" in node)) return false;
+			const location = node.location;
+			if (location === null || typeof location !== "object" || !("kind" in location)) return false;
+			const kind = location.kind;
+			if (!("turn" in location)) return false;
+			const turn = location.turn;
+			if (turn === null || typeof turn !== "object" || !("status" in turn)) return false;
+			if (kind === "turn") return turn.status === "open";
+			if (kind !== "step" || !("step" in location)) return false;
+			const step = location.step;
+			return step !== null && typeof step === "object" && "status" in step && step.status === "open";
+		}
 		/**
-		* True while a Chat node is still growing: an assistant/workflow `status:
-		* 'running'` payload, a Tool root that has not settled (`kind` absent), or a
-		* model-retry whose current attempt is still `scheduled`.
+		* True while a Chat node has an explicitly unfinished lifecycle: an
+		* assistant/workflow `status: 'running'` payload, a Tool root that has not
+		* settled (`kind` absent), or a model-retry whose current attempt is still
+		* `scheduled`. Open-but-otherwise-unknown rows are covered by
+		* `isFollowableChatNode` below.
 		* @param node - The Chat node's view `node` prop.
 		* @returns whether this row should own conversation follow.
 		*/
@@ -1147,6 +1810,11 @@ window.__ModuleLoader__.load({
 			const data = node.data;
 			if (data === null || typeof data !== "object") return false;
 			if ("status" in data && data.status === "running") return true;
+			if ("kind" in data && data.kind === "command" && "outcome" in data && data.outcome === null) return true;
+			if ("command" in data) {
+				const command = data.command;
+				if (command !== null && typeof command === "object" && "outcome" in command && command.outcome === null) return true;
+			}
 			if ("root" in data) {
 				const root = data.root;
 				if (root !== null && typeof root === "object" && !("kind" in root)) return true;
@@ -1158,18 +1826,128 @@ window.__ModuleLoader__.load({
 			return false;
 		}
 		/**
-		* Wrap a prior Chat node renderer so a growing row shares conversation
-		* follow. Presentation stays with the wrapped component; kit seats
-		* (`renderSlot`, locale, inject) pass through unchanged.
+		* True for any Agent-owned Chat row in the currently open turn/step. This is
+		* the extensibility boundary: a newly registered Context, Command, Tool, or
+		* workflow renderer is followed without adding another kind-specific branch.
+		*/
+		function isFollowableChatNode(node) {
+			return isGrowingChatNode(node) || openAgentLocation(node);
+		}
+		/**
+		* True when a newly mounted Agent-owned row belongs to the current open
+		* Turn/Step, or is itself an unresolved growing lifecycle.
+		* @param node - The Chat node's view `node` prop.
+		* @returns whether its initial height should enter through conversation follow.
+		*/
+		function shouldAnimateChatNodeEntrance(node) {
+			return isFollowableChatNode(node);
+		}
+		/** Runtime-only fallback for unknown or terminal rows at the active flow tip. */
+		function liveAgentTailMode(root) {
+			const port = root.closest("[data-conversation-scroll]");
+			if (port === null) return null;
+			const row = root.closest("[data-chat-flow-key]");
+			if (row !== null) {
+				let sibling = row.nextElementSibling;
+				while (sibling !== null) {
+					if (sibling instanceof HTMLElement && sibling.hasAttribute("data-chat-flow-key")) return null;
+					sibling = sibling.nextElementSibling;
+				}
+			}
+			const flow = root.closest("[data-chat-flow]");
+			if (flow !== null && [...flow.children].some((child) => child instanceof HTMLElement && child.getAttribute("role") === "status" && !child.hasAttribute("data-chat-flow-key"))) return "turn";
+			return hasRecentConversationFollow(port) ? "handoff" : null;
+		}
+		/**
+		* Wrap a prior Agent Chat renderer so its entrance and later growth share
+		* conversation follow. Presentation stays with the wrapped component; kit
+		* seats (`renderSlot`, locale, inject) pass through unchanged.
 		* @param Inner - The already-registered row component.
 		* @returns A follow-hosted row.
 		*/
 		function wrapFollowNodeView(Inner) {
 			return function TypewriterFollowNodeView(props) {
 				const speedCpsRef = (0, react.useRef)(35);
+				const hostRef = (0, react.useRef)(null);
+				const growing = isGrowingChatNode(props.node);
+				const structurallyFollowable = isFollowableChatNode(props.node);
+				const structuralRef = (0, react.useRef)(structurallyFollowable);
+				const [runtimeFollowable, setRuntimeFollowable] = (0, react.useState)(false);
+				const runtimePersistentRef = (0, react.useRef)(false);
+				const runtimeHandledRef = (0, react.useRef)(false);
+				const followable = structurallyFollowable || runtimeFollowable;
+				const revealInitialRef = (0, react.useRef)(true);
+				const [entering, setEntering] = (0, react.useState)(() => shouldAnimateChatNodeEntrance(props.node));
+				const [growthPulse, setGrowthPulse] = (0, react.useState)(false);
+				const followableRef = (0, react.useRef)(false);
+				const growingRef = (0, react.useRef)(growing);
+				const entranceActiveRef = (0, react.useRef)(entering || growthPulse);
+				const growthExtentRef = (0, react.useRef)(null);
+				const mountedRef = (0, react.useRef)(true);
+				const pulseTimerRef = (0, react.useRef)(null);
+				structuralRef.current = structurallyFollowable;
+				followableRef.current = followable;
+				growingRef.current = growing;
+				entranceActiveRef.current = entering || growthPulse;
+				const finishRuntimeReveal = (0, react.useCallback)(() => {
+					if (structuralRef.current || runtimePersistentRef.current) return;
+					runtimeHandledRef.current = true;
+					setRuntimeFollowable(false);
+				}, []);
+				useProgressiveDomText(hostRef, followable, revealInitialRef.current, speedCpsRef, runtimeFollowable ? finishRuntimeReveal : void 0);
+				(0, react.useLayoutEffect)(() => {
+					if (structurallyFollowable) return;
+					const root = hostRef.current;
+					if (root === null) return;
+					const mode = liveAgentTailMode(root);
+					if (runtimeFollowable) {
+						if (runtimePersistentRef.current && mode !== "turn") {
+							runtimePersistentRef.current = false;
+							runtimeHandledRef.current = true;
+							setRuntimeFollowable(false);
+						}
+						return;
+					}
+					if (runtimeHandledRef.current || mode === null) return;
+					runtimePersistentRef.current = mode === "turn";
+					setRuntimeFollowable(true);
+					setEntering(true);
+				}, [runtimeFollowable, structurallyFollowable]);
+				const finishEntrance = (0, react.useCallback)(() => {
+					growthExtentRef.current = null;
+					if (pulseTimerRef.current !== null) {
+						clearTimeout(pulseTimerRef.current);
+						pulseTimerRef.current = null;
+					}
+					setEntering(false);
+					setGrowthPulse(false);
+				}, []);
+				const onGrowth = (0, react.useCallback)((deltaPx) => {
+					if (!mountedRef.current || !followableRef.current || growingRef.current || entranceActiveRef.current) return;
+					growthExtentRef.current = deltaPx;
+					setGrowthPulse(true);
+					if (pulseTimerRef.current !== null) clearTimeout(pulseTimerRef.current);
+					pulseTimerRef.current = setTimeout(() => {
+						pulseTimerRef.current = null;
+						setGrowthPulse(false);
+					}, 1200);
+				}, []);
+				(0, react.useEffect)(() => {
+					mountedRef.current = true;
+					return () => {
+						mountedRef.current = false;
+						if (pulseTimerRef.current !== null) clearTimeout(pulseTimerRef.current);
+					};
+				}, []);
 				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FollowHost, {
-					active: isGrowingChatNode(props.node),
+					active: growing,
+					entrance: entering || growthPulse,
+					onEntranceSettled: finishEntrance,
+					onGrowth: followable ? onGrowth : void 0,
+					entranceExtentRef: growthExtentRef,
 					speedCpsRef,
+					predictive: false,
+					hostRef,
 					children: (0, react.createElement)(Inner, props)
 				});
 			};
@@ -1189,31 +1967,31 @@ window.__ModuleLoader__.load({
 			tag.textContent = css;
 		}
 		var SmoothStreamCard_module_css_default = {
-			"description": "XNGeRG_description",
-			"header": "XNGeRG_header",
-			"fieldHead": "XNGeRG_fieldHead",
-			"updateCopy": "XNGeRG_updateCopy",
-			"footer": "XNGeRG_footer",
-			"discard": "XNGeRG_discard",
-			"readOnly": "XNGeRG_readOnly",
-			"failure": "XNGeRG_failure",
-			"chevronOpen": "XNGeRG_chevronOpen",
-			"cardOpen": "XNGeRG_cardOpen",
-			"update": "XNGeRG_update",
-			"save": "XNGeRG_save",
-			"chevron": "XNGeRG_chevron",
-			"label": "XNGeRG_label",
-			"body": "XNGeRG_body",
+			"card": "XNGeRG_card",
 			"hint": "XNGeRG_hint",
+			"failed": "XNGeRG_failed",
+			"field": "XNGeRG_field",
+			"chevron": "XNGeRG_chevron",
 			"headText": "XNGeRG_headText",
+			"version": "XNGeRG_version",
+			"body": "XNGeRG_body",
+			"fieldHead": "XNGeRG_fieldHead",
+			"toggle": "XNGeRG_toggle",
+			"readOnly": "XNGeRG_readOnly",
+			"header": "XNGeRG_header",
 			"pending": "XNGeRG_pending",
+			"label": "XNGeRG_label",
+			"update": "XNGeRG_update",
+			"discard": "XNGeRG_discard",
+			"footer": "XNGeRG_footer",
+			"failure": "XNGeRG_failure",
 			"name": "XNGeRG_name",
-			"toggle": "XNGeRG_toggle",
+			"description": "XNGeRG_description",
+			"cardOpen": "XNGeRG_cardOpen",
+			"chevronOpen": "XNGeRG_chevronOpen",
 			"updateRow": "XNGeRG_updateRow",
-			"failed": "XNGeRG_failed",
-			"version": "XNGeRG_version",
-			"field": "XNGeRG_field",
-			"card": "XNGeRG_card"
+			"save": "XNGeRG_save",
+			"updateCopy": "XNGeRG_updateCopy"
 		};
 		//#endregion
 		//#region src/client/SmoothStreamCard.tsx
@@ -1612,13 +2390,24 @@ window.__ModuleLoader__.load({
 			"balanced",
 			"silky"
 		];
-		/** Human-authored rows stay on the built-in renderer; `assistant-step` is replaced. */
-		const SKIP_WRAP = new Set([
+		/**
+		* The assistant renderer owns its own character queue and conversation
+		* follower, so wrapping it again would create two scroll owners. Human input
+		* stays immediate; every Agent-owned output renderer goes through the same
+		* generic follow boundary. This is deliberately keyed by the owner that
+		* provides the renderer, not by individual tool names, so new Context,
+		* Command, and Tool rows are covered automatically.
+		*/
+		const SKIP_WRAP = /* @__PURE__ */ new Set([
 			"assistant-step",
 			"user",
 			"steering",
 			"command-input"
 		]);
+		/** React function/class or an exotic component such as memo/forwardRef/lazy. */
+		function isWrappableComponent(value) {
+			return typeof value === "function" || value !== null && typeof value === "object" && "$$typeof" in value;
+		}
 		/**
 		* Read the Host-bridged boot config. The inline script is produced by this
 		* plugin's Host half from a schema-validated value, so only the structural
@@ -1638,16 +2427,19 @@ window.__ModuleLoader__.load({
 			return raw;
 		}
 		/**
-		* Wrap every keyed Chat row except `assistant-step` in place. A second
+		* Wrap every Agent-owned keyed Chat row except the assistant renderer in
+		* place. A second
 		* register with the same `children` table throws because the child slot is
 		* already declared, and only the winning entry receives `renderSlot`;
 		* swapping `entry.component` keeps the original children, locale, and inject
 		* seats. `assistant-step` is replaced below so text and Think use the
-		* typewriter reveal.
+		* typewriter reveal. The wrapper owns only the shared layout-growth/follow
+		* lifecycle; the Harness keeps each renderer's controls, disclosures, and
+		* cards intact.
 		* @param ctx - Browser context carrying the slot registry.
 		* @returns Restorer that puts the original components back.
 		*/
-		function wrapGrowingChatRows(ctx) {
+		function wrapAgentChatRows(ctx) {
 			const restores = [];
 			const wrapped = /* @__PURE__ */ new WeakSet();
 			const wrapAll = () => {
@@ -1655,7 +2447,7 @@ window.__ModuleLoader__.load({
 					const key = entry.options.key;
 					if (key === void 0 || SKIP_WRAP.has(key)) continue;
 					const current = entry.component;
-					if (typeof current !== "function" || wrapped.has(current)) continue;
+					if (!isWrappableComponent(current) || wrapped.has(current)) continue;
 					const inner = current;
 					const next = wrapFollowNodeView(inner);
 					wrapped.add(next);
@@ -1718,8 +2510,9 @@ window.__ModuleLoader__.load({
 		/**
 		* Register the typewriter renderer after the conversation package declares the
 		* keyed Chat node seat. A lower priority shadows the built-in assistant row;
-		* every other growing row is wrapped in place so Tool cards, retries, and
-		* workflow runs share conversation follow. The Host-bridged configuration
+		* every other keyed renderer is wrapped in place so Context, commands, Tool
+		* cards, retries, and workflow runs share one extensible follow boundary. The
+		* Host-bridged configuration
 		* selects the render direction, smoothing preset, and glide speed; the
 		* plugin-owned settings RPC supplies the live auto-expand preference when the
 		* settings surface is composed.
@@ -1765,7 +2558,7 @@ window.__ModuleLoader__.load({
 				});
 			};
 			ctx.slots.inject("conversation.chat.node", () => {
-				const unwrap = wrapGrowingChatRows(ctx);
+				const unwrap = wrapAgentChatRows(ctx);
 				const unshadow = ctx.slots.register({
 					name: "conversation.chat.node",
 					key: "assistant-step",