@oh-my-pi/pi-coding-agent 15.10.8 → 15.10.10

package/src/modes/components/transcript-container.ts

@@ -1,17 +1,36 @@
-import { type Component, Container, type NativeScrollbackLiveRegion, TERMINAL } from "@oh-my-pi/pi-tui";
+import { type Component, Container, type NativeScrollbackLiveRegion } from "@oh-my-pi/pi-tui";
 
-const kSnapshot = Symbol("transcript.frozenRender");
+const kSnapshot = Symbol("transcript.liveDiffSnapshot");
 
-interface FrozenRender {
+/**
+ * Per-block diff cache: the block's previous stripped contribution plus the
+ * derived append-only state. Purely an input to {@link deriveLiveCommitState}
+ * for still-live blocks — it is never replayed as render output. Every block
+ * renders its current content on every frame.
+ */
+interface LiveDiffSnapshot {
 	width: number;
 	lines: string[];
 	generation: number;
 	appendOnly: boolean;
-	volatile: boolean;
+	/**
+	 * Frames remaining until a block that rewrote an interior row may re-earn
+	 * append-only status. `0` means the block is not under rewrite suspicion.
+	 */
+	volatileCooldown: number;
+	/**
+	 * Stable-prefix ratchet (see {@link deriveLiveCommitState}): leading rows
+	 * promoted as commit-safe because they stayed visibly identical for
+	 * {@link STABLE_PREFIX_COMMIT_FRAMES} consecutive frames, plus the in-flight
+	 * candidate run and its age.
+	 */
+	stablePrefixLength: number;
+	candidatePrefixLength: number;
+	candidatePrefixAge: number;
 }
 
 interface SnapshotCarrier {
-	[kSnapshot]?: FrozenRender;
+	[kSnapshot]?: LiveDiffSnapshot;
 }
 
 /**
@@ -51,125 +70,212 @@ function stripPlainBlankEdges(lines: string[]): string[] {
 
 interface LiveCommitState {
 	appendOnly: boolean;
-	volatile: boolean;
+	volatileCooldown: number;
+	stablePrefixLength: number;
+	candidatePrefixLength: number;
+	candidatePrefixAge: number;
 	safeLength: number;
 }
 
+/**
+ * Render frames a block must stay clean (static or append-shaped) after an
+ * interior rewrite before its rows become committable again. A one-off
+ * re-layout (a codespan finalizing across a wrap boundary, a paragraph
+ * re-parsed as a heading) only suspends commits briefly — the pinned emitter
+ * appends from the stalled high-water mark, so the gap backfills contiguously
+ * once the block re-earns append-only. Periodic animations (a spinner rewrites
+ * its row every few frames) keep resetting the countdown and never re-earn it,
+ * so genuinely volatile blocks stay deferred. Frames arrive at most at the
+ * TUI's 30 Hz render cadence, so 30 frames ≈ 1s of clean streaming.
+ */
+const VOLATILE_REARM_FRAMES = 30;
+
+/**
+ * Consecutive frames a leading row run must stay visibly identical before it
+ * is promoted as commit-safe even though the block's tail keeps rewriting.
+ * Append-only detection alone is all-or-nothing per block: one perpetually
+ * ticking row (a task tool's progress tree, per-agent cost/tool counters, a
+ * log line spinner) suspends commits for the WHOLE block forever, so once the
+ * block outgrows the viewport its static head — e.g. a task's prompt/context
+ * markdown — is neither committed to native scrollback nor on screen: the
+ * transcript reads as cut off for the entire (possibly minutes-long) run.
+ * The ratchet commits the settled head while only the genuinely volatile tail
+ * stays deferred. If a promoted row is later rewritten (a collapsing
+ * preview), the engine's committed-prefix audit re-anchors and recommits —
+ * duplication, never loss — and the ratchet retreats to the divergence.
+ */
+const STABLE_PREFIX_COMMIT_FRAMES = 30;
+
+/**
+ * Visible-content form of a row: SGR/OSC bytes and trailing pad spaces are
+ * write framing, not content. A styled line's closing escape moves when the
+ * line stops being the last of its span (a wrapped thinking paragraph growing
+ * by one row), and width-padded rows shift their trailing spaces as text
+ * grows; both leave the on-screen cells identical and must not count as a
+ * rewrite of a committed-candidate row. Committed scrollback rows are written
+ * with a full SGR/OSC reset terminator, so escape-placement drift between
+ * visually identical renders cannot bleed styles across rows.
+ */
+function normalizeRow(line: string): string {
+	return Bun.stripANSI(line).trimEnd();
+}
+
+function rowsVisiblyEqual(prev: string, cur: string): boolean {
+	return prev === cur || normalizeRow(prev) === normalizeRow(cur);
+}
+
 function hasValidSnapshot(
-	snapshot: FrozenRender | undefined,
+	snapshot: LiveDiffSnapshot | undefined,
 	width: number,
 	generation: number,
-): snapshot is FrozenRender {
+): snapshot is LiveDiffSnapshot {
 	return snapshot !== undefined && snapshot.generation === generation && snapshot.width === width;
 }
 
 function commonPrefixLength(prev: string[], cur: string[]): number {
 	const limit = Math.min(prev.length, cur.length);
 	let i = 0;
-	while (i < limit && prev[i] === cur[i]) i++;
+	while (i < limit && rowsVisiblyEqual(prev[i]!, cur[i]!)) i++;
 	return i;
 }
 
 function commonSuffixLength(prev: string[], cur: string[], prefixLength: number): number {
 	const limit = Math.min(prev.length - prefixLength, cur.length - prefixLength);
 	let i = 0;
-	while (i < limit && prev[prev.length - 1 - i] === cur[cur.length - 1 - i]) i++;
+	while (i < limit && rowsVisiblyEqual(prev[prev.length - 1 - i]!, cur[cur.length - 1 - i]!)) i++;
 	return i;
 }
 
 function deriveLiveCommitState(
-	previous: FrozenRender | undefined,
+	previous: LiveDiffSnapshot | undefined,
 	current: string[],
 	width: number,
 	generation: number,
 ): LiveCommitState {
 	let appendOnly = false;
-	let volatile = false;
+	let volatileCooldown = 0;
+	let stablePrefixLength = 0;
+	let candidatePrefixLength = 0;
+	let candidatePrefixAge = 0;
 	if (hasValidSnapshot(previous, width, generation)) {
 		appendOnly = previous.appendOnly;
-		volatile = previous.volatile;
+		volatileCooldown = previous.volatileCooldown;
+		stablePrefixLength = previous.stablePrefixLength;
+		candidatePrefixLength = previous.candidatePrefixLength;
+		candidatePrefixAge = previous.candidatePrefixAge;
 
 		const prefixLength = commonPrefixLength(previous.lines, current);
 		const staticRender = prefixLength === previous.lines.length && prefixLength === current.length;
+		let cleanFrame = true;
 		if (!staticRender) {
 			const suffixLength = commonSuffixLength(previous.lines, current, prefixLength);
 			// Append-only growth never rewrites a row that may already have scrolled
-			// into native scrollback; it only grows the block at/near its tail. Three
+			// into native scrollback; it only grows the block at/near its tail. Four
 			// shapes qualify: a pure bottom append, an insertion above stable trailing
-			// chrome (a streaming tool's footer/border), and an in-place extension of
-			// the current line by one streamed token (line count unchanged). The first
-			// two preserve every previous row across a matching prefix + suffix; the
-			// last leaves a single divergent previous row that the current row merely
-			// lengthens. A divergent interior row that is genuinely rewritten means the
-			// block re-laid-out committed content — volatile, and never committed.
+			// chrome (a streaming tool's footer/border), an in-place extension of the
+			// current line by one streamed token (line count unchanged), and a
+			// wrap-shrink of the current line where its last word grew past the wrap
+			// column and moved down onto an appended row. The first two preserve every
+			// previous row across a matching prefix + suffix; the last two leave a
+			// single divergent previous row — the block's in-flight bottom line, which
+			// cannot have been committed (commits stop at the viewport top and the
+			// bottom line is by definition on screen). Any other divergent interior
+			// row means the block re-laid-out committed-candidate content — a rewrite,
+			// which suspends commits until the block re-earns append-only.
 			const preservedEveryRow = prefixLength + suffixLength >= previous.lines.length;
-			const tailExtendedInPlace =
+			let tailExtendedInPlace = false;
+			if (
+				!preservedEveryRow &&
 				prefixLength + suffixLength === previous.lines.length - 1 &&
-				prefixLength < current.length &&
-				current[prefixLength]!.startsWith(previous.lines[prefixLength]!);
-			if ((preservedEveryRow || tailExtendedInPlace) && current.length >= previous.lines.length && !volatile) {
-				appendOnly = true;
-			} else if (!preservedEveryRow && !tailExtendedInPlace) {
-				volatile = true;
+				prefixLength < current.length
+			) {
+				const prevTail = normalizeRow(previous.lines[prefixLength]!);
+				const curTail = normalizeRow(current[prefixLength]!);
+				tailExtendedInPlace =
+					curTail.startsWith(prevTail) || (current.length > previous.lines.length && prevTail.startsWith(curTail));
+			}
+			if ((preservedEveryRow || tailExtendedInPlace) && current.length >= previous.lines.length) {
+				if (volatileCooldown === 0) appendOnly = true;
+			} else {
+				cleanFrame = false;
 				appendOnly = false;
+				volatileCooldown = VOLATILE_REARM_FRAMES;
+			}
+		}
+		if (cleanFrame && volatileCooldown > 0) volatileCooldown--;
+
+		// Stable-prefix ratchet, independent of append-only. `prefixLength` is
+		// this frame's visibly-unchanged leading run; the candidate accumulates
+		// the MINIMUM prefix across a STABLE_PREFIX_COMMIT_FRAMES window, so
+		// promotion means every promoted row stayed identical for the whole
+		// window (row r is inside frame i's common prefix iff r < p_i, so
+		// r < min(p) holds for every frame of the window). A row settling
+		// mid-window promotes at most two windows later. A change above the
+		// already-promoted run retreats it to the divergence — the engine
+		// audit owns any rows that already committed (recommit, never loss).
+		if (prefixLength < stablePrefixLength) {
+			stablePrefixLength = prefixLength;
+			candidatePrefixLength = prefixLength;
+			candidatePrefixAge = 0;
+		} else {
+			candidatePrefixLength =
+				candidatePrefixAge === 0 ? prefixLength : Math.min(candidatePrefixLength, prefixLength);
+			candidatePrefixAge++;
+			if (candidatePrefixAge >= STABLE_PREFIX_COMMIT_FRAMES) {
+				stablePrefixLength = candidatePrefixLength;
+				candidatePrefixLength = prefixLength;
+				candidatePrefixAge = 0;
 			}
 		}
 	}
 
 	return {
 		appendOnly,
-		volatile,
-		safeLength: volatile ? 0 : appendOnly ? current.length : 0,
+		volatileCooldown,
+		stablePrefixLength,
+		candidatePrefixLength,
+		candidatePrefixAge,
+		// An append-only block's whole body is committable; otherwise the
+		// settled head still is — only the volatile tail stays deferred.
+		safeLength: appendOnly ? current.length : stablePrefixLength,
 	};
 }
 
 /**
- * Transcript container that freezes the rendered output of every block except
- * the bottom-most (live) one on terminals where committed native scrollback is
- * immutable.
+ * Transcript container that always renders every block's current content and
+ * reports the live-region seam (`NativeScrollbackLiveRegion`) that gates the
+ * engine's append-only scrollback commits.
  *
- * On ED3-risk terminals with an unobservable viewport (ghostty/kitty/iTerm2/…)
- * the renderer cannot clear saved lines (`\x1b[3J` may yank a reader) or query
- * whether the user has scrolled, so any block that re-lays-out *after* it has
- * scrolled past the viewport leaves a stale duplicate above the live region
- * (a finalized assistant message re-wrapping, a tool preview collapsing to its
- * compact result, a late async tool completion). The renderer's only safe move
- * for such an offscreen edit is to not repaint — which is correct only if the
- * committed region never changes underneath it.
- *
- * This container provides that guarantee: a block's render is snapshotted while
- * it is the live (bottom-most) block, and once a newer block is appended it
- * replays the snapshot instead of recomputing. Mutations after a block leaves
- * live are intentionally deferred until the next checkpoint {@link thaw} (prompt
- * submit → native-scrollback rebuild), where the whole transcript is replayed
- * and any drift reconciles safely. On terminals that can rebuild history this
- * freezing is unnecessary, so it renders every block live for full fidelity.
+ * The engine never rewrites committed history: rows above the seam that have
+ * entered the tape keep whatever bytes they were committed with ("let the
+ * history be"), while the visible window always repaints from each block's
+ * latest render — a late tool result, a post-finalize error pin, or an expand
+ * toggle is always reflected on screen. Blocks that are still mutating (an
+ * unfinalized tool, a streaming assistant message) stay below the seam so
+ * their rows do not enter history while they can still change; a streaming
+ * block whose render grows append-only deepens the seam through its settled
+ * head so a long reply's scrolled-off rows still reach scrollback mid-stream.
  */
 export class TranscriptContainer extends Container implements NativeScrollbackLiveRegion {
-	// Bumped to invalidate every block's snapshot at once; a snapshot is only
-	// honored when its stored generation still matches.
+	// Bumped to retire every block's diff snapshot at once (theme change /
+	// clear); a snapshot is only honored when its stored generation matches.
 	#generation = 0;
-	// Line index where the live (repaintable) region began on the previous
-	// render — the start of the earliest still-mutating block, or the bottom
-	// block when everything is finalized. A block leaves the live region only
-	// once it has finalized AND a finalized block sits below it; the frame it
-	// crosses out is recomputed so it freezes at its true final content, not the
-	// mid-stream snapshot it last rendered while live (TUI render coalescing can
-	// advance a block's content in the very frame it stops being live).
-	#prevLiveStartIndex = 0;
 	// Local line index where the current live region begins in the most recent
-	// render. TUI extends the native-scrollback pinned region from this point
-	// through the live blocks and the root chrome rendered below them.
+	// render. TUI commits rows to native scrollback only above this seam (or
+	// the deeper commit-safe end below).
 	#nativeScrollbackLiveRegionStart: number | undefined;
 	// Local line index up to which the leading run of live blocks is safe to
-	// commit. Finalized blocks contribute their full frozen body; still-live
-	// blocks contribute only after their stripped render has been observed
-	// growing without changing a previously rendered interior row.
+	// commit. Finalized blocks contribute their full body; still-live blocks
+	// contribute only while their render has been observed growing without
+	// visibly rewriting a previously rendered interior row (escape placement
+	// and pad drift are ignored). A rewrite suspends the block's contribution
+	// until it re-earns append-only via VOLATILE_REARM_FRAMES clean frames;
+	// the engine then backfills the stalled gap.
 	#nativeScrollbackCommitSafeEnd: number | undefined;
 
 	override invalidate(): void {
-		// A theme/global invalidation forces a full recompute on the rebuild that
-		// follows; retire every snapshot.
+		// Theme/global invalidation: retire every diff snapshot so stale styling
+		// is not diffed against the recolored render.
 		this.#generation++;
 		super.invalidate();
 	}
@@ -187,32 +293,19 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 		return this.#nativeScrollbackCommitSafeEnd;
 	}
 
-	/**
-	 * Retire all frozen snapshots so the next render reflects each block's current
-	 * state. Call at reconciliation checkpoints (prompt submit) where the whole
-	 * transcript is replayed into native scrollback and any drift a frozen block
-	 * accumulated is reconciled.
-	 */
-	thaw(): void {
-		this.#generation++;
-	}
-
 	override render(width: number): string[] {
 		width = Math.max(1, width);
 		this.#nativeScrollbackLiveRegionStart = undefined;
 		this.#nativeScrollbackCommitSafeEnd = undefined;
 
-		// Freezing/snapshotting only applies on ED3-risk terminals; elsewhere every
-		// block renders live. Inter-block spacing applies on BOTH paths so the gap
-		// between blocks is identical regardless of terminal.
-		const risk = TERMINAL.eagerEraseScrollbackRisk;
 		const count = this.children.length;
 
 		// The live region spans from the earliest still-mutating block through the
-		// bottom. A block that has not finalized must stay repaintable: out-of-band
-		// inserts (TTSR/todo cards) can append a finalized block *below* a tool that
-		// is still awaiting its result, and freezing the tool there would strand its
-		// committed rows on the mid-stream preview the late result never reaches.
+		// bottom. A block that has not finalized must stay below the seam: out-of-
+		// band inserts (TTSR/todo cards) can append a finalized block *below* a
+		// tool that is still awaiting its result, and committing the tool there
+		// would strand its history rows on the mid-stream preview the late result
+		// never reaches.
 		let liveStartIndex = count - 1;
 		for (let i = 0; i < count; i++) {
 			if (!isBlockFinalized(this.children[i]!)) {
@@ -220,62 +313,48 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 				break;
 			}
 		}
-		// Blocks at [prevLiveStart, liveStart) just crossed out of the live region;
-		// recompute them so they freeze at their final content. Everything below
-		// the lower of the two cutoffs was already frozen last frame and replays.
-		const replayCutoff = Math.min(liveStartIndex, this.#prevLiveStartIndex);
-		if (risk) this.#prevLiveStartIndex = liveStartIndex;
 
 		const lines: string[] = [];
 		// Tracks whether we are still inside the leading run of commit-safe live
 		// blocks. The first still-live volatile block closes it, but rendering
 		// continues so lower blocks remain visible.
 		let commitSafeOpen = true;
-		// The live-region start is recorded at the first visible row at/after the
-		// cutoff; empty leading blocks (or a separator) must not claim it early.
+		// The live-region start is recorded at the first visible row at/after
+		// liveStartIndex; empty leading blocks (or a separator) must not claim it
+		// early.
 		let liveRecorded = false;
 		for (let i = 0; i < count; i++) {
 			const child = this.children[i]! as Component & SnapshotCarrier;
 
-			// Resolve this child's contribution — its visible body with plain-blank
-			// top/bottom edges stripped (the container owns inter-block gaps). On
-			// ED3-risk terminals a frozen, scrolled-off block replays its snapshot
-			// instead of recomputing; a stale generation (post-thaw) or width
-			// mismatch (resize) recomputes, as does a block still live last frame.
-			let contribution: string[] | undefined;
-			const previousSnapshot = risk ? child[kSnapshot] : undefined;
-			if (risk && i < liveStartIndex && i < replayCutoff) {
-				if (hasValidSnapshot(previousSnapshot, width, this.#generation)) {
-					contribution = previousSnapshot.lines;
-				}
-			}
+			// This child's contribution: its current render with plain-blank
+			// top/bottom edges stripped (the container owns inter-block gaps).
+			// Always the latest content — committed history keeps whatever bytes
+			// it was written with, but the window must reflect the present state
+			// (late tool results, post-finalize re-layouts, expand toggles).
+			const previousSnapshot = child[kSnapshot];
+			const contribution = stripPlainBlankEdges(child.render(width));
 			let liveCommitState: LiveCommitState | undefined;
-			if (contribution === undefined) {
-				const rendered = child.render(width);
-				contribution = stripPlainBlankEdges(rendered);
-				if (risk && i >= liveStartIndex && !isBlockFinalized(child)) {
-					liveCommitState = deriveLiveCommitState(previousSnapshot, contribution, width, this.#generation);
-				}
-				// Cache every block's latest contribution. While a block is in the
-				// live region this keeps its snapshot current; on the frame it crosses
-				// out, the recompute above refreshes it before it freezes.
-				if (risk) {
-					child[kSnapshot] = {
-						width,
-						lines: contribution,
-						generation: this.#generation,
-						appendOnly: liveCommitState?.appendOnly ?? false,
-						volatile: liveCommitState?.volatile ?? false,
-					};
-				}
+			if (i >= liveStartIndex && !isBlockFinalized(child)) {
+				liveCommitState = deriveLiveCommitState(previousSnapshot, contribution, width, this.#generation);
 			}
+			// Cache the latest contribution as the next frame's diff input.
+			child[kSnapshot] = {
+				width,
+				lines: contribution,
+				generation: this.#generation,
+				appendOnly: liveCommitState?.appendOnly ?? false,
+				volatileCooldown: liveCommitState?.volatileCooldown ?? 0,
+				stablePrefixLength: liveCommitState?.stablePrefixLength ?? 0,
+				candidatePrefixLength: liveCommitState?.candidatePrefixLength ?? 0,
+				candidatePrefixAge: liveCommitState?.candidatePrefixAge ?? 0,
+			};
 
 			// Empty (or stripped-to-nothing) children contribute nothing and never
 			// affect spacing or the live-region offsets. An empty still-live child
 			// still closes the commit-safe run: if it later gains rows, it pushes
 			// everything below it.
 			if (contribution.length === 0) {
-				if (risk && i >= liveStartIndex && commitSafeOpen && !isBlockFinalized(child)) commitSafeOpen = false;
+				if (i >= liveStartIndex && commitSafeOpen && !isBlockFinalized(child)) commitSafeOpen = false;
 				continue;
 			}
 
@@ -284,10 +363,10 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 			// already a plain blank (a fragment's own trailing pad), never doubling.
 			const sep = lines.length > 0 && !isPlainBlank(lines[lines.length - 1]!) ? 1 : 0;
 
-			// The separator before the first live block stays in the committed prefix
-			// (it is deterministic and never changes once the prior block is frozen),
+			// The separator before the first live block stays in the committed
+			// prefix (it is deterministic once the prior block's body is settled),
 			// so the live region begins at the block's first content row.
-			if (risk && !liveRecorded && i >= liveStartIndex) {
+			if (!liveRecorded && i >= liveStartIndex) {
 				this.#nativeScrollbackLiveRegionStart = lines.length + sep;
 				liveRecorded = true;
 			}
@@ -296,7 +375,7 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 			const blockStart = lines.length;
 			for (let j = 0; j < contribution.length; j++) lines.push(contribution[j]!);
 
-			if (risk && i >= liveStartIndex && commitSafeOpen) {
+			if (i >= liveStartIndex && commitSafeOpen) {
 				const finalized = isBlockFinalized(child);
 				const safeLength = finalized ? contribution.length : (liveCommitState?.safeLength ?? 0);
 				if (safeLength > 0) {

package/src/modes/controllers/event-controller.ts

@@ -36,19 +36,6 @@ const IRC_MESSAGE_VISIBLE_TTL_MS = 10_000;
  */
 export const INTERRUPTING_WORKING_MESSAGE = "Interrupting…";
 
-// Events that change foreground streaming state, or that reset a turn. The TUI
-// eager native-scrollback rebuild mode is recomputed only on these so unrelated
-// IRC/notices/status refreshes do not toggle scrollback replay policy.
-const STREAM_RENDER_MODE_EVENTS: Record<string, true> = {
-	agent_start: true,
-	agent_end: true,
-	message_start: true,
-	message_end: true,
-	tool_execution_start: true,
-	tool_execution_update: true,
-	tool_execution_end: true,
-};
-
 type AgentSessionEventHandlers = {
 	[E in AgentSessionEventKind]: (event: Extract<AgentSessionEvent, { type: E }>) => Promise<void>;
 };
@@ -65,7 +52,6 @@ export class EventController {
 	#renderedCustomMessages = new Set<string>();
 	#lastIntent: string | undefined = undefined;
 	#backgroundToolCallIds = new Set<string>();
-	#assistantMessageStreaming = false;
 	#agentTurnActive = false;
 	#interrupting = false;
 	#readToolCallArgs = new Map<string, Record<string, unknown>>();
@@ -217,30 +203,6 @@ export class EventController {
 
 		const run = this.#handlers[event.type] as (e: AgentSessionEvent) => Promise<void>;
 		await run(event);
-		// While an assistant turn is active, visible status chrome and foreground
-		// transcript blocks can re-render after rows have entered native scrollback
-		// (idle Working loader, Markdown fences, wrapping, tool previews). Let the
-		// TUI use its foreground live-region path instead of idle deferral, which
-		// can otherwise leave the loader/status frame frozen until the next input.
-		// Background-running tools after the turn ends are excluded so late async
-		// updates keep the no-yank deferral; agent_start/agent_end bracket the
-		// foreground turn.
-		if (STREAM_RENDER_MODE_EVENTS[event.type]) {
-			this.#refreshToolRenderMode();
-		}
-	}
-
-	#refreshToolRenderMode(): void {
-		let foregroundToolActive = this.#agentTurnActive || this.#assistantMessageStreaming;
-		if (!foregroundToolActive) {
-			for (const toolCallId of this.ctx.pendingTools.keys()) {
-				if (!this.#backgroundToolCallIds.has(toolCallId)) {
-					foregroundToolActive = true;
-					break;
-				}
-			}
-		}
-		this.ctx.ui.setEagerNativeScrollbackRebuild(foregroundToolActive);
 	}
 
 	async #handleAgentStart(_event: Extract<AgentSessionEvent, { type: "agent_start" }>): Promise<void> {
@@ -250,7 +212,6 @@ export class EventController {
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
 		this.#resetReadGroup();
-		this.#assistantMessageStreaming = false;
 		this.#lastAssistantComponent = undefined;
 		// Restore the previous turn's inline error in the transcript before dropping
 		// the banner, so the error stays in history once the banner is gone.
@@ -267,7 +228,6 @@ export class EventController {
 			this.ctx.statusContainer.clear();
 		}
 		this.#cancelIdleCompaction();
-		this.#refreshToolRenderMode();
 		this.ctx.ensureLoadingAnimation();
 		this.ctx.ui.requestRender();
 	}
@@ -340,7 +300,6 @@ export class EventController {
 			this.ctx.addMessageToChat(event.message);
 			this.ctx.ui.requestRender();
 		} else if (event.message.role === "assistant") {
-			this.#assistantMessageStreaming = true;
 			this.#lastVisibleBlockCount = 0;
 			this.ctx.streamingComponent = new AssistantMessageComponent(
 				undefined,
@@ -491,9 +450,6 @@ export class EventController {
 
 	async #handleMessageEnd(event: Extract<AgentSessionEvent, { type: "message_end" }>): Promise<void> {
 		if (event.message.role === "user") return;
-		if (event.message.role === "assistant") {
-			this.#assistantMessageStreaming = false;
-		}
 		if (this.ctx.streamingComponent && event.message.role === "assistant") {
 			this.ctx.streamingMessage = event.message;
 			this.#streamingReveal.stop();
@@ -701,7 +657,6 @@ export class EventController {
 	}
 	async #handleAgentEnd(_event: Extract<AgentSessionEvent, { type: "agent_end" }>): Promise<void> {
 		this.#agentTurnActive = false;
-		this.#assistantMessageStreaming = false;
 		this.#streamingReveal.stop();
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();

package/src/modes/controllers/input-controller.ts

@@ -191,7 +191,7 @@ export class InputController {
 			this.ctx.keybindings.getKeys("app.clipboard.pasteImage"),
 		);
 		this.ctx.editor.onPasteImage = () => this.handleImagePaste();
-		this.ctx.editor.onPasteImagePath = path => void this.handleImagePathPaste(path);
+		this.ctx.editor.onPasteImagePath = path => this.handleImagePathPaste(path);
 		this.ctx.editor.setActionKeys(
 			"app.clipboard.pasteTextRaw",
 			this.ctx.keybindings.getKeys("app.clipboard.pasteTextRaw"),
@@ -267,7 +267,7 @@ export class InputController {
 				const focused = this.ctx.ui.getFocused();
 				const target = focused && focused !== this.ctx.editor && hasPasteText(focused) ? focused : this.ctx.editor;
 				target.pasteText(text);
-				this.ctx.ui.requestRender(false, { allowUnknownViewportMutation: true });
+				this.ctx.ui.requestRender();
 			},
 			pasteImage: async image => {
 				// Images can only land in the main editor — when a modal Input is
@@ -755,7 +755,7 @@ export class InputController {
 		const dims = await this.#imageDimensions(imageData);
 		const label = dims ? `[Image #${imageNum}, ${dims.width}x${dims.height}]` : `[Image #${imageNum}]`;
 		this.ctx.editor.insertText(`${label} `);
-		this.ctx.ui.requestRender(false, { allowUnknownViewportMutation: true });
+		this.ctx.ui.requestRender();
 	}
 
 	/** Probe pixel dimensions for the marker label (`[Image #N, WxH]`). Returns undefined when the
@@ -801,7 +801,7 @@ export class InputController {
 			});
 			if (!image) {
 				this.ctx.editor.pasteText(path);
-				this.ctx.ui.requestRender(false, { allowUnknownViewportMutation: true });
+				this.ctx.ui.requestRender();
 				this.ctx.showStatus("Pasted path is not a supported image");
 				return;
 			}
@@ -811,7 +811,7 @@ export class InputController {
 			);
 		} catch (error) {
 			this.ctx.editor.pasteText(path);
-			this.ctx.ui.requestRender(false, { allowUnknownViewportMutation: true });
+			this.ctx.ui.requestRender();
 			this.ctx.showStatus(
 				error instanceof ImageInputTooLargeError ? error.message : "Failed to read pasted image path",
 			);

package/src/modes/controllers/mcp-command-controller.ts

@@ -36,7 +36,7 @@ import {
 import type { MCPAuthConfig, MCPServerConfig, MCPServerConnection } from "../../mcp/types";
 import type { OAuthCredential } from "../../session/auth-storage";
 import { shortenPath } from "../../tools/render-utils";
-import { urlHyperlink } from "../../tui";
+import { urlHyperlinkAlways } from "../../tui";
 import { openPath } from "../../utils/open";
 import { ChatBlock } from "../components/chat-block";
 import { MCPAddWizard } from "../components/mcp-add-wizard";
@@ -63,7 +63,7 @@ export class MCPAuthorizationLinkPrompt implements Component {
 	invalidate(): void {}
 
 	render(_width: number): string[] {
-		const link = urlHyperlink(this.#url, "Click here to authorize");
+		const link = urlHyperlinkAlways(this.#url, "Click here to authorize");
 		return [
 			` ${theme.fg("success", "Open authorization URL:")}`,
 			` ${theme.fg("accent", link)}`,

package/src/modes/controllers/selector-controller.ts

@@ -266,10 +266,6 @@ export class SelectorController {
 				this.ctx.updateEditorBorderColor();
 				break;
 
-			case "clearOnShrink":
-				this.ctx.ui.setClearOnShrink(value as boolean);
-				break;
-
 			case "autocompleteMaxVisible":
 				this.ctx.editor.setAutocompleteMaxVisible(typeof value === "number" ? value : Number(value));
 				break;