@oh-my-pi/pi-tui 18.12.1 → 18.12.2

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [18.12.2] - 2026-10-18
+
+### Added
+
+- Added `ComposerPreferences.completeScrollback` (default `false`): rows a growing HUD or dialog pushes off screen go straight to scrollback instead of being held back until it shrinks ([#15692](https://github.com/can1357/oh-my-pi/pull/15692) by [@Ilm-Alan](https://github.com/Ilm-Alan))
+
+### Fixed
+
+- Fixed table charts picking the wrong label and measure columns when numbers group thousands with spaces (`1 988`, `17 083`); they now read like `1,988` ([#16175](https://github.com/can1357/oh-my-pi/issues/16175))
+- Fixed terminal capability replies relayed through win32-input-mode appearing as typed input in WSL terminals ([#16137](https://github.com/can1357/oh-my-pi/issues/16137))
+- Fixed the status-bar activity spinner and turn timer freezing until the next keypress when the working-row loader is stopped mid-turn; an open turn window now repaints the status line on its own timer ([#16109](https://github.com/can1357/oh-my-pi/pull/16109) by [@tommymorgan](https://github.com/tommymorgan)).
+- Fixed pasting sometimes inserting a block of base64 text instead of the pasted text in terminals that deliver pastes through the Kitty clipboard protocol (OSC 5522), most often with dictation apps that paste for you; a slow paste now arrives whole, and keys typed while a paste never finishes are given back instead of lost ([#16170](https://github.com/can1357/oh-my-pi/pull/16170) by [@H4vC](https://github.com/H4vC))
+- Fixed a streaming table bouncing everything below it up and down while its last cell was still being written ([#16116](https://github.com/can1357/oh-my-pi/pull/16116) by [@galtamam-cmyk](https://github.com/galtamam-cmyk))
+- Fixed inline images in iTerm2 being sized for the wrong cell shape, which left charts smeared or offset ([#16118](https://github.com/can1357/oh-my-pi/pull/16118) by [@galtamam-cmyk](https://github.com/galtamam-cmyk))
+
 ## [18.12.1] - 2026-10-17
 
 ### Breaking Changes
@@ -2462,69 +2477,4 @@
 
 - Increased the minimum required Bun version for the TUI package from >=1.3.7 to >=1.3.14
 
-## [14.9.8] - 2026-05-12
-
-### Added
-
-- Added `Terminal.setProgress(active)` to emit OSC 9;4 progress sequences with a ~1s keepalive interval so Ghostty does not clear the indicator during long-running work (ports pi-mono `a900d251` + `76bc605a`)
-- Added optional `argumentHint?: string` to `SlashCommand`; rendered before the description in the autocomplete dropdown (ports pi-mono `aa25726e`)
-- Added `VirtualTerminal.waitForRender()` test helper for the throttled render pipeline (ports pi-mono `41377ee8`)
-
-### Changed
-
-- `ProcessTerminal` `columns`/`rows` getters consult `Bun.env.COLUMNS` / `Bun.env.LINES` before falling back to 80×24, so piped/non-TTY runs honour environment-provided dimensions (ports pi-mono `32f7fc6a`)
-- `requestRender()` non-force calls are coalesced to a ~16ms frame budget; `requestRender(true)` still flushes immediately via `process.nextTick` (ports pi-mono `6f5f37f8`)
-- `KNOWN_TERMINALS.base` / `KNOWN_TERMINALS.trueColor` default `hyperlinks: false`; tmux and screen (`TMUX` env or `TERM` starts with `tmux`/`screen`) force `hyperlinks: false` even when the outer terminal would advertise OSC 8 (adapts pi-mono `30a8a41f`)
-- `SlashCommand.getArgumentCompletions()` may return a `Promise`; results are now awaited and non-array returns are ignored (ports pi-mono `a1e10789`)
-- Fuzzy `@` autocomplete now follows symlinked directories via `ScanOptions.follow_links` plumbed through the native walker (ports pi-mono `780d5367`)
-- Plain `@<query>` (no slash) fuzzy matches by basename only, so `@plan` no longer surfaces every file whose ancestor directories contain `plan` (ports pi-mono `968430f6`)
-- Changed slash-command autocomplete list rendering to combine command hint and description in a single displayed suggestion text
-- Changed render scheduling to throttle `requestRender` calls to roughly 60fps by batching updates
-- Changed terminal input handling to process complete cell-size responses without buffering partial input
-- Changed `KeyId` to accept super-modifier combinations and improve typed key-id validation
-
-### Fixed
-
-- Fixed editor corruption on Thai Sara Am (U+0E33) and Lao AM (U+0EB3) vowels by normalizing to their compatibility decompositions on the terminal-write path while keeping editor content logically unchanged (ports pi-mono `bc668826` + `338ce3a3` + `20ca45d5`)
-- Fixed cell-size detection (`CSI 6;h;w t` response) to consume only exact replies, so a bare `Escape` keystroke is no longer swallowed while waiting for terminal image metadata (ports pi-mono `49c0d860`)
-- Fixed Kitty CSI-u printable input duplicating on layouts (e.g. Italian) where the terminal also emits the raw character: the immediately-following matching codepoint is now suppressed (ports pi-mono `bdb416cb`)
-- Fixed bracketed-paste CSI-u `Ctrl+<letter>` re-encoding (tmux popup with `extended-keys-format=csi-u`) leaking literal `[<code>;5u` into the editor; control bytes are decoded back to their literal byte before per-char filtering (ports pi-mono `d06db09a`)
-- Fixed xterm `modifyOtherKeys` shifted printable input so uppercase letters inserted via `CSI 27;mod;codepoint~` reach the editor correctly (ports pi-mono `6b55d685`)
-- Fixed `super`-modified Kitty shortcuts (`super+k`, `ctrl+super+enter`, …) to parse and match via the new `KITTY_MOD_SUPER` mask (ports pi-mono `ddb8454c` + `5ed46003`)
-- Fixed `ctrl+alt+<letter>` in tmux falling through to CSI-u / `modifyOtherKeys` when the legacy `ESC<ctrl-char>` form does not match (ports pi-mono `6cf5098f`)
-- Fixed Markdown strikethrough requiring strict `~~text~~` delimiters with non-whitespace boundaries; single tildes no longer render strikethrough (ports pi-mono `db5274b4`)
-- Allowed `SlashCommand.getArgumentCompletions` to return asynchronous results by accepting Promise-based completions
-- Added `argumentHint` support to slash command definitions and displayed it in command suggestion descriptions
-- Added support for xterm `modifyOtherKeys` printable key sequences by decoding `CSI 27;mod;key~` into text input
-- Normalized line output during rendering to correct Thai/Lao AM glyph composition for displayed text
-- Fixed duplicated Kitty key input emissions by dropping the matching unmodified follow-up sequence after a Kitty CSI-u printable-key event
-
-## [14.9.5] - 2026-05-12
-
-### Fixed
-
-- Fixed rapidly blinking cursor artifact during task execution by consolidating cursor control sequences into the synchronized output buffer ([#992](https://github.com/can1357/oh-my-pi/issues/992))
-
-## [14.5.7] - 2026-04-29
-
-### Fixed
-
-- Fixed editor Ctrl+Enter handling to recognize NumLock and keypad Enter variants.
-
-## [14.3.0] - 2026-04-25
-
-### Fixed
-
-- Fixed shared Markdown Mermaid fenced-block rendering to resolve diagrams from fenced source text instead of external prerender state
-
-## [14.1.1] - 2026-04-14
-
-### Breaking Changes
-
-- Removed the `searchDb` constructor argument from `CombinedAutocompleteProvider`, requiring callers to use the built-in search behavior
-
-### Changed
-
-- Changed truncation debug logging to run only when `debugRedraw` is enabled
-
-Older entries are archived in [packages/tui/CHANGELOG.md@200e7d2c6ebb](https://github.com/can1357/oh-my-pi/blob/200e7d2c6ebb2e187b167f807b9f68f779c0bf4b/packages/tui/CHANGELOG.md).
+Older entries are archived in [packages/tui/CHANGELOG.md@04d4ab14b45f](https://github.com/can1357/oh-my-pi/blob/04d4ab14b45f8dbd4055b675519f8815a1eb1841/packages/tui/CHANGELOG.md).

package/dist/types/chrome/status-notice.d.ts

@@ -21,6 +21,8 @@ export interface StatusNoticeOptions {
 export declare class StatusNotice extends Container {
     #private;
     constructor(message: string, options?: StatusNoticeOptions);
+    /** The text the notice currently shows. */
+    get message(): string;
     setMessage(message: string, options?: StatusNoticeOptions): void;
     describe(): NativeNode;
 }

package/dist/types/prompt/composer.d.ts

@@ -14,6 +14,8 @@ export interface ComposerPreferences {
     readonly showHardwareCursor: boolean;
     readonly maxInlineImages: number;
     readonly resizeScrollback: ResizeScrollbackMode;
+    /** Send rows a growing HUD or dialog pushes off screen straight to scrollback instead of holding them back until it shrinks. */
+    readonly completeScrollback: boolean;
     readonly imeSafeCursor: boolean;
     readonly autocompleteMaxVisible: number;
     readonly spellingTypoDetection: boolean;

package/dist/types/tools/web-search-types.d.ts

@@ -25,6 +25,7 @@ export declare const SEARCH_PROVIDER_LABELS: {
     readonly tavily: "Tavily";
     readonly firecrawl: "Firecrawl";
     readonly brave: "Brave";
+    readonly deepseek: "DeepSeek";
     readonly kimi: "Kimi";
     readonly synthetic: "Synthetic";
     readonly ollama: "Ollama";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.12.1",
+	"version": "18.12.2",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.12.1",
-		"@oh-my-pi/pi-agent-core": "18.12.1",
-		"@oh-my-pi/pi-ai": "18.12.1",
-		"@oh-my-pi/pi-catalog": "18.12.1",
-		"@oh-my-pi/pi-natives": "18.12.1",
-		"@oh-my-pi/pi-utils": "18.12.1",
-		"@oh-my-pi/pi-wire": "18.12.1",
-		"@oh-my-pi/snapcompact": "18.12.1"
+		"@oh-my-pi/omptype": "18.12.2",
+		"@oh-my-pi/pi-agent-core": "18.12.2",
+		"@oh-my-pi/pi-ai": "18.12.2",
+		"@oh-my-pi/pi-catalog": "18.12.2",
+		"@oh-my-pi/pi-natives": "18.12.2",
+		"@oh-my-pi/pi-utils": "18.12.2",
+		"@oh-my-pi/pi-wire": "18.12.2",
+		"@oh-my-pi/snapcompact": "18.12.2"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/charts/table-data.ts

@@ -148,7 +148,17 @@ export interface TableAnalysis {
 	readonly composition?: Composition;
 }
 
-const NUMBER = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?(?:[eE][+-]?\d+)?|\.\d+`;
+/**
+ * A whole number as written: bare, or grouped in thousands by commas (`1,988`)
+ * or by spaces as many locales write it (`1 988`, also U+00A0 and U+202F).
+ * Space groups take exactly three digits, so `12 5` and `128 2560` stay apart.
+ */
+const INTEGER = String.raw`\d{1,3}(?:,\d{3})+|\d{1,3}(?:[ \u00A0\u202F]\d{3})+(?!\d)|\d+`;
+const NUMBER = String.raw`(?:${INTEGER})(?:\.\d+)?(?:[eE][+-]?\d+)?|\.\d+`;
+/** A cell holding one whole number and nothing else (`38`, `1,980`). */
+const WHOLE = new RegExp(String.raw`^(?:${INTEGER})$`);
+/** The first number of a figure, its whole part and its decimals apart. */
+const WRITTEN = new RegExp(String.raw`(${INTEGER})(?:\.(\d+))?`);
 const CELL = new RegExp(
 	String.raw`^(?<approx>~|≈|<=|>=|<|>|≤|≥)?\s*(?<sign>[+\-−±])?\s*(?<cur>[$€£¥])?\s*(?<num>${NUMBER})(?<plus>\+(?=\s*[A-Za-zµμ%]))?\s*(?<unit>%|[A-Za-zµμ×]+(?:\/[A-Za-z]+)?|\/s)?(?<rest>.*)$`,
 );
@@ -517,8 +527,9 @@ export function parseCell(markdown: string): Cell {
 	return { ...cell, fit: "prose" };
 }
 
+/** The value of a number {@link NUMBER} matched, its comma or space group separators removed. */
 function toNumber(written: string): number {
-	return Number(written.replaceAll(",", ""));
+	return Number(written.replace(/[,\s]/g, ""));
 }
 
 /** A number of a list or sum: its value as written, its unit (known or a noun) and how it was marked. */
@@ -632,7 +643,7 @@ function listCell(text: string, base: CellBase): NumberCell | undefined {
 	// A spaced pair of bare numbers that is no score (`25.0 / 27.8`, `12.6 / 9.4`: the second is no whole, or
 	// the first exceeds it) lists two values of the column's quantity; `27 / 30` stays a score.
 	const [first, second] = items;
-	const whole = /^\d[\d,]*$/.test(text.slice(text.indexOf("/") + 1, end).trim());
+	const whole = WHOLE.test(text.slice(text.indexOf("/") + 1, end).trim());
 	const score = whole && first!.value >= 0 && first!.value <= second!.value;
 	const pair = items.length === 2 && !marked.some(Boolean) && separators[0] !== "/" && !score;
 	if (!pair && (!marked.at(-1) || !(marked.every(Boolean) || carried))) return undefined;
@@ -876,9 +887,9 @@ const WHOLE_HEADER = /\b(?:total|all|sum|overall)\b/i;
  */
 export function writtenSlack(cell: NumberCell): number {
 	if (cell.denominator !== undefined && cell.dim === "percent") return 0;
-	const match = /(\d[\d,]*)(?:\.(\d+))?/.exec(cell.figure);
+	const match = WRITTEN.exec(cell.figure);
 	if (!match) return 0;
-	const written = Number(`${match[1]!.replaceAll(",", "")}${match[2] ? `.${match[2]}` : ""}`);
+	const written = toNumber(`${match[1]!}${match[2] ? `.${match[2]}` : ""}`);
 	const factor = written ? Math.abs(cell.value) / written : 1;
 	const decimals = match[2]?.length ?? 0;
 	if (cell.dim === "count" && decimals === 0 && factor === 1 && !cell.approx) return 0;
@@ -1097,7 +1108,7 @@ const MIN_LISTS = 2;
 /** A spaced slash between list items. */
 const LIST_SLASH = /\s+\/\s+/;
 /** A list item that is one number, as written (`12`, `~1,400`, `3.5 ms`, `40%`). */
-const LISTED_NUMBER = /^[~≈]?[$€£¥]?\d[\d,]*(?:\.\d+)?\s*(?:%|[A-Za-zµμ]+)?$/;
+const LISTED_NUMBER = new RegExp(String.raw`^[~≈]?[$€£¥]?(?:${INTEGER})(?:\.\d+)?\s*(?:%|[A-Za-zµμ]+)?$`);
 
 /**
  * Rows folding several rows into one (`response anthropic / chat / responses /

package/src/chrome/status-notice.ts

@@ -42,6 +42,11 @@ export class StatusNotice extends Container {
 		this.addChild(this.#text);
 	}
 
+	/** The text the notice currently shows. */
+	get message(): string {
+		return this.#message;
+	}
+
 	setMessage(message: string, options: StatusNoticeOptions = {}): void {
 		const toast = options.toast ?? true;
 		this.#text.setStyleFn(options.styleFn);

package/src/components/markdown.ts

@@ -4611,7 +4611,27 @@ export class Markdown implements Component {
 				const text = this.#renderInlineTokens(cell.tokens || [], styleContext);
 				return this.#wrapCellText(text, columnWidths[i]);
 			});
-			const rowLineCount = Math.max(...rowCellLines.map(c => c.length));
+			let rowLineCount = Math.max(...rowCellLines.map(c => c.length));
+			// The open cell is laid out in widths measured without it, so it can
+			// wrap past the lines its row's finished cells need. Those extra lines
+			// come and go as the cell grows and the column widens, moving every row
+			// below the table each frame; hold the row at its finished cells' height
+			// until the cell closes and counts toward the widths. While lines are
+			// held back, only the last kept line makes room for a `…`: it is
+			// re-wrapped one column narrower, since the wrapper closes the line's
+			// links and styles where truncation would cut them off, and dropped when
+			// even that overflows (a wide glyph in a two-cell column).
+			if (rowIndex === lastRow && rowCellLines[openCell]) {
+				const settledLineCount = Math.max(1, ...rowCellLines.filter((_, i) => i !== openCell).map(c => c.length));
+				if (rowCellLines[openCell].length > settledLineCount) {
+					const width = columnWidths[openCell];
+					const kept = rowCellLines[openCell].slice(0, settledLineCount);
+					const last = width > 1 ? (this.#wrapCellText(kept[settledLineCount - 1], width - 1)[0] ?? "") : "";
+					kept[settledLineCount - 1] = `${visibleWidth(last) < width ? last : ""}…`;
+					rowCellLines[openCell] = kept;
+				}
+				rowLineCount = settledLineCount;
+			}
 
 			for (let lineIdx = 0; lineIdx < rowLineCount; lineIdx++) {
 				const rowParts = rowCellLines.map((cellLines, colIdx) => {

package/src/prompt/composer-cache.ts

@@ -94,6 +94,7 @@ function parseUiState(
 		showHardwareCursor,
 		maxInlineImages,
 		resizeScrollback,
+		completeScrollback,
 		imeSafeCursor,
 		autocompleteMaxVisible,
 		spellingTypoDetection,
@@ -109,6 +110,7 @@ function parseUiState(
 			resizeScrollback !== "append" &&
 			resizeScrollback !== "rebuild" &&
 			resizeScrollback !== "preserve") ||
+		(completeScrollback !== undefined && typeof completeScrollback !== "boolean") ||
 		typeof imeSafeCursor !== "boolean" ||
 		typeof autocompleteMaxVisible !== "number" ||
 		typeof spellingTypoDetection !== "boolean" ||
@@ -136,6 +138,7 @@ function parseUiState(
 			showHardwareCursor,
 			maxInlineImages,
 			resizeScrollback: resizeScrollback ?? "rebuild",
+			completeScrollback: completeScrollback ?? false,
 			imeSafeCursor,
 			autocompleteMaxVisible,
 			spellingTypoDetection,

package/src/prompt/composer.ts

@@ -37,6 +37,8 @@ export interface ComposerPreferences {
 	readonly showHardwareCursor: boolean;
 	readonly maxInlineImages: number;
 	readonly resizeScrollback: ResizeScrollbackMode;
+	/** Send rows a growing HUD or dialog pushes off screen straight to scrollback instead of holding them back until it shrinks. */
+	readonly completeScrollback: boolean;
 	readonly imeSafeCursor: boolean;
 	readonly autocompleteMaxVisible: number;
 	readonly spellingTypoDetection: boolean;
@@ -51,6 +53,7 @@ export const COMPOSER_DEFAULTS: ComposerPreferences = {
 	showHardwareCursor: true,
 	maxInlineImages: 8,
 	resizeScrollback: "rebuild",
+	completeScrollback: false,
 	imeSafeCursor: false,
 	autocompleteMaxVisible: 10,
 	spellingTypoDetection: true,
@@ -271,6 +274,8 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 	// displaced rows, so those rows refill the screen when it shrinks (#11007).
 	// Displaced rows reach history when newer output pushes them past the floor
 	// or persistent idle chrome settles and raises it.
+	// With `completeScrollback`, rows the chrome pushes off screen go straight
+	// to scrollback, and when it shrinks the freed rows stay blank.
 	// The floor is terminal-height independent — chrome heights do not scale
 	// with rows — so it is retained across resizes rather than rediscovered
 	// from whatever chrome is expanded when the height changes.
@@ -429,7 +434,7 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		const promotedChromeContracted = this.#chromeFloorPromoted && eligibleChrome < (this.#chromeFloor ?? 0);
 		this.#chromeFloor = Math.min(this.#chromeFloor ?? eligibleChrome, eligibleChrome);
 		this.#rebaselineChromeFloor(this.#runActive || transcript.hasActiveBlock(), eligibleChrome);
-		const belowFloor = this.#chromeFloor;
+		const belowFloor = this.#preferences.completeScrollback ? after.length : this.#chromeFloor;
 		// Offer history under capacity pressure only: blocks stay live (and keep
 		// reflowing to the current width) while the screen has room. A batch
 		// leaves the mutable viewport in the same frame it is appended, so its
@@ -447,7 +452,8 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		// billed against, so its compaction allocator (one row per block, no
 		// inter-block blanks) engages only when a block genuinely cannot retire.
 		// Rows the chrome above its floor displaces are clipped from the top by
-		// the `drop` slice below; they stay live until the chrome shrinks.
+		// the `drop` slice below; they stay live until the chrome shrinks. With
+		// `completeScrollback` none are held back.
 		const active = transcript.renderViewport(width, Math.max(0, rows - before.length - belowFloor), frame);
 		const activeSpans: ViewportClickSpan[] = [];
 		for (const span of transcript.getLastViewportSpans()) {

package/src/status-line/component.ts

@@ -43,7 +43,7 @@ import type { TspMeterMark, TspProps } from "@oh-my-pi/pi-wire";
 import type { NativeNode, NativeUiEvent } from "../native/node";
 import { col, node, span } from "../native/describe";
 import { getContextMeterThresholds } from "../chrome/context-thresholds";
-import { isNativeRendering } from "../native/state";
+import { isNativeRendering, onNativeRenderingChange } from "../native/state";
 import { getSeparator } from "./separators";
 import type {
 	CollabStatus,
@@ -154,6 +154,10 @@ const WATCHER_FAILURE_POLL_TTL_MS = 5000;
 const BRAND_FADE_MS = 450;
 /** Repaint cadence while the brand fade is in flight (rust omp's `FADE_FRAME`). */
 const BRAND_FADE_FRAME_MS = 40;
+/** Repaint cadence while a turn's active-processing window is open: keeps the
+ * status bar's clock-driven readouts (pi spinner, turn timer) animating when
+ * no other component is requesting renders. */
+const ACTIVE_WINDOW_REPAINT_MS = 250;
 
 /**
  * Providers whose subscription quota is a single monthly bucket, so their
@@ -690,6 +694,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	#gitWatcherUnavailable = false;
 	#onBranchChange: (() => void) | null = null;
 	#disposed = false;
+	/** Unsubscribe for the native-rendering feed; re-arms the turn-window ticker when a TSP surface is revoked. */
+	#unwatchNativeRendering: (() => void) | undefined;
 	#autoCompactEnabled: boolean = true;
 	/** Pulse timer for the running-speculation indicator; live only while speculation runs. */
 	#speculationBlinkTimer: NodeJS.Timeout | undefined;
@@ -700,6 +706,8 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	#brandWorking = false;
 	/** Frame timer driving repaints while the brand fade is unsettled. */
 	#brandFadeTimer: NodeJS.Timeout | undefined;
+	/** Repaint ticker while a turn's active-processing window is open (see #syncActiveWindowRepaint). */
+	#activeWindowRepaintTimer: NodeJS.Timeout | undefined;
 	/** One wall-clock wakeup for the active model's next tariff change, including while idle. */
 	#pricingTimer: NodeJS.Timeout | undefined;
 	#pricingTimerCost: ModelCost | undefined;
@@ -825,6 +833,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		private readonly host: StatusLineHost<TSession>,
 	) {
 		this.#settings = host.getSettings();
+		this.#unwatchNativeRendering = onNativeRenderingChange(() => this.#syncActiveWindowRepaint());
 	}
 
 	#gitEnabled(): boolean {
@@ -931,6 +940,12 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			this.#invalidateSessionCaches();
 			this.#closeStaleActiveWindow();
 		}
+		// The ticker self-stops once its tick sees no open window for the
+		// newly-attached session; re-pointing focus at a session whose turn
+		// is still running must re-arm it, and no other path reliably fires
+		// here (closeStaleActiveWindow returns early while streaming, and
+		// the synthesized agent_start no-ops on an already-open window).
+		this.#syncActiveWindowRepaint();
 		this.invalidate();
 	}
 
@@ -1029,6 +1044,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		meter.activeMs = 0;
 		meter.activeStartedAt = null;
 		this.#invalidateStatusLineRenderCache();
+		this.#syncActiveWindowRepaint();
 	}
 
 	/**
@@ -1043,6 +1059,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		if (meter.activeStartedAt !== null) return;
 		meter.activeStartedAt = Date.now();
 		this.#invalidateStatusLineRenderCache();
+		this.#syncActiveWindowRepaint();
 	}
 
 	/**
@@ -1057,6 +1074,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		meter.activeMs += Math.max(0, Date.now() - meter.activeStartedAt);
 		meter.activeStartedAt = null;
 		this.#invalidateStatusLineRenderCache();
+		this.#syncActiveWindowRepaint();
 	}
 
 	/**
@@ -1282,8 +1300,11 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		this.#onBranchChange = null;
 		this.#stopSpeculationBlink();
 		this.#stopBrandFadeTimer();
+		this.#stopActiveWindowRepaint();
 		this.#stopPricingTimer();
 		this.#clearUsageStartTimer();
+		this.#unwatchNativeRendering?.();
+		this.#unwatchNativeRendering = undefined;
 		this.#onCodexResetFireworks = undefined;
 		this.#onResetExpiryNotice = undefined;
 		this.#codexResetSnapshots.clear();
@@ -1387,6 +1408,40 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		this.#brandFadeTimer = undefined;
 	}
 
+	/**
+	 * Keep the status bar repainting while a turn's active-processing window
+	 * is open. The `pi` segment's spinner and turn timer are painted from the
+	 * wall clock at render time, so they only animate when frames flow; during
+	 * a quiet turn the working-row loader's 80 ms tick is normally the sole
+	 * repaint source, and paths that stop or bypass that loader mid-turn (an
+	 * error banner, a stale retry/compaction loader reference) froze the
+	 * spinner until the next keystroke. The status line owns the active
+	 * window, so it owns a repaint source for it; a native surface clocks its
+	 * own spinner and needs none.
+	 */
+	#syncActiveWindowRepaint(): void {
+		if (this.#disposed || isNativeRendering() || this.getTurnElapsedMs() === null) {
+			this.#stopActiveWindowRepaint();
+			return;
+		}
+		if (this.#activeWindowRepaintTimer) return;
+		const timer = setInterval(() => {
+			if (this.#disposed || isNativeRendering() || this.getTurnElapsedMs() === null) {
+				this.#stopActiveWindowRepaint();
+				return;
+			}
+			this.#onBranchChange?.();
+		}, ACTIVE_WINDOW_REPAINT_MS);
+		timer.unref?.();
+		this.#activeWindowRepaintTimer = timer;
+	}
+
+	#stopActiveWindowRepaint(): void {
+		if (!this.#activeWindowRepaintTimer) return;
+		clearInterval(this.#activeWindowRepaintTimer);
+		this.#activeWindowRepaintTimer = undefined;
+	}
+
 	#stopPricingTimer(): void {
 		clearTimeout(this.#pricingTimer);
 		this.#pricingTimer = undefined;

package/src/stdin-buffer.ts

@@ -58,7 +58,7 @@ const PARTIAL_HOLD_MAX_MS = 150;
 // so the string-terminator cap is generous.
 const MAX_CSI_BYTES = 4096;
 const MAX_STRING_SEQ_BYTES = 16 * 1024 * 1024;
-// Torn-string discard bounds. When a capped or timeout-expired OSC/DCS/APC
+// Torn-string discard bounds. When a capped OSC/DCS/APC
 // partial is dropped, the bytes that follow are mid-string payload (base64
 // clipboard data, Sixel, …) up to the next ST/BEL. Replaying them as
 // keystrokes types kilobytes of garbage into the focused component (kitty
@@ -69,6 +69,22 @@ const STRING_DISCARD_MAX_BYTES = 2 * MAX_STRING_SEQ_BYTES;
 const STRING_DISCARD_INACTIVITY_MS = 1000;
 // Partial that can only be the head of an OSC/DCS/APC string sequence.
 const STRING_SEQ_PARTIAL = /^\x1b[\]P_]/;
+// A pending string head is abandoned after this long without terminal-shaped
+// progress. Generous: a slow clipboard owner or SSH link may stall a packet
+// for a while, and abandoning a live packet types nothing but loses it.
+const STRING_ABANDON_MS = 5000;
+// How long an abandoned head stays dormant waiting for a late tail. Bounded
+// so a stale packet cannot absorb unrelated multi-byte input later on; a
+// resumed head that is abandoned again is dropped for good.
+const STRING_DORMANT_MS = 10_000;
+// Openings of the string replies omp receives, matched while still partial
+// (each alternative accepts any prefix of its opener) so a legacy Alt chord
+// that diverges is recognized as soon as it does:
+// - OSC: numeric command then `;` (`\x1b]11;`, `\x1b]5522;`).
+// - DCS: DECRQSS/XTGETTCAP `\x1bP1$r` / `\x1bP1+r`, XTVERSION `\x1bP>|`, DA3 `\x1bP!|`.
+// - APC: kitty graphics `\x1b_G`, TSP `\x1b_tsp;`, Glyph Protocol `\x1b_25a1;`.
+const LEGACY_STRING_REPLY_OPENER =
+	/^(?:\x1b\]\d+(?:;|$)|\x1bP(?:\d(?:[$+](?:r|$)|$)|[>!](?:\||$))|\x1b_(?:G|t(?:s(?:p(?:;|$)|$)|$)|2(?:5(?:a(?:1(?:;|$)|$)|$)|$)))/;
 
 // SGR mouse report bodies live between `<` and the terminating `M`/`m`.
 // Matched only when the trailing byte is a valid terminator, so the regex
@@ -108,6 +124,74 @@ function isRawMultilineBurst(text: string): boolean {
 	return false;
 }
 
+// `resolveEscapeEnd` result for an abandoned string sequence; see there.
+const STRING_ABORTED = -3;
+const OSC5522_PREFIX = "\x1b]5522;";
+// Kitty clipboard metadata (`type=read:status=DATA:mime=…:pw=…:id=…`) is
+// short; bounding the `;` search keeps a malformed packet O(n).
+const MAX_OSC5522_METADATA = 1024;
+
+/**
+ * Resolve an OSC/DCS/APC string sequence by its grammar, not by time. A
+ * string ends at ST (`ESC \`), or BEL for OSC. Its payload never contains
+ * another control byte or escape, and an OSC 5522 payload (after the
+ * metadata `;`) is strict base64. So a slow terminal — a clipboard owner
+ * serving a paste lazily — just extends the wait, while a keypress that
+ * cannot be payload (Enter, Backspace, Esc, arrows, space) proves the
+ * terminal abandoned the string: the caller drops the head and parses that
+ * key normally. Neither half of a stalled packet is ever typed as text.
+ *
+ * The scan is bounded to `[searchFrom, scanLimit)`; `resumeSearchFrom - 1`
+ * keeps a one-byte overlap so an `ESC \` split across chunks is still found.
+ */
+function resolveStringEnd(
+	buffer: string,
+	pos: number,
+	length: number,
+	resumeSearchFrom: number,
+	belTerminates: boolean,
+): number {
+	const searchFrom = Math.max(pos + 2, resumeSearchFrom - 1);
+	const scanLimit = Math.min(length, pos + MAX_STRING_SEQ_BYTES);
+	const base64From = belTerminates ? osc5522PayloadStart(buffer, pos, scanLimit) : -1;
+	// ECMA-48 §8.3.27: a DCS command string may carry BS..CR (0x08-0x0D).
+	const dcs = buffer.charCodeAt(pos + 1) === 0x50; /* P */
+	for (let i = searchFrom; i < scanLimit; i++) {
+		const code = buffer.charCodeAt(i);
+		if (code === 0x1b /* ESC */) {
+			// A lone trailing ESC may open ST; re-examined next call.
+			if (i + 1 === scanLimit) break;
+			if (buffer.charCodeAt(i + 1) === 0x5c /* \ */) return i + 2;
+			return STRING_ABORTED - i;
+		}
+		if (code === 0x07 /* BEL */ && belTerminates) return i + 1;
+		if ((code < 0x20 || code === 0x7f) && !(dcs && code >= 0x08 && code <= 0x0d)) return STRING_ABORTED - i;
+		if (base64From !== -1 && i >= base64From && !isBase64Code(code)) return STRING_ABORTED - i;
+	}
+	return length - pos >= MAX_STRING_SEQ_BYTES ? -2 : -1;
+}
+
+/** Index where an OSC 5522 packet's base64 payload starts, or -1 if not (yet) known. */
+function osc5522PayloadStart(buffer: string, pos: number, scanLimit: number): number {
+	if (!buffer.startsWith(OSC5522_PREFIX, pos)) return -1;
+	const metadataEnd = Math.min(scanLimit, pos + OSC5522_PREFIX.length + MAX_OSC5522_METADATA);
+	for (let i = pos + OSC5522_PREFIX.length; i < metadataEnd; i++) {
+		if (buffer.charCodeAt(i) === 0x3b /* ; */) return i + 1;
+	}
+	return -1;
+}
+
+function isBase64Code(code: number): boolean {
+	return (
+		(code >= 0x41 && code <= 0x5a) || // A-Z
+		(code >= 0x61 && code <= 0x7a) || // a-z
+		(code >= 0x30 && code <= 0x39) || // 0-9
+		code === 0x2b || // +
+		code === 0x2f || // /
+		code === 0x3d // =
+	);
+}
+
 /**
  * Resolve the exclusive-end index of the escape sequence starting at `pos`
  * (`buffer.charCodeAt(pos)` must be ESC). `resumeSearchFrom` is honored only
@@ -125,6 +209,9 @@ function isRawMultilineBurst(text: string): boolean {
  *   `-2`         — incomplete and the prefix already spans the per-type cap;
  *                  the caller cap-flushes CSI as raw bytes; string types
  *                  (OSC/DCS/APC) are dropped and their tail discarded.
+ *   `<= STRING_ABORTED` — an OSC/DCS/APC interrupted by a byte its payload
+ *                  cannot contain; `STRING_ABORTED - result` is that byte's
+ *                  index.
  */
 function resolveEscapeEnd(buffer: string, pos: number, length: number, resumeSearchFrom: number): number {
 	if (pos + 1 >= length) return -1;
@@ -174,45 +261,13 @@ function resolveEscapeEnd(buffer: string, pos: number, length: number, resumeSea
 			}
 			return length - pos >= MAX_CSI_BYTES ? -2 : -1;
 		}
-		case 0x5d /* ] */: {
-			// OSC: ESC ] ... BEL or ST (ESC \). Scan is bounded to
-			// [searchFrom, scanLimit): `String#indexOf` has no end bound, so
-			// an unterminated payload delivered as one huge chunk would
-			// otherwise be scanned to the end of the buffer — past the cap
-			// this function exists to enforce. `resumeSearchFrom - 1` keeps
-			// the one-byte overlap so an `ESC \` split across chunks is
-			// still found (the prior call's trailing ESC is re-inspected).
-			const searchFrom = Math.max(pos + 2, resumeSearchFrom - 1);
-			const scanLimit = Math.min(length, pos + MAX_STRING_SEQ_BYTES);
-			for (let i = searchFrom; i < scanLimit; i++) {
-				const code = buffer.charCodeAt(i);
-				if (code === 0x07 /* BEL */) return i + 1;
-				if (code === 0x1b /* ESC */) {
-					// `ESC \` (ST) must end within the cap; a lone trailing
-					// ESC at the buffer edge stays incomplete and is
-					// re-examined next call via the resume overlap.
-					if (i + 1 < scanLimit && buffer.charCodeAt(i + 1) === 0x5c /* \ */) return i + 2;
-				}
-			}
-			return length - pos >= MAX_STRING_SEQ_BYTES ? -2 : -1;
-		}
+		case 0x5d /* ] */:
+			// OSC: ESC ] ... BEL or ST (ESC \).
+			return resolveStringEnd(buffer, pos, length, resumeSearchFrom, true);
 		case 0x50 /* P */:
-		case 0x5f /* _ */: {
-			// DCS / APC: ESC P/_ ... ST (ESC \). Same bounded scan and
-			// split-ST overlap as the OSC branch, minus BEL.
-			const searchFrom = Math.max(pos + 2, resumeSearchFrom - 1);
-			const scanLimit = Math.min(length, pos + MAX_STRING_SEQ_BYTES);
-			for (let i = searchFrom; i < scanLimit; i++) {
-				if (
-					buffer.charCodeAt(i) === 0x1b /* ESC */ &&
-					i + 1 < scanLimit &&
-					buffer.charCodeAt(i + 1) === 0x5c /* \ */
-				) {
-					return i + 2;
-				}
-			}
-			return length - pos >= MAX_STRING_SEQ_BYTES ? -2 : -1;
-		}
+		case 0x5f /* _ */:
+			// DCS / APC: ESC P/_ ... ST (ESC \).
+			return resolveStringEnd(buffer, pos, length, resumeSearchFrom, false);
 		case 0x4f /* O */:
 			// SS3: ESC O + 1 char.
 			return pos + 3 <= length ? pos + 3 : -1;
@@ -236,10 +291,18 @@ function parseUnmodifiedKittyPrintableCodepoint(sequence: string): number | unde
 function extractCompleteSequences(
 	buffer: string,
 	resumeSearchFrom: number,
-): { sequences: string[]; remainder: string; resumeSearchFrom: number; discardFrom?: number } {
+): {
+	sequences: string[];
+	remainder: string;
+	resumeSearchFrom: number;
+	discardFrom?: number;
+	/** The buffered string head at offset 0 was abandoned (see `resolveStringEnd`). */
+	abortedHead?: boolean;
+} {
 	const sequences: string[] = [];
 	const length = buffer.length;
 	let pos = 0;
+	let abortedHead = false;
 
 	// Index-based scanning: this is the input hot path. Slicing the remaining
 	// buffer (or Array.from-ing it) per iteration would make plain-text bursts
@@ -273,7 +336,7 @@ function extractCompleteSequences(
 				//   window so cases 1/2 can still arrive; if no follower
 				//   arrives, `flush()` splits the held remainder into two ESC
 				//   events (#3857).
-				return { sequences, remainder: buffer.slice(pos), resumeSearchFrom: 0 };
+				return { sequences, remainder: buffer.slice(pos), resumeSearchFrom: 0, abortedHead };
 			}
 			const third = buffer.charCodeAt(pos + 2);
 			if (third !== 0x5b && third !== 0x4f) {
@@ -292,7 +355,7 @@ function extractCompleteSequences(
 			//   text (settings search filling with "[B" or "[<35;22;17M").
 			const innerEnd = resolveEscapeEnd(buffer, pos + 1, length, 0);
 			if (innerEnd === -1) {
-				return { sequences, remainder: buffer.slice(pos), resumeSearchFrom: 0 };
+				return { sequences, remainder: buffer.slice(pos), resumeSearchFrom: 0, abortedHead };
 			}
 			if (innerEnd === -2) {
 				// `third` is CSI/SS3 here, never a string type.
@@ -321,13 +384,21 @@ function extractCompleteSequences(
 		// Single ESC — resolve directly. Hint carries over from the previous
 		// call only when we are still on the buffered escape (pos === 0).
 		const end = resolveEscapeEnd(buffer, pos, length, pos === 0 ? hint : 0);
+		if (end <= STRING_ABORTED) {
+			// The terminal abandoned this string: drop the head (protocol
+			// data, never keys) and parse the interrupting byte normally.
+			if (pos === 0) abortedHead = true;
+			pos = STRING_ABORTED - end;
+			hint = 0;
+			continue;
+		}
 		if (end === -1) {
 			// Buffer for more. When this is the leading OSC/DCS/APC,
 			// remember how far we scanned so the next `process()` call
 			// resumes from there instead of rescanning the whole buffer.
 			const next = pos + 1 < length ? buffer.charCodeAt(pos + 1) : -1;
 			const nextHint = pos === 0 && (next === 0x5d || next === 0x50 || next === 0x5f) ? length : 0;
-			return { sequences, remainder: buffer.slice(pos), resumeSearchFrom: nextHint };
+			return { sequences, remainder: buffer.slice(pos), resumeSearchFrom: nextHint, abortedHead };
 		}
 		if (end === -2) {
 			const next = buffer.charCodeAt(pos + 1);
@@ -349,7 +420,7 @@ function extractCompleteSequences(
 		hint = 0;
 	}
 
-	return { sequences, remainder: "", resumeSearchFrom: 0 };
+	return { sequences, remainder: "", resumeSearchFrom: 0, abortedHead };
 }
 
 export type StdinBufferOptions = {
@@ -433,6 +504,20 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	#stringDiscardBytes = 0;
 	#stringDiscardEscHeld = false;
 	#stringDiscardWatchdog?: NodeJS.Timeout;
+	// Pending string head bookkeeping (see `#trackStringRead`): when the head
+	// last made terminal-shaped progress (0 = no head tracked), keys typed
+	// while it stalled, and the abandonment timer.
+	#stringProgressMs = 0;
+	#stringTypedKeys: string[] = [];
+	// Buffer offset of each typed key, parallel to `#stringTypedKeys`.
+	#stringTypedAt: number[] = [];
+	#stringAbandonTimer?: NodeJS.Timeout;
+	// An abandoned string head, kept so a late terminal-shaped tail still
+	// completes it instead of being typed (see `#resumeDormantString`).
+	#dormantString: string | undefined;
+	#dormantUntilMs = 0;
+	// The pending head was resumed from dormancy; abandoning it again drops it.
+	#stringResumed = false;
 
 	constructor(options: StdinBufferOptions = {}) {
 		super();
@@ -472,6 +557,11 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			str = this.#consumeStringDiscard(str);
 			if (str.length === 0) return;
 		}
+		if (this.#dormantString !== undefined && this.#buffer.length === 0) {
+			if (Date.now() < this.#dormantUntilMs) this.#resumeDormantString(str);
+			else this.#dormantString = undefined;
+		}
+		if (this.#bufferIsStringHead()) this.#trackStringRead(str);
 
 		if (this.#flushDeferral && this.#isFreshEscapeAfterDeferredFlush(str)) {
 			// The buffered partial already hit its flush timeout. A new escape is
@@ -528,6 +618,8 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 
 		const startIndex = this.#buffer.indexOf(BRACKETED_PASTE_START);
 		if (startIndex !== -1) {
+			// Keys typed while a string head stalled precede the paste.
+			this.#emitStringTypedKeys();
 			if (startIndex > 0) {
 				const beforePaste = this.#buffer.slice(0, startIndex);
 				const result = extractCompleteSequences(beforePaste, 0);
@@ -554,6 +646,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			const junk = this.#buffer.slice(result.discardFrom);
 			this.#buffer = "";
 			this.#escapeSearchOffset = 0;
+			this.#takeStringTypedKeys();
 			for (const sequence of result.sequences) {
 				this.#emitDataSequence(sequence);
 			}
@@ -565,14 +658,26 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#buffer = result.remainder;
 		this.#escapeSearchOffset = result.resumeSearchFrom;
 
+		// An abandoned string head hands back the keys typed while it stalled;
+		// they precede the byte that aborted it.
+		if (result.abortedHead) this.#emitStringTypedKeys();
 		for (const sequence of result.sequences) {
 			this.#emitDataSequence(sequence);
 		}
 
-		if (this.#buffer.length > 0) {
-			this.#armFlushTimer();
-		} else {
+		// A string head waits for its terminator, an aborting byte, or the
+		// abandonment bound (`#trackStringRead`), never the key flush window.
+		if (this.#bufferIsStringHead()) {
+			if (this.#stringProgressMs === 0) {
+				this.#dormantString = undefined;
+				this.#stringResumed = false;
+				this.#noteStringProgress();
+			}
 			this.#partialHoldStartMs = 0;
+		} else {
+			this.#takeStringTypedKeys();
+			if (this.#buffer.length > 0) this.#armFlushTimer();
+			else this.#partialHoldStartMs = 0;
 		}
 	}
 
@@ -751,7 +856,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			this.#timeout = undefined;
 			this.#flushDeferral = setTimeout(() => {
 				this.#flushDeferral = undefined;
-				this.#flushExpired(true);
+				this.#flushExpired();
 			});
 		}, this.#timeoutMs);
 	}
@@ -798,8 +903,132 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		return SGR_MOUSE_PARTIAL.test(this.#buffer) || isKittyProtocolActive();
 	}
 
+	/**
+	 * Whether the buffer is the head of an OSC/DCS/APC string: terminal
+	 * protocol data (OSC 5522 clipboard read, graphics reply), never a key.
+	 * Without the kitty keyboard protocol `\x1b]`/`\x1bP`/`\x1b_` may be
+	 * Alt+]/Alt+P/Alt+_, alone or batched with the next keys, so a head counts
+	 * only while it follows the opening of a reply omp actually receives
+	 * ({@link LEGACY_STRING_REPLY_OPENER}); the moment it diverges it falls
+	 * back to the key flush timer.
+	 */
+	#bufferIsStringHead(): boolean {
+		const buffer = this.#buffer;
+		if (!STRING_SEQ_PARTIAL.test(buffer)) return false;
+		if (isKittyProtocolActive()) return true;
+		return buffer.length > 2 && LEGACY_STRING_REPLY_OPENER.test(buffer);
+	}
+
+	/**
+	 * Classify a read arriving while a string head is pending. Chunk boundaries
+	 * do not follow terminal writes (SSH, tmux), so no read is ever torn out of
+	 * the string: every byte stays payload until the terminator completes it or
+	 * an impossible byte aborts it, and every read refreshes the abandonment
+	 * bound so a slow transfer is never abandoned while it still streams.
+	 *
+	 * Typing and terminal payload are indistinguishable by their bytes; when in
+	 * doubt the string wins, because typed base64 is the failure this exists
+	 * to prevent. Only a lone printable key arriving after the flush window
+	 * passed without a read — the shape of typing — is remembered: a head that
+	 * completes keeps it as payload, one that is abandoned (aborting byte, or
+	 * {@link STRING_ABANDON_MS} without reads) replays it. Multi-byte reads,
+	 * even keys an event-loop stall batched together, stay protocol data.
+	 */
+	#trackStringRead(str: string): void {
+		const stalled = Date.now() - this.#stringProgressMs >= this.#timeoutMs;
+		this.#noteStringProgress();
+		const code = str.codePointAt(0)!;
+		if (!stalled || str.length !== (code > 0xffff ? 2 : 1) || code < 0x20 || code === 0x7f) return;
+		// Only a key the string would keep as payload: a terminator completes
+		// it, and an impossible byte aborts it and is delivered by the parser.
+		const candidate = this.#buffer + str;
+		const end = resolveStringEnd(
+			candidate,
+			0,
+			candidate.length,
+			this.#buffer.length,
+			this.#buffer.charCodeAt(1) === 0x5d,
+		);
+		if (end !== -1) return;
+		this.#stringTypedKeys.push(str);
+		this.#stringTypedAt.push(this.#buffer.length);
+	}
+
+	#noteStringProgress(): void {
+		this.#stringProgressMs = Date.now();
+		clearTimeout(this.#stringAbandonTimer);
+		this.#stringAbandonTimer = setTimeout(() => {
+			this.#stringAbandonTimer = undefined;
+			if (!this.#bufferIsStringHead()) {
+				this.#takeStringTypedKeys();
+				return;
+			}
+			// The replayed keys are not payload: cut them from the dormant head
+			// so a late tail completes the packet the terminal actually sent.
+			let dormant = this.#buffer;
+			for (let i = this.#stringTypedAt.length - 1; i >= 0; i--) {
+				const at = this.#stringTypedAt[i]!;
+				dormant = dormant.slice(0, at) + dormant.slice(at + this.#stringTypedKeys[i]!.length);
+			}
+			if (this.#stringResumed) {
+				this.#dormantString = undefined;
+			} else {
+				this.#dormantString = dormant;
+				this.#dormantUntilMs = Date.now() + STRING_DORMANT_MS;
+			}
+			this.#buffer = "";
+			this.#escapeSearchOffset = 0;
+			this.#emitStringTypedKeys();
+		}, STRING_ABANDON_MS);
+	}
+
+	/** End string head tracking; returns the keys typed while it stalled. */
+	#takeStringTypedKeys(): string[] {
+		if (this.#stringProgressMs === 0) return [];
+		const keys = this.#stringTypedKeys;
+		this.#stringTypedKeys = [];
+		this.#stringTypedAt = [];
+		this.#stringProgressMs = 0;
+		clearTimeout(this.#stringAbandonTimer);
+		this.#stringAbandonTimer = undefined;
+		return keys;
+	}
+
+	/** End string head tracking and replay the keys typed while it stalled. */
+	#emitStringTypedKeys(): void {
+		for (const keys of this.#takeStringTypedKeys()) {
+			for (const sequence of extractCompleteSequences(keys, 0).sequences) this.#emitDataSequence(sequence);
+		}
+	}
+
+	/**
+	 * Re-attach a late tail to an abandoned string head. A read that completes
+	 * the head (even a lone BEL, or `\` after a held ESC), a lone ESC under the
+	 * kitty keyboard protocol (never a key there, so it opens a split ST), or a
+	 * multi-byte read that continues its grammar (strict base64 for OSC 5522)
+	 * resumes the head, as protocol data like any multi-byte read. Other lone
+	 * printable keys pass through as typing and keep the head dormant;
+	 * anything else means input moved on.
+	 */
+	#resumeDormantString(str: string): void {
+		const head = this.#dormantString!;
+		const candidate = head + str;
+		const end = resolveStringEnd(candidate, 0, candidate.length, head.length, head.charCodeAt(1) === 0x5d);
+		const code = str.codePointAt(0)!;
+		const heldSt = str === ESC && isKittyProtocolActive();
+		if (end <= 0 && !heldSt && str.length === (code > 0xffff ? 2 : 1)) {
+			if (code < 0x20 || code === 0x7f) this.#dormantString = undefined;
+			return;
+		}
+		this.#dormantString = undefined;
+		if (end <= STRING_ABORTED) return;
+		this.#buffer = head;
+		this.#escapeSearchOffset = head.length;
+		this.#stringResumed = true;
+	}
+
 	/** Timeout-driven flush: hold unambiguous partials (bounded), else deliver. */
-	#flushExpired(fromTimer = false): void {
+	#flushExpired(): void {
 		if (this.#buffer.length === 0) {
 			this.#partialHoldStartMs = 0;
 			return;
@@ -812,16 +1041,16 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			}
 		}
 		this.#partialHoldStartMs = 0;
-		for (const sequence of this.#drainBuffered(fromTimer)) {
+		for (const sequence of this.#drainBuffered()) {
 			this.#emitDataSequence(sequence);
 		}
 	}
 
 	flush(): string[] {
-		return this.#drainBuffered(false);
+		return this.#drainBuffered();
 	}
 
-	#drainBuffered(discardTornString: boolean): string[] {
+	#drainBuffered(): string[] {
 		this.#clearFlushTimer();
 
 		const rawCandidate = this.#takeRawPasteCandidate();
@@ -832,6 +1061,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			return sequences;
 		}
 
+		const stringHead = this.#bufferIsStringHead();
 		const buffered = this.#buffer;
 		this.#buffer = "";
 		this.#escapeSearchOffset = 0;
@@ -843,15 +1073,10 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		// split in `extractCompleteSequences` and deliver two ESC events.
 		if (buffered === `${ESC}${ESC}`) {
 			sequences.push(ESC, ESC);
-		} else if (isKittyProtocolActive() && STRING_SEQ_PARTIAL.test(buffered)) {
-			// Torn OSC/DCS/APC head. Under the kitty keyboard protocol no key
-			// ever arrives as a bare `\x1b]`/`\x1bP`/`\x1b_`, so this is always
-			// terminal protocol data (kitty OSC 5522 clipboard read, graphics
-			// reply) whose tail is still in flight. Never deliver the head as a
-			// key; on a timeout flush also swallow the tail up to its
-			// terminator so kilobytes of base64 are not typed into the focused
-			// component (image paste spam).
-			if (discardTornString) this.#enterStringDiscard();
+		} else if (stringHead) {
+			// Unterminated OSC/DCS/APC head: protocol data, never delivered as a
+			// key. Its tracking ends with it so the next head starts fresh.
+			this.#takeStringTypedKeys();
 		} else {
 			sequences.push(buffered);
 		}
@@ -930,6 +1155,9 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#clearPasteWatchdog();
 		this.#clearRawPasteTimer();
 		this.#exitStringDiscard();
+		this.#takeStringTypedKeys();
+		this.#dormantString = undefined;
+		this.#stringResumed = false;
 		this.#buffer = "";
 		this.#rawPasteCandidate = "";
 		this.#pasteMode = false;

package/src/terminal.ts

@@ -856,6 +856,8 @@ export class ProcessTerminal implements Terminal {
 	// Releases a relayed lone ESC the decoder held for a sequence tail that never came.
 	#win32PendingFlushTimer?: Timer;
 	#stdinBuffer?: StdinBuffer;
+	/** Parsed input path shared by direct VT and win32-input-mode relayed text. */
+	#stdinSequenceHandler?: (sequence: string) => void;
 	#stdinDataHandler?: (data: string) => void;
 	#disconnectHandler?: () => void;
 	#stdinEndHandler = () => {
@@ -1387,7 +1389,30 @@ export class ProcessTerminal implements Terminal {
 		// skip the subparameter tail instead of dropping the whole report.
 		const inBandResizePattern = /^\x1b\[48;(\d+)(?::[\d:]*)?;(\d+)(?::[\d:]*)?;(\d+)(?::[\d:]*)?;(\d+)(?::[\d:]*)?t$/;
 
-		this.#stdinBuffer.on("data", (sequence: string) => {
+		this.#stdinSequenceHandler = (sequence: string) => {
+			const decoder = this.#win32InputDecoder;
+			const win32Keys = decoder?.decode(sequence);
+			if (decoder && win32Keys !== undefined) {
+				clearTimeout(this.#win32PendingFlushTimer);
+				this.#win32PendingFlushTimer = undefined;
+				// The record is ESC-led, so it interrupts any direct reply still being
+				// reassembled, just as a raw escape does below. Decoded keys carry no ESC
+				// of their own and would otherwise be appended to that fragment.
+				this.#privateCsiResponseBuffer = "";
+				this.#inBandResizeBuffer = "";
+				this.#osc11ResponseBuffer = "";
+				this.#osc99ResponseBuffer = "";
+				this.#glyphProtocolReplyBuffer = "";
+				this.#tspReplyBuffer = "";
+				for (const key of win32Keys) this.#stdinSequenceHandler?.(key);
+				if (decoder.hasPendingSequence) {
+					this.#win32PendingFlushTimer = setTimeout(
+						() => this.#releaseWin32PendingSequence(),
+						WIN32_RELAYED_ESCAPE_TIMEOUT_MS,
+					);
+				}
+				return;
+			}
 			// Fast path for plain-text bytes: every escape-probe regex below
 			// anchors on `^\x1b…`, so a byte that is not ESC can never match. A
 			// non-bracketed paste of N printable chars arrives as N per-scalar
@@ -1719,20 +1744,6 @@ export class ProcessTerminal implements Terminal {
 				return;
 			}
 			if (this.#inputHandler) {
-				const decoder = this.#win32InputDecoder;
-				const win32Keys = decoder?.decode(sequence);
-				if (decoder && win32Keys !== undefined) {
-					clearTimeout(this.#win32PendingFlushTimer);
-					this.#win32PendingFlushTimer = undefined;
-					for (const key of win32Keys) this.#inputHandler(key);
-					if (decoder.hasPendingSequence) {
-						this.#win32PendingFlushTimer = setTimeout(
-							() => this.#releaseWin32PendingSequence(),
-							WIN32_RELAYED_ESCAPE_TIMEOUT_MS,
-						);
-					}
-					return;
-				}
 				// Windows console hosts drop AltGr text under kitty (AltGr+F → `CSI 102;3u`);
 				// recover it from the active layout before any keybinding sees an Alt chord.
 				const altGrText =
@@ -1741,7 +1752,8 @@ export class ProcessTerminal implements Terminal {
 						: undefined;
 				this.#inputHandler(altGrText ?? sequence);
 			}
-		});
+		};
+		this.#stdinBuffer.on("data", this.#stdinSequenceHandler);
 
 		// Re-wrap paste content with bracketed paste markers for existing editor
 		// handling. An Enter that shared the paste's stdin read rides along so
@@ -2104,7 +2116,7 @@ export class ProcessTerminal implements Terminal {
 		clearTimeout(this.#win32PendingFlushTimer);
 		this.#win32PendingFlushTimer = undefined;
 		const pending = this.#win32InputDecoder?.flushPendingSequence() ?? [];
-		for (const key of pending) this.#inputHandler?.(key);
+		for (const key of pending) this.#stdinSequenceHandler?.(key);
 	}
 
 	#disableWin32InputMode(): void {
@@ -2442,6 +2454,7 @@ export class ProcessTerminal implements Terminal {
 			this.#stdinBuffer.destroy();
 			this.#stdinBuffer = undefined;
 		}
+		this.#stdinSequenceHandler = undefined;
 
 		// Remove event handlers
 		if (this.#stdinDataHandler) {

package/src/tools/web-search-types.ts

@@ -26,6 +26,7 @@ export const SEARCH_PROVIDER_LABELS = {
 	tavily: "Tavily",
 	firecrawl: "Firecrawl",
 	brave: "Brave",
+	deepseek: "DeepSeek",
 	kimi: "Kimi",
 	synthetic: "Synthetic",
 	ollama: "Ollama",

package/src/tui.ts

@@ -107,6 +107,11 @@ const PAINT_END_NO_SYNC = ENABLE_AUTOWRAP;
 // native text selection.
 const MOUSE_TRACKING_ON = "\x1b[?1000h\x1b[?1003h\x1b[?1006h";
 const MOUSE_TRACKING_OFF = "\x1b[?1006l\x1b[?1003l\x1b[?1000l";
+// Cell-size replies: CSI 6 ; height ; width t in pixels, and iTerm2's
+// OSC 1337 ; ReportCellSize = height ; width [; scale] ST in points.
+const CELL_SIZE_REPLY = /^\x1b\[6;(\d+);(\d+)t$/;
+const ITERM2_CELL_SIZE_REPLY =
+	/^\x1b\]1337;ReportCellSize=(\d+(?:\.\d+)?);(\d+(?:\.\d+)?)(?:;(\d+(?:\.\d+)?))?(?:\x07|\x1b\\)$/;
 
 type MouseTrackingState = "off" | "inline" | "full";
 
@@ -2562,6 +2567,9 @@ export class TUI extends Container {
 		// Query terminal for cell size in pixels: CSI 16 t
 		// Response format: CSI 6 ; height ; width t
 		this.terminal.write("\x1b[16t");
+		// iTerm2 never answers CSI 16 t. Without a size, rows reserved for an image
+		// and crops of a partly scrolled one assume 9x18 cells and land offset.
+		if (TERMINAL.imageProtocol === ImageProtocol.Iterm2) this.terminal.write("\x1b]1337;ReportCellSize\x1b\\");
 	}
 
 	/**
@@ -3051,14 +3059,19 @@ export class TUI extends Container {
 	}
 
 	#consumeCellSizeResponse(data: string): boolean {
-		// Response format: ESC [ 6 ; height ; width t
-		const match = data.match(/^\x1b\[6;(\d+);(\d+)t$/);
-		if (!match) {
-			return false;
+		let heightPx: number;
+		let widthPx: number;
+		const pixels = CELL_SIZE_REPLY.exec(data);
+		if (pixels) {
+			heightPx = parseInt(pixels[1], 10);
+			widthPx = parseInt(pixels[2], 10);
+		} else {
+			const points = ITERM2_CELL_SIZE_REPLY.exec(data);
+			if (!points) return false;
+			const scale = points[3] ? Number(points[3]) : 1;
+			heightPx = Math.round(Number(points[1]) * scale);
+			widthPx = Math.round(Number(points[2]) * scale);
 		}
-
-		const heightPx = parseInt(match[1], 10);
-		const widthPx = parseInt(match[2], 10);
 		if (heightPx <= 0 || widthPx <= 0) {
 			return true;
 		}