@oh-my-pi/pi-tui 18.3.5 → 18.4.1

package/src/status-line/startup.ts

@@ -0,0 +1,181 @@
+/**
+ * Status line for the speculative first frame, before any session exists.
+ *
+ * InteractiveMode persists {@link StatusLineStartupData} (settings plus the last
+ * session's model and thinking state); the next launch renders it through the
+ * real {@link StatusLineComponent} as a fresh, unnamed session at the live
+ * terminal width. Path and git branch are read live; context usage is reported
+ * unknown so the gauge shows the window without a percent.
+ *
+ * @example
+ * ```ts ignore
+ * const statusLine = createStartupStatusLine(cached.statusLine);
+ * statusLine.attachToEditor(editor, getComposerStyle(shape));
+ * ```
+ */
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import { isRecord } from "@oh-my-pi/pi-utils/type-guards";
+import { parseThinkingLevel } from "../thinking";
+import { StatusLineComponent } from "./component";
+import type { CompactionBoundaries } from "./context-usage";
+import type { StatusLineHost, StatusLineSession } from "./host";
+import {
+	CONTEXT_LINE_MODE_VALUES,
+	STATUS_LINE_PRESET_VALUES,
+	STATUS_LINE_SEGMENT_IDS,
+	STATUS_LINE_SEPARATOR_VALUES,
+} from "./schema";
+import type { StatusLineSettings } from "./types";
+
+/** Session-independent inputs that reproduce a fresh session's status bar on the next launch. */
+export interface StatusLineStartupData {
+	readonly settings: StatusLineSettings;
+	readonly gitEnabled: boolean;
+	/** Model of the last session; the next fresh session usually starts on it too. */
+	readonly model?: Model;
+	readonly thinkingLevel?: ThinkingLevel;
+	readonly autoThinking: boolean;
+	readonly fastMode: boolean;
+	/** Whether `model` bills through a subscription (drives the cost segment's prefix). */
+	readonly usingSubscription: boolean;
+	readonly autoCompactEnabled: boolean;
+	readonly compactionBoundaries: CompactionBoundaries | null;
+}
+
+const NO_MESSAGES: readonly never[] = [];
+const NO_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	orchestrationInput: 0,
+	orchestrationOutput: 0,
+	orchestrationCacheRead: 0,
+	premiumRequests: 0,
+	cost: 0,
+};
+
+/** Build the prepaint status line; the caller disposes it once the session-bound bar mounts. */
+export function createStartupStatusLine(data: StatusLineStartupData): StatusLineComponent {
+	const session: StatusLineSession = {
+		state: { model: data.model, thinkingLevel: data.thinkingLevel, messages: NO_MESSAGES },
+		model: data.model,
+		messages: NO_MESSAGES,
+		isStreaming: false,
+		isAutoThinking: data.autoThinking,
+		sessionManager: {
+			getSessionName: () => undefined,
+			getSessionId: () => "",
+			getUsageStatistics: () => NO_USAGE,
+		},
+		modelRegistry: { isUsingOAuth: () => data.usingSubscription },
+		getContextUsage: () =>
+			data.model?.contextWindow ? { tokens: 0, contextWindow: data.model.contextWindow, percent: null } : undefined,
+		autoResolvedThinkingLevel: () => undefined,
+		isFastModeActive: () => data.fastMode,
+		getAsyncJobSnapshot: () => null,
+		getGoalModeState: () => undefined,
+	};
+	const host: StatusLineHost = {
+		getSettings: () => data.settings,
+		gitEnabled: () => data.gitEnabled,
+		codexResetFireworksEnabled: () => false,
+		getSettingsRevision: () => 0,
+		getSessionSettingsIdentity: () => undefined,
+		getSessionSettingsRevision: () => 0,
+		goalStatusInFooter: () => false,
+		activeAccount: () => undefined,
+		canFetchUsageReports: () => false,
+		fetchUsageReports: async () => null,
+		resolveActiveRepo: () => null,
+		lookupPullRequest: async () => ({ stdout: "", exitCode: 1 }),
+		calculateTokensPerSecond: () => null,
+		limitMatchesActiveAccount: () => false,
+		computeCompactionBoundaries: () => data.compactionBoundaries,
+	};
+	const statusLine = new StatusLineComponent(session, host);
+	statusLine.setAutoCompactEnabled(data.autoCompactEnabled);
+	return statusLine;
+}
+
+function isOneOf<T extends string>(values: readonly T[], value: unknown): value is T {
+	return typeof value === "string" && values.some(candidate => candidate === value);
+}
+
+function isOptionalBoolean(value: unknown): boolean {
+	return value === undefined || typeof value === "boolean";
+}
+
+function isSegmentList(value: unknown): boolean {
+	return value === undefined || (Array.isArray(value) && value.every(id => isOneOf(STATUS_LINE_SEGMENT_IDS, id)));
+}
+
+/** Shallow check of persisted settings; nested segment options are trusted as written by this version. */
+function isStatusLineSettings(value: unknown): value is StatusLineSettings {
+	return (
+		isRecord(value) &&
+		(value.preset === undefined || isOneOf(STATUS_LINE_PRESET_VALUES, value.preset)) &&
+		isSegmentList(value.leftSegments) &&
+		isSegmentList(value.rightSegments) &&
+		(value.separator === undefined || isOneOf(STATUS_LINE_SEPARATOR_VALUES, value.separator)) &&
+		(value.segmentOptions === undefined || isRecord(value.segmentOptions)) &&
+		(value.contextLine === undefined || isOneOf(CONTEXT_LINE_MODE_VALUES, value.contextLine)) &&
+		isOptionalBoolean(value.showHookStatus) &&
+		isOptionalBoolean(value.sessionAccent) &&
+		isOptionalBoolean(value.transparent) &&
+		isOptionalBoolean(value.compactThinkingLevel)
+	);
+}
+
+/** Check the model fields the status line reads; the rest is trusted as serialized by this version. */
+function isPersistedModel(value: unknown): value is Model {
+	return (
+		isRecord(value) &&
+		typeof value.id === "string" &&
+		typeof value.name === "string" &&
+		typeof value.provider === "string" &&
+		typeof value.api === "string" &&
+		typeof value.contextWindow === "number"
+	);
+}
+
+function readCompactionBoundaries(value: unknown): CompactionBoundaries | null | undefined {
+	if (value === null) return null;
+	if (!isRecord(value) || typeof value.thresholdPercent !== "number") return undefined;
+	const speculationPercent = value.speculationPercent;
+	if (speculationPercent !== null && typeof speculationPercent !== "number") return undefined;
+	return { thresholdPercent: value.thresholdPercent, speculationPercent };
+}
+
+/** Validate persisted {@link StatusLineStartupData}; `undefined` for anything malformed. */
+export function readStatusLineStartupData(value: unknown): StatusLineStartupData | undefined {
+	if (!isRecord(value) || !isStatusLineSettings(value.settings)) return undefined;
+	const model = value.model;
+	if (model !== undefined && !isPersistedModel(model)) return undefined;
+	const thinkingLevel = typeof value.thinkingLevel === "string" ? parseThinkingLevel(value.thinkingLevel) : undefined;
+	if (value.thinkingLevel !== undefined && thinkingLevel === undefined) return undefined;
+	const compactionBoundaries = readCompactionBoundaries(value.compactionBoundaries);
+	if (
+		typeof value.gitEnabled !== "boolean" ||
+		typeof value.autoThinking !== "boolean" ||
+		typeof value.fastMode !== "boolean" ||
+		typeof value.usingSubscription !== "boolean" ||
+		typeof value.autoCompactEnabled !== "boolean" ||
+		compactionBoundaries === undefined
+	) {
+		return undefined;
+	}
+	return {
+		settings: value.settings,
+		gitEnabled: value.gitEnabled,
+		model,
+		thinkingLevel,
+		autoThinking: value.autoThinking,
+		fastMode: value.fastMode,
+		usingSubscription: value.usingSubscription,
+		autoCompactEnabled: value.autoCompactEnabled,
+		compactionBoundaries,
+	};
+}

package/src/status-line/types.ts

@@ -84,8 +84,6 @@ export interface SegmentContext {
 	sessionAccent?: boolean;
 	/** Stand-in session title for previews; `session_name` renders it when the session is unnamed. */
 	previewTitle?: string;
-	/** Replace dynamic values with ellipses while preserving each segment's icon, color, and static text. */
-	startupPlaceholder?: boolean;
 	activeRepo: ActiveRepoContext | null;
 	width: number;
 	options: StatusLineSegmentOptions;

package/src/terminal-capabilities.ts

@@ -514,11 +514,15 @@ function parseTmuxVersionFromEnv(env: NodeJS.ProcessEnv): { major: number; minor
  * Policy (highest precedence first):
  *   1. Explicit user override (`PI_NO_HYPERLINKS=1` off, `PI_FORCE_HYPERLINKS=1`
  *      on). Opt-out wins ties.
- *   2. Static terminal capability — terminals whose {@link TerminalInfo} marks
+ *   2. Herdr pane with no nested screen/tmux: on. Herdr hides the outer
+ *      terminal (`TERM=xterm-256color`, no `TERM_PROGRAM`), but it renders
+ *      OSC 8 in its own grid and opens links itself on Ctrl+click, so the
+ *      outer terminal's support does not matter.
+ *   3. Static terminal capability — terminals whose {@link TerminalInfo} marks
  *      `hyperlinks: false` (e.g. `base`) stay off unless the user forced on.
- *   3. GNU screen's explicit session marker (`STY`) always off, even if tmux is
+ *   4. GNU screen's explicit session marker (`STY`) always off, even if tmux is
  *      also present: a screen layer anywhere in the path cannot forward OSC 8.
- *   4. tmux session (`TMUX` set): enabled when tmux self-reports >= 3.4 via
+ *   5. tmux session (`TMUX` set): enabled when tmux self-reports >= 3.4 via
  *      `TERM_PROGRAM_VERSION` (tmux 3.4 stores OSC 8 as a cell attribute and
  *      forwards it to outer terminals whose `terminal-features` include
  *      `hyperlinks`). Older or unknown versions stay off; on outer terminals
@@ -526,11 +530,11 @@ function parseTmuxVersionFromEnv(env: NodeJS.ProcessEnv): { major: number; minor
  *      identical to today. Checked before the screen-family TERM heuristic
  *      because tmux's historical `default-terminal` is `screen-256color`, so
  *      `TERM=screen*` inside a tmux session must NOT short-circuit to off.
- *   5. screen-family TERM without `TMUX` always off: screen never gained OSC 8
+ *   6. screen-family TERM without `TMUX` always off: screen never gained OSC 8
  *      support.
- *   6. tmux-family TERM without `TMUX` env — unusual (e.g. inspection scripts);
+ *   7. tmux-family TERM without `TMUX` env — unusual (e.g. inspection scripts);
  *      no version available, so off.
- *   7. Otherwise honor the static terminal capability.
+ *   8. Otherwise honor the static terminal capability.
  */
 export function shouldEnableHyperlinksByDefault(
 	env: NodeJS.ProcessEnv = Bun.env,
@@ -539,6 +543,8 @@ export function shouldEnableHyperlinksByDefault(
 	const override = hyperlinksUserOverride(env);
 	if (override !== null) return override;
 
+	if (isInsideHerdr(env) && !env.STY && !env.TMUX) return true;
+
 	if (!getTerminalInfo(terminalId).hyperlinks) return false;
 
 	// STY is GNU screen's explicit session marker. It vetoes tmux enabling when

package/src/terminal.ts

@@ -171,10 +171,14 @@ export const STDOUT_BACKLOG_CLEAR_BYTES = 256 * 1024;
 /**
  * How long an armed backlog may go without any drain progress before the
  * consumer is declared gone. A slow-but-alive terminal keeps reaching new
- * low-water marks (so it never trips); a wedged one that flushes nothing is
- * torn down within this window.
+ * low-water marks (so it never trips), but a live one can also stop reading
+ * for seconds at a time: a busy tmux server holding a slow client, or a
+ * container's attach stream. Waiting costs no memory, because frames are
+ * deferred while the backlog is up (`TUI.#deferRenderForOutputBacklog`), so the
+ * window is long enough to ride those out; a reader that never comes back is
+ * still torn down within it.
  */
-const STDOUT_STALL_TIMEOUT_MS = 2_000;
+const STDOUT_STALL_TIMEOUT_MS = 60_000;
 
 /** Cadence at which {@link ProcessTerminal} re-samples the backlog while an episode is armed. */
 const STDOUT_STALL_POLL_MS = 250;
@@ -808,6 +812,11 @@ export class ProcessTerminal implements Terminal {
 	#reportedRows?: number;
 	#mode2031DebounceTimer?: Timer;
 	#windowsTerminalAppearancePollTimer?: Timer;
+	#progressActive = false;
+	// Ghostty expires OSC 9;4 state without a heartbeat. Persistent hosts such
+	// as Windows Terminal restart their indeterminate animation on every write.
+	readonly #keepProgressAlive = TERMINAL.id === "ghostty";
+	#bracketedPasteRefreshTimer?: Timer;
 	#progressTimer?: Timer;
 
 	constructor(options?: ProcessTerminalOptions) {
@@ -936,9 +945,8 @@ export class ProcessTerminal implements Terminal {
 			}
 		}
 
-		// Keep unmanaged fd-2 writes (macOS libmalloc/framework diagnostics) off
-		// the viewport while we own the terminal; released in stop(). See
-		// stderr-guard in pi-utils (mirrors openai/codex#24459).
+		// Keep unmanaged native fd-2 writes off the viewport while we own the
+		// terminal; released in stop(). See stderr-guard in pi-utils.
 		suppressTerminalStderr();
 
 		// Set up resize handler immediately. The OS refreshes process.stdout
@@ -1765,7 +1773,15 @@ export class ProcessTerminal implements Terminal {
 		// heuristic pure downside — turn it off so stall-batched keystrokes are
 		// not misread as a paste (#12540). `supported` is only true here after an
 		// explicit DECRPM reply (the DA1-sentinel fallback resolves unsupported).
-		if (mode === 2004 && supported) this.#stdinBuffer?.setRawPasteClassification(false);
+		if (mode === 2004 && supported) {
+			this.#stdinBuffer?.setRawPasteClassification(false);
+			// A terminal can reset this mode after the initial probe (for example,
+			// iTerm2's Terminal State toggle). Keep the mode asserted while we own
+			// the TTY, since the raw fallback is disabled after confirmation.
+			this.#bracketedPasteRefreshTimer ??= setInterval(() => {
+				if (this.#active && !this.#dead) this.#safeWrite("\x1b[?2004h");
+			}, 1000);
+		}
 	}
 
 	#syncWindowsTerminalAppearancePolling(mode2031Supported: boolean): void {
@@ -1897,6 +1913,10 @@ export class ProcessTerminal implements Terminal {
 		// Suppress observer/timer callbacks before any teardown can yield or throw.
 		this.#active = false;
 		this.#inputDeferred = false;
+		if (this.#bracketedPasteRefreshTimer) {
+			clearInterval(this.#bracketedPasteRefreshTimer);
+			this.#bracketedPasteRefreshTimer = undefined;
+		}
 		if (this.#headless) return;
 		// Unregister from emergency cleanup
 		if (activeTerminal === this) {
@@ -1908,7 +1928,9 @@ export class ProcessTerminal implements Terminal {
 		// step throws.
 		restoreTerminalStderr();
 
-		if (this.#clearProgressTimer()) {
+		this.#clearProgressTimer();
+		if (this.#progressActive) {
+			this.#progressActive = false;
 			this.#safeWrite(TERMINAL_PROGRESS_CLEAR_SEQUENCE);
 		}
 
@@ -2061,6 +2083,10 @@ export class ProcessTerminal implements Terminal {
 	#markTerminalDisconnected(reason: string, err?: unknown): void {
 		if (this.#dead) return;
 		this.#dead = true;
+		if (this.#bracketedPasteRefreshTimer) {
+			clearInterval(this.#bracketedPasteRefreshTimer);
+			this.#bracketedPasteRefreshTimer = undefined;
+		}
 		this.#disarmStdoutStallWatchdog();
 		logger.warn("terminal disconnected; stopping interactive rendering", { reason, err });
 
@@ -2297,14 +2323,17 @@ export class ProcessTerminal implements Terminal {
 	setProgress(active: boolean): void {
 		if (this.#headless) return;
 		if (active) {
+			if (this.#progressActive) return;
+			this.#progressActive = true;
 			this.#safeWrite(TERMINAL_PROGRESS_ACTIVE_SEQUENCE);
-			if (!this.#progressTimer) {
+			if (this.#keepProgressAlive && !this.#progressTimer) {
 				this.#progressTimer = setInterval(() => {
 					this.#safeWrite(TERMINAL_PROGRESS_ACTIVE_SEQUENCE);
 				}, TERMINAL_PROGRESS_KEEPALIVE_MS);
 				this.#progressTimer.unref?.();
 			}
 		} else {
+			this.#progressActive = false;
 			this.#clearProgressTimer();
 			this.#safeWrite(TERMINAL_PROGRESS_CLEAR_SEQUENCE);
 		}

package/src/tools/output-meta.ts

@@ -58,7 +58,8 @@ export interface DiagnosticMeta {
  */
 export interface LimitsMeta {
 	matchLimit?: { reached: number; suggestion: number };
-	resultLimit?: { reached: number; suggestion: number };
+	/** `suggestion` is omitted when the tool is already at its hard cap, so no larger usable limit exists to advise. */
+	resultLimit?: { reached: number; suggestion?: number };
 	headLimit?: { reached: number; suggestion: number };
 	/** `unit` may be absent in sessions persisted before it was recorded. */
 	columnTruncated?: { maxColumn: number; unit?: "bytes" | "chars"; artifactId?: string };
@@ -187,7 +188,7 @@ function isGeneratedOutputNoticeLine(line: string): boolean {
 	return (
 		body.startsWith("Showing ") ||
 		/^\d+ matches limit reached\. Use limit=\d+ for more/u.test(body) ||
-		/^\d+ results limit reached\. Use limit=\d+ for more/u.test(body) ||
+		/^\d+ results limit reached(?:\.|$)/u.test(body) ||
 		body.startsWith("Some lines truncated to ")
 	);
 }
@@ -300,7 +301,14 @@ export function formatOutputNotice(meta: OutputMeta | undefined): string {
 	}
 	if (meta.limits?.resultLimit) {
 		const l = meta.limits.resultLimit;
-		parts.push(`${l.reached} results limit reached. Use limit=${l.suggestion} for more`);
+		// At the tool's hard cap there is no larger usable limit, so the
+		// "Use limit=" advice would name a value that gets clamped right
+		// back — emit the bare reached notice instead (#13263).
+		parts.push(
+			l.suggestion === undefined
+				? `${l.reached} results limit reached`
+				: `${l.reached} results limit reached. Use limit=${l.suggestion} for more`,
+		);
 	}
 	if (meta.limits?.headLimit) {
 		const l = meta.limits.headLimit;

package/src/tools/vibe.ts

@@ -23,6 +23,8 @@ export interface VibeToolDetails {
 	op: VibeOp;
 	/** Live TV-wall snapshot of the owner's worker sessions at (or during) the call. */
 	screens: VibeScreenSnapshot[];
+	/** Sessions the director killed, left off `screens`; shown as a count. */
+	hiddenKilled?: string[];
 	spawned?: { id: string; cli: VibeCli; jobId: string };
 	send?: VibeSendOutcome;
 	wait?: {
@@ -46,6 +48,8 @@ export interface VibeScreenSnapshot {
 	id: string;
 	cli: VibeCli;
 	state: VibeSessionState;
+	/** Terminated by the director (`vibe_kill`) or mode teardown; unset for workers that died on their own. */
+	killed?: boolean;
 	model?: string;
 	turns: number;
 	queued: number;
@@ -373,13 +377,21 @@ export function createVibeToolRenderer(op: VibeOp) {
 				return new Text(header, 0, 0);
 			}
 
-			// wait/list: the TV wall.
+			// wait/list: the TV wall. Director-killed sessions arrive pre-filtered
+			// (see `hiddenKilled`) so a long-running director's wall stays legible.
 			const screens = details.screens;
+			const hiddenKilled = details.hiddenKilled?.length ?? 0;
+			const killedMeta = hiddenKilled > 0 ? [uiTheme.fg("dim", `${hiddenKilled} killed hidden`)] : [];
 			if (screens.length === 0) {
 				const fallback = result.content.find(part => part.type === "text")?.text ?? "no sessions";
+				const gist = hiddenKilled > 0 ? "no live sessions" : fallback;
 				return new Text(
 					renderStatusLine(
-						{ icon: "warning", title: `vibe ${op}`, meta: [uiTheme.fg("dim", frameText(fallback, 60))] },
+						{
+							icon: "warning",
+							title: `vibe ${op}`,
+							meta: [uiTheme.fg("dim", frameText(gist, 60)), ...killedMeta],
+						},
 						uiTheme,
 					),
 					0,
@@ -394,6 +406,7 @@ export function createVibeToolRenderer(op: VibeOp) {
 				if (running > 0) meta.push(uiTheme.fg("accent", `${running} on air`));
 				if (settledById.size > 0) meta.push(uiTheme.fg("success", `${settledById.size} settled`));
 				if (details.wait?.timedOut) meta.push(uiTheme.fg("warning", "timed out"));
+				meta.push(...killedMeta);
 				const title =
 					op === "wait"
 						? waiting

package/src/tui.ts

@@ -883,7 +883,8 @@ export class TUI extends Container {
 	// engine paints only the modal on the alt buffer and leaves every
 	// normal-screen accounting field (#previousFrameLength, #viewportTopRow, …)
 	// untouched, so exiting reconciles cleanly against the terminal-restored
-	// normal screen. #altPreviousLines is the last alt frame, for repaint-skip.
+	// normal screen. #altPreviousLines is the last alt frame, diffed row by row
+	// against the next one.
 	#altActive = false;
 	#mouseTracking: MouseTrackingState = "off";
 	/** Product-owned probe for opt-in normal-buffer click capture (`tui.mouse`). Read every frame. */
@@ -2867,16 +2868,18 @@ export class TUI extends Container {
 			this.#providerWindow.length > 0;
 		if (diffable) {
 			for (let index = 0; index < rows; index++) {
-				const previous = this.#providerPreparedRows[index];
-				const current = prepared.rows[index]!;
 				if (
-					this.#providerWindow[index] === prepared.lines[index] &&
-					previous !== undefined &&
-					previous.widthEpoch === current.widthEpoch &&
-					previous.imageProtocol === current.imageProtocol
+					!this.#rowNeedsRewrite(
+						this.#providerWindow,
+						this.#providerPreparedRows,
+						prepared.lines,
+						prepared.rows,
+						index,
+					)
 				) {
 					continue;
 				}
+				const current = prepared.rows[index]!;
 				buffer += `\x1b[${newTop + index + 1};1H${this.#lineRewriteSequence(
 					current,
 					width,
@@ -3440,6 +3443,29 @@ export class TUI extends Container {
 		return visibleWidth(above);
 	}
 
+	/**
+	 * Whether screen row `index` must be rewritten to turn the previously painted
+	 * frame into this one: its line, or the preparation it was painted with,
+	 * changed.
+	 */
+	#rowNeedsRewrite(
+		previousLines: readonly string[],
+		previousRows: readonly PreparedLine[],
+		lines: readonly string[],
+		rows: readonly PreparedLine[],
+		index: number,
+	): boolean {
+		const previous = previousRows[index];
+		const current = rows[index]!;
+		return (
+			previousLines[index] !== lines[index] ||
+			previous === undefined ||
+			previous.width !== current.width ||
+			previous.widthEpoch !== current.widthEpoch ||
+			previous.imageProtocol !== current.imageProtocol
+		);
+	}
+
 	#lineRewriteSequence(
 		line: PreparedLine,
 		width: number,
@@ -3549,9 +3575,11 @@ export class TUI extends Container {
 	}
 
 	/**
-	 * Full per-row viewport rewrite on the alt buffer. Emits only sync-output
-	 * brackets, a cursor home, and per-row rewrites — never ED3 or any
-	 * native-scrollback byte. The hardware cursor stays hidden here.
+	 * Paint a frame on the alt buffer: only the rows that changed since the
+	 * previous frame, or every row when the height changed, a repaint is forced,
+	 * or a changed frame holds OSC 66 text before or after. Emits only
+	 * sync-output brackets, cursor moves, and per-row rewrites — never ED3 or
+	 * any native-scrollback byte. The hardware cursor stays hidden here.
 	 */
 	#emitAltFrame(prepared: PreparedLines, width: number, height: number, notifyPaint: boolean): void {
 		// The pass that composed this frame ran with `altScreen`, so the normal
@@ -3573,38 +3601,34 @@ export class TUI extends Container {
 			for (const seq of imageTransmits) transmitBuffer += seq;
 			this.terminal.write(transmitBuffer);
 		}
-		// Skip an identical repaint (the modal is mostly static between
-		// keystrokes) — unless a forced repaint (resetDisplay,
-		// requestRender(true)) is pending: the redraw gesture must repair a
-		// corrupted modal even when our cached frame is byte-identical.
+		// A forced repaint (resetDisplay, requestRender(true)) rewrites every row
+		// even when the cached frame is byte-identical: the redraw gesture must
+		// repair a corrupted modal. So does a changed frame with OSC 66 text in
+		// it, before or after: a scaled glyph spans the rows below its own and the
+		// terminal drops it when any of them is written, so those rows are not
+		// independent. Otherwise rewrite only the rows that changed (a keystroke
+		// in a modal touches a row or two), and skip an identical frame entirely.
 		const force = this.#forceViewportRepaintOnNextRender;
 		this.#forceViewportRepaintOnNextRender = false;
-		if (!force && this.#altPreviousLines.length === height) {
-			let same = true;
-			for (let r = 0; r < height; r++) {
-				const previous = this.#altPreparedRows[r];
-				const current = prepared.rows[r]!;
-				if (
-					prepared.lines[r] !== this.#altPreviousLines[r] ||
-					previous === undefined ||
-					previous.width !== current.width ||
-					previous.widthEpoch !== current.widthEpoch ||
-					previous.imageProtocol !== current.imageProtocol
-				) {
-					same = false;
-					break;
-				}
-			}
-			if (same) {
-				this.#altPreviousLines = prepared.lines;
-				this.#altPreparedRows = prepared.rows;
-				return;
-			}
-		}
-		let buffer = `${this.#paintBeginSequence}\x1b[H`;
+		const full =
+			force ||
+			this.#altPreviousLines.length !== height ||
+			((this.#altPreviousLines.some(isOsc66Line) || prepared.lines.some(isOsc66Line)) &&
+				prepared.rows.some((_row, r) =>
+					this.#rowNeedsRewrite(this.#altPreviousLines, this.#altPreparedRows, prepared.lines, prepared.rows, r),
+				));
+		let rowsBuffer = "";
 		for (let r = 0; r < height; r++) {
-			if (r > 0) buffer += "\n";
-			buffer += this.#lineRewriteSequence(
+			if (full) {
+				if (r > 0) rowsBuffer += "\n";
+			} else if (
+				this.#rowNeedsRewrite(this.#altPreviousLines, this.#altPreparedRows, prepared.lines, prepared.rows, r)
+			) {
+				rowsBuffer += `\x1b[${r + 1};1H`;
+			} else {
+				continue;
+			}
+			rowsBuffer += this.#lineRewriteSequence(
 				prepared.rows[r]!,
 				width,
 				r,
@@ -3613,10 +3637,10 @@ export class TUI extends Container {
 				this.#osc66SpacerGlyphWidth(prepared.lines, r),
 			);
 		}
-		buffer += this.#paintEndSequence;
-		this.terminal.write(buffer);
 		this.#altPreviousLines = prepared.lines;
 		this.#altPreparedRows = prepared.rows;
+		if (rowsBuffer === "") return;
+		this.terminal.write(`${this.#paintBeginSequence}${full ? "\x1b[H" : ""}${rowsBuffer}${this.#paintEndSequence}`);
 		this.#debugPaint = { lines: prepared.lines, windowTop: 0, altScreen: true };
 		if (notifyPaint) {
 			this.#notifyPaint({
@@ -3628,6 +3652,6 @@ export class TUI extends Container {
 				rows: height,
 			});
 		}
-		this.#fullRedrawCount += 1;
+		if (full) this.#fullRedrawCount += 1;
 	}
 }