@gajae-code/tui 0.12.0 → 0.12.2

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [0.12.2] - 2026-07-30
+
+## [0.12.1] - 2026-07-29
+
+### Fixed
+
+- Kitty/Ghostty inline images no longer remain visually pinned when sticky or semantic viewport repaints move their anchors into application scrollback. The renderer now soft-deletes only the named placement from the old viewport, retains uploaded pixels for history replay, and keeps placement tracking aligned across unresolved-anchor and follow-live transitions.
+
 ## [0.12.0] - 2026-07-28
 
 ### Changed
@@ -13,6 +21,10 @@
 
 ### Fixed
 
+- Slash-command autocomplete no longer treats the final segment of a nested filesystem path or URL as a command token, preventing accepted skill suggestions from rewriting literal paths.
+
+- Terminal capability-probe replies no longer leak into the prompt as text (`^[]11;rgb:0000/0000/0000^G^[[?62;22;52c` appearing in the editor after a long-running foreground command). Three separate paths fed them to the input handler: replies whose pending-query counters had already been reset (`stop()`/`start()` around an editor handoff, Ctrl+Z, or a session resume) failed the `#pendingDa1Sentinels`/`#osc11Pending` gates and were forwarded; a reply split across stdin reads with a gap larger than `StdinBuffer`'s 10ms completion timeout was flushed as individual characters; and an unterminated sequence kept absorbing the following ESC. Probe replies are now consumed by shape, incomplete probe-reply prefixes are held at the stdin decoding boundary (bounded by 500ms/256 bytes, and only 150ms for a bare ESC inside a probe window), an ESC cuts the sequence in progress unless it is an OSC/DCS/APC string terminator, and an unsolicited reply is dropped by an explicit backstop. A dropped or mangled reply can no longer latch `#osc11Pending` either: a 1s watchdog and a 64-byte reassembly cap resolve the query cycle instead of swallowing keystrokes. DA1 and XTSMGRAPHICS replies stay owned by the sixel probe and are dropped in `Tui` once that probe has finished, so an orphaned device report is no longer typed into the focused component.
+
 - `waitForRenderCommit` / generation-scoped render tokens resolve only after a successful buffer write (or fail open on stopped/unavailable terminals), enabling awaitable progress frames for interactive resume without hanging (#2914).
 - Streaming layout contraction followed by regrowth no longer re-admits an already committed logical row into native terminal scrollback, preventing occasional duplicated assistant lines after Markdown reflow.
 - Repeated clearing of an already-clear viewport output source is now a render-request no-op, matching identical non-null source updates.

package/dist/types/stdin-buffer.d.ts

@@ -45,6 +45,12 @@ export declare class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
     #private;
     constructor(options?: StdinBufferOptions);
     process(data: string | Buffer): void;
+    /**
+     * ProcessTerminal calls this right after writing a capability probe so a lone
+     * ESC arriving inside the reply window is treated as a possible reply fragment
+     * rather than a keypress.
+     */
+    noteProbeIssued(windowMs?: number): void;
     flush(): string[];
     clear(): void;
     getBuffer(): string;

package/dist/types/terminal-capabilities.d.ts

@@ -158,6 +158,15 @@ export declare function encodeKittyPlacement(options: {
     columns: number;
     rows: number;
 }): string;
+export interface KittyPlacementReference {
+    imageId: number;
+    placementId: number;
+    rows: number;
+}
+/** Extract bounded, named kitty placements from a rendered line. */
+export declare function extractKittyPlacementReferences(line: string): KittyPlacementReference[];
+/** Soft-delete one named kitty placement while retaining its transmitted pixels. */
+export declare function encodeKittyPlacementDelete(reference: KittyPlacementReference): string;
 export declare function encodeITerm2(base64Data: string, options?: {
     width?: number | string;
     height?: number | string;

package/dist/types/terminal.d.ts

@@ -1,3 +1,19 @@
+/**
+ * Capability-probe reply shapes that only this layer solicits (OSC 11 background
+ * color, the Mode 2031 appearance DSR, and the Kitty keyboard-flags report).
+ * These are terminal-to-host replies and are NEVER legitimate user input, so a
+ * reply that arrives outside its pending-query window is dropped defensively.
+ *
+ * DA1 is deliberately absent: `Tui` issues its own DA1 request for the sixel
+ * probe and consumes that reply downstream.
+ */
+export declare const PROBE_REPLY_PATTERNS: ReadonlyArray<{
+    name: string;
+    issuedProbe: string;
+    pattern: RegExp;
+}>;
+/** True when `sequence` is one of the probe replies above. */
+export declare function isUnsolicitedProbeReply(sequence: string): boolean;
 /**
  * Whether GJC may reprogram the keyboard with enhanced input protocols
  * (the Kitty keyboard protocol and the xterm modifyOtherKeys fallback).

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/tui",
-	"version": "0.12.0",
+	"version": "0.12.2",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -36,8 +36,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@gajae-code/natives": "0.12.0",
-		"@gajae-code/utils": "0.12.0",
+		"@gajae-code/natives": "0.12.2",
+		"@gajae-code/utils": "0.12.2",
 		"lru-cache": "11.3.6",
 		"marked": "18.0.6"
 	},

package/src/autocomplete.ts

@@ -229,6 +229,10 @@ export function extractSlashCommandTokenPrefix(text: string): string | null {
 	const charBeforeSlash = text[slashIndex - 1];
 	if (charBeforeSlash && NON_COMMAND_SLASH_PREFIX_PRECEDERS.has(charBeforeSlash)) return null;
 
+	let tokenStart = slashIndex;
+	while (tokenStart > 0 && !/\s/.test(text[tokenStart - 1] ?? "")) tokenStart -= 1;
+	if (text.slice(tokenStart, slashIndex).includes("/")) return null;
+
 	return token;
 }
 export interface AutocompleteItem {

package/src/keys.ts

@@ -423,7 +423,6 @@ const KITTY_MOD_SUPER = 8;
 const KITTY_MOD_NUM_LOCK = 128;
 const KITTY_LOCK_MASK = 64 + 128; // Caps Lock + Num Lock
 const MODIFY_OTHER_KEYS_PATTERN = /^\x1b\[27;(\d+);(\d+)~$/;
-const PSMUX_MODIFIED_ENTER_PATTERN = /^\x1b\[13;(2|6)~$/;
 const KITTY_KEYPAD_OPERATOR_TEXT: Record<number, string> = {
 	57410: "/",
 	57411: "*",
@@ -496,21 +495,6 @@ export function parseKittySequence(data: string): ParsedKittySequence | null {
 		eventType: result.eventType,
 	};
 }
-
-function parsePsmuxModifiedEnter(data: string): string | undefined {
-	const match = data.match(PSMUX_MODIFIED_ENTER_PATTERN);
-	if (!match) return undefined;
-	return match[1] === "6" ? "shift+ctrl+enter" : "shift+enter";
-}
-
-function matchesPsmuxModifiedEnter(data: string, keyId: KeyId): boolean {
-	const parsed = parsePsmuxModifiedEnter(data);
-	if (!parsed) return false;
-	const expected = String(keyId);
-	if (parsed === expected) return true;
-	return parsed === "shift+ctrl+enter" && expected === "ctrl+shift+enter";
-}
-
 function hasControlChars(data: string): boolean {
 	return [...data].some(ch => {
 		const code = ch.charCodeAt(0);
@@ -654,7 +638,7 @@ export function decodePrintableKey(data: string): string | undefined {
  * @param keyId - Key identifier (e.g., "ctrl+c", "escape", Key.ctrl("c"))
  */
 export function matchesKey(data: string, keyId: KeyId): boolean {
-	return matchesPsmuxModifiedEnter(data, keyId) || matchesKeyNative(data, keyId, kittyProtocolActive);
+	return matchesKeyNative(data, keyId, kittyProtocolActive);
 }
 
 /**
@@ -666,5 +650,5 @@ export function matchesKey(data: string, keyId: KeyId): boolean {
  * @param data - Raw input data from terminal
  */
 export function parseKey(data: string): string | undefined {
-	return parsePsmuxModifiedEnter(data) ?? parseKeyNative(data, kittyProtocolActive) ?? undefined;
+	return parseKeyNative(data, kittyProtocolActive) ?? undefined;
 }

package/src/stdin-buffer.ts

@@ -26,6 +26,25 @@ const BRACKETED_PASTE_END = "\x1b[201~";
 const SGR_QUARANTINE_MAX_BYTES = 256;
 const SGR_QUARANTINE_TIMEOUT_MS = 100;
 
+// Bounds for holding an incomplete terminal capability-probe reply instead of
+// flushing its fragments into the input stream.
+const PROBE_FRAGMENT_HOLD_MAX_MS = 500;
+const PROBE_FRAGMENT_MAX_BYTES = 256;
+const PROBE_ESCAPE_HOLD_MAX_MS = 150;
+const PROBE_REPLY_WINDOW_MS = 2500;
+
+/**
+ * True when the buffer is an escape sequence that only a terminal reply can
+ * complete: an OSC without its BEL/ST terminator (OSC 11 background color) or a
+ * private CSI without its final byte (DA1, kitty flags, Mode 2031 DSR).
+ * SGR mouse prefixes are excluded; they have their own quarantine.
+ */
+function isIncompleteProbeReplyPrefix(buffer: string): boolean {
+	if (buffer.length > PROBE_FRAGMENT_MAX_BYTES) return false;
+	if (/^\x1b\][^\x07\x1b]*$/.test(buffer)) return true;
+	return /^\x1b\[\??[\d;]*$/.test(buffer);
+}
+
 /** True for complete SGR mouse CSI reports. These remain control input, never text. */
 export function isSgrMouseSequence(sequence: string): boolean {
 	return /^\x1b\[<\d+;\d+;\d+[Mm]$/.test(sequence);
@@ -238,6 +257,19 @@ function parseUnmodifiedKittyPrintableCodepoint(sequence: string): number | unde
 	return codepoint >= 32 ? codepoint : undefined;
 }
 
+/**
+ * True when the ESC at `index` can still continue the escape sequence that
+ * started at offset 0, i.e. it is (or may become) the ST terminator `ESC \` of
+ * an OSC/DCS/APC string. Anywhere else an ESC cancels the sequence in progress.
+ */
+function continuesAsStringTerminator(remaining: string, index: number): boolean {
+	const introducer = remaining[1];
+	if (introducer !== "]" && introducer !== "P" && introducer !== "_") return false;
+	const afterEsc = remaining[index + 1];
+	// Terminator not fully delivered yet: keep buffering rather than guessing.
+	return afterEsc === undefined || afterEsc === "\\";
+}
+
 function extractCompleteSequences(buffer: string): { sequences: string[]; remainder: string } {
 	const sequences: string[] = [];
 	let pos = 0;
@@ -270,6 +302,15 @@ function extractCompleteSequences(buffer: string): { sequences: string[]; remain
 					pos += seqEnd;
 					break;
 				} else if (status === "incomplete") {
+					// An ESC cancels an escape sequence already in progress; it can only
+					// continue one as the ST terminator of an OSC/DCS/APC string. Cutting
+					// here keeps an unterminated sequence from swallowing the next key.
+					// seqEnd === 1 is excluded so Meta sequences (ESC ESC) still parse.
+					if (remaining[seqEnd] === ESC && seqEnd >= 2 && !continuesAsStringTerminator(remaining, seqEnd)) {
+						sequences.push(candidate);
+						pos += seqEnd;
+						break;
+					}
 					seqEnd++;
 				} else {
 					// Should not happen when starting with ESC
@@ -346,6 +387,10 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	#sgrQuarantineBytes = 0;
 	#sgrQuarantineSemicolons = 0;
 	#sgrQuarantineHasDigit = false;
+	// Probe-reply fragment hold.
+	#probeHoldStartedAt: number | undefined;
+	#probeHoldBuffer = "";
+	#probeReplyWindowUntil = 0;
 
 	constructor(options: StdinBufferOptions = {}) {
 		super();
@@ -497,17 +542,10 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			this.#emitDataSequence(sequence);
 		}
 
-		if (this.#buffer.length > 0) {
-			this.#timeout = setTimeout(() => {
-				if (isSgrMousePrefix(this.#buffer)) {
-					this.#beginSgrQuarantine();
-					return;
-				}
-				const flushed = this.flush();
-				for (const sequence of flushed) {
-					this.#emitDataSequence(sequence);
-				}
-			}, this.#timeoutMs);
+		if (this.#buffer.length === 0) {
+			this.#probeHoldStartedAt = undefined;
+		} else {
+			this.#timeout = setTimeout(() => this.#onFlushTimeout(), this.#timeoutMs);
 		}
 	}
 
@@ -599,12 +637,61 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.emit("data", sequence);
 	}
 
+	/**
+	 * ProcessTerminal calls this right after writing a capability probe so a lone
+	 * ESC arriving inside the reply window is treated as a possible reply fragment
+	 * rather than a keypress.
+	 */
+	noteProbeIssued(windowMs: number = PROBE_REPLY_WINDOW_MS): void {
+		this.#probeReplyWindowUntil = Date.now() + windowMs;
+	}
+
+	#onFlushTimeout(): void {
+		if (isSgrMousePrefix(this.#buffer)) {
+			this.#beginSgrQuarantine();
+			return;
+		}
+		if (this.#shouldHoldProbeFragment()) {
+			this.#timeout = setTimeout(() => this.#onFlushTimeout(), this.#timeoutMs);
+			return;
+		}
+		this.#probeHoldStartedAt = undefined;
+		const flushed = this.flush();
+		for (const sequence of flushed) {
+			this.#emitDataSequence(sequence);
+		}
+	}
+
+	#shouldHoldProbeFragment(): boolean {
+		const buffer = this.#buffer;
+		if (buffer.length === 0) return false;
+		const now = Date.now();
+		const bareEscape = buffer === "\x1b";
+		if (bareEscape) {
+			// A lone ESC is a real key press: only hold it while a probe reply is
+			// still expected, and only briefly.
+			if (now >= this.#probeReplyWindowUntil) return false;
+		} else if (!isIncompleteProbeReplyPrefix(buffer)) {
+			return false;
+		}
+		if (this.#probeHoldStartedAt === undefined || this.#probeHoldBuffer !== buffer) {
+			// Restart the clock whenever the fragment makes progress. A start stamp left
+			// over from an earlier fragment expired every later hold instantly, so a
+			// reply split across many reads still leaked character by character.
+			this.#probeHoldStartedAt = now;
+			this.#probeHoldBuffer = buffer;
+		}
+		const limit = bareEscape ? PROBE_ESCAPE_HOLD_MAX_MS : PROBE_FRAGMENT_HOLD_MAX_MS;
+		return now - this.#probeHoldStartedAt < limit;
+	}
+
 	flush(): string[] {
 		if (this.#timeout) {
 			clearTimeout(this.#timeout);
 			this.#timeout = undefined;
 		}
 		if (this.#sgrQuarantine) this.#endSgrQuarantine();
+		this.#probeHoldStartedAt = undefined;
 
 		const pendingMeta = this.#consumePendingSingleUtf8LeadAsMeta();
 
@@ -637,6 +724,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#sgrQuarantineBytes = 0;
 		this.#sgrQuarantineSemicolons = 0;
 		this.#sgrQuarantineHasDigit = false;
+		this.#probeHoldStartedAt = undefined;
 		// Drop any incomplete multi-byte sequence the decoder is holding so a
 		// stale partial prefix cannot combine with future input. destroy()
 		// resets the decoder by calling clear().

package/src/terminal-capabilities.ts

@@ -514,6 +514,68 @@ export function encodeKittyPlacement(options: {
 	return `\x1b_Ga=p,i=${options.imageId},p=${options.placementId},c=${options.columns},r=${options.rows},C=1,q=2\x1b\\`;
 }
 
+export interface KittyPlacementReference {
+	imageId: number;
+	placementId: number;
+	rows: number;
+}
+
+const MAX_KITTY_CONTROL_CHARS = 4096;
+const MAX_KITTY_PLACEMENTS_PER_LINE = 1024;
+const MAX_KITTY_PLACEMENT_SCAN_CHARS = 256 * 1024;
+const MAX_KITTY_PLACEMENT_SCAN_BYTES = 256 * 1024;
+const MAX_KITTY_UINT32 = 0xffff_ffff;
+const MAX_KITTY_CONTROL_FIELDS = 64;
+
+function parseKittyUint32(raw: string | undefined): number | null {
+	if (raw === undefined || raw.length === 0 || raw.length > 10 || !/^\d+$/u.test(raw)) return null;
+	const value = Number(raw);
+	return Number.isInteger(value) && value > 0 && value <= MAX_KITTY_UINT32 ? value : null;
+}
+
+/** Extract bounded, named kitty placements from a rendered line. */
+export function extractKittyPlacementReferences(line: string): KittyPlacementReference[] {
+	if (line.length > MAX_KITTY_PLACEMENT_SCAN_CHARS) return [];
+	if (!line.includes(ImageProtocol.Kitty) || Buffer.byteLength(line) > MAX_KITTY_PLACEMENT_SCAN_BYTES) return [];
+	const placements: KittyPlacementReference[] = [];
+	for (const match of line.matchAll(/\x1b_G([^;\x1b]*)(?:;([^\x1b]*))?\x1b\\/gu)) {
+		const control = match[1] ?? "";
+		if (control.length === 0 || control.length > MAX_KITTY_CONTROL_CHARS || match[2] !== undefined) continue;
+		const parts = control.split(",");
+		if (parts.length > MAX_KITTY_CONTROL_FIELDS) continue;
+
+		const params = new Map<string, string>();
+		let valid = true;
+		for (const part of parts) {
+			const separator = part.indexOf("=");
+			if (separator !== 1 || part.length === 2) {
+				valid = false;
+				break;
+			}
+			const key = part[0];
+			if (!/[A-Za-z]/u.test(key) || params.has(key)) {
+				valid = false;
+				break;
+			}
+			params.set(key, part.slice(2));
+		}
+		if (!valid || params.get("a") !== "p" || params.get("C") !== "1" || params.has("m")) continue;
+
+		const imageId = parseKittyUint32(params.get("i"));
+		const placementId = parseKittyUint32(params.get("p"));
+		const rows = parseKittyUint32(params.get("r"));
+		if (imageId === null || placementId === null || rows === null) continue;
+		placements.push({ imageId, placementId, rows });
+		if (placements.length > MAX_KITTY_PLACEMENTS_PER_LINE) return [];
+	}
+	return placements;
+}
+
+/** Soft-delete one named kitty placement while retaining its transmitted pixels. */
+export function encodeKittyPlacementDelete(reference: KittyPlacementReference): string {
+	return `\x1b_Ga=d,d=i,i=${reference.imageId},p=${reference.placementId},q=2\x1b\\`;
+}
+
 export function encodeITerm2(
 	base64Data: string,
 	options: {
@@ -755,8 +817,8 @@ export function renderImage(
 		// and ALL of its placements (breaking sibling components showing the
 		// same content) and would re-send multi-MB payloads on every repaint.
 		if (!transmittedKittyImageIds.has(imageId)) {
-			transmittedKittyImageIds.add(imageId);
 			(options.onTransmit ?? kittyTransmitWriter)(encodeKittyTransmit(base64Data, imageId));
+			transmittedKittyImageIds.add(imageId);
 		}
 		const sequence = encodeKittyPlacement({ imageId, placementId, columns: fit.columns, rows: fit.rows });
 		return { sequence, rows: fit.rows, cursorNeutral: true };

package/src/terminal.ts

@@ -8,6 +8,33 @@ const TERMINAL_PROGRESS_KEEPALIVE_MS = 1000;
 const TERMINAL_PROGRESS_ACTIVE_SEQUENCE = "\x1b]9;4;3\x07";
 const TERMINAL_PROGRESS_CLEAR_SEQUENCE = "\x1b]9;4;0;\x07";
 
+/**
+ * Capability-probe reply shapes that only this layer solicits (OSC 11 background
+ * color, the Mode 2031 appearance DSR, and the Kitty keyboard-flags report).
+ * These are terminal-to-host replies and are NEVER legitimate user input, so a
+ * reply that arrives outside its pending-query window is dropped defensively.
+ *
+ * DA1 is deliberately absent: `Tui` issues its own DA1 request for the sixel
+ * probe and consumes that reply downstream.
+ */
+export const PROBE_REPLY_PATTERNS: ReadonlyArray<{ name: string; issuedProbe: string; pattern: RegExp }> = [
+	{
+		name: "osc11-background",
+		issuedProbe: "\x1b]11;?\x07",
+		pattern: /^\x1b\]11;rgba?:[0-9a-fA-F]{1,4}\/[0-9a-fA-F]{1,4}\/[0-9a-fA-F]{1,4}(?:\x07|\x1b\\)$/,
+	},
+	{ name: "mode2031-dsr", issuedProbe: "\x1b[?2031h", pattern: /^\x1b\[\?997;[12]n$/ },
+	{ name: "kitty-flags", issuedProbe: "\x1b[?u", pattern: /^\x1b\[\?\d+u$/ },
+];
+
+/** True when `sequence` is one of the probe replies above. */
+export function isUnsolicitedProbeReply(sequence: string): boolean {
+	for (const entry of PROBE_REPLY_PATTERNS) {
+		if (entry.pattern.test(sequence)) return true;
+	}
+	return false;
+}
+
 /**
  * Whether GJC may reprogram the keyboard with enhanced input protocols
  * (the Kitty keyboard protocol and the xterm modifyOtherKeys fallback).
@@ -222,6 +249,10 @@ export class ProcessTerminal implements Terminal {
 	#privateCsiResponseBuffer = "";
 	#pendingDa1Sentinels = 0;
 	#osc11PollTimer?: Timer;
+	// Bounds the OSC 11 / DA1 pending-query window so a dropped or mangled reply
+	// (multiplexer, TERM=dumb host) cannot latch #osc11Pending forever and freeze
+	// stdin.
+	#osc11QueryWatchdog?: Timer;
 	#mode2031DebounceTimer?: Timer;
 	#progressTimer?: ReturnType<typeof setInterval>;
 	#mouseEnabled = false;
@@ -318,6 +349,7 @@ export class ProcessTerminal implements Terminal {
 		// When the terminal reports a change, we re-query OSC 11 to get the
 		// actual background color (following Neovim convention) with 100ms debounce.
 		this.#safeWrite("\x1b[?2031h");
+		this.#stdinBuffer?.noteProbeIssued();
 
 		// Start periodic OSC 11 re-query for terminals without Mode 2031
 		// (Warp, Alacritty, WezTerm, iTerm2). Self-disables once Mode 2031 fires.
@@ -415,10 +447,11 @@ export class ProcessTerminal implements Terminal {
 			// flush timeout elapses mid-sequence, the prefix `\x1b[?<digits>` arrives as
 			// one event and the tail `;...<terminator>` arrives as individual character
 			// events that would otherwise leak into the prompt as keystrokes. See #1238.
-			if (
-				this.#privateCsiResponseBuffer ||
-				(privateCsiPartialPattern.test(sequence) && this.#pendingDa1Sentinels > 0)
-			) {
+			// Reassembly is keyed on the reply's shape, not on `#pendingDa1Sentinels`:
+			// replies the terminal still owed after a counter reset (stop()/start()
+			// around a foreground command) otherwise leaked into the editor one
+			// character at a time. No keystroke can produce this prefix.
+			if (this.#privateCsiResponseBuffer || privateCsiPartialPattern.test(sequence)) {
 				if (this.#privateCsiResponseBuffer && sequence.startsWith("\x1b")) {
 					// New escape arrived mid-reassembly — abandon partial and re-process the new sequence.
 					this.#privateCsiResponseBuffer = "";
@@ -491,7 +524,7 @@ export class ProcessTerminal implements Terminal {
 			// Accumulate fragments until the BEL/ST terminator arrives, then parse once.
 			// If a new escape sequence arrives (not the ST terminator), abort buffering
 			// and forward it as normal input so user keystrokes are never swallowed.
-			if (this.#osc11Pending && (this.#osc11ResponseBuffer || sequence.startsWith("\x1b]11;"))) {
+			if (this.#osc11ResponseBuffer || sequence.startsWith("\x1b]11;")) {
 				if (this.#osc11ResponseBuffer && sequence.startsWith("\x1b") && sequence !== "\x1b\\") {
 					// New escape sequence arrived mid-buffer — not an OSC 11 continuation.
 					this.#osc11ResponseBuffer = "";
@@ -499,12 +532,25 @@ export class ProcessTerminal implements Terminal {
 				} else {
 					this.#osc11ResponseBuffer += sequence;
 					const osc11Match = this.#osc11ResponseBuffer.match(osc11ResponsePattern);
-					if (!osc11Match) return;
-					const [, rHex, gHex, bHex] = osc11Match;
-					this.#osc11Pending = false;
-					this.#osc11ResponseBuffer = "";
-					this.#handleOsc11Response(rHex!, gHex!, bHex!);
-					return;
+					if (osc11Match) {
+						const [, rHex, gHex, bHex] = osc11Match;
+						this.#osc11Pending = false;
+						this.#osc11ResponseBuffer = "";
+						this.#clearOsc11QueryWatchdog();
+						this.#handleOsc11Response(rHex!, gHex!, bHex!);
+						return;
+					}
+					// Bound the reassembly buffer. A real reply is <= ~25 bytes; if the
+					// terminator is dropped or mangled (multiplexer, TERM=dumb) an unbounded
+					// buffer swallows every following keystroke and freezes input. Past the
+					// cap, abandon reassembly and let the sequence fall through as input.
+					if (this.#osc11ResponseBuffer.length > 64) {
+						this.#osc11Pending = false;
+						this.#osc11ResponseBuffer = "";
+						this.#clearOsc11QueryWatchdog();
+					} else {
+						return;
+					}
 				}
 			}
 
@@ -520,6 +566,13 @@ export class ProcessTerminal implements Terminal {
 				}, 100);
 				return;
 			}
+			// Defensive backstop. A capability-probe reply reaching this point arrived
+			// outside its pending-query window, so none of the handlers above consumed
+			// it. These shapes are never user input, and paste content never reaches
+			// this handler, so dropping is always safe.
+			if (isUnsolicitedProbeReply(sequence)) {
+				return;
+			}
 			if (this.#inputHandler) {
 				this.#inputHandler(sequence);
 			}
@@ -562,6 +615,39 @@ export class ProcessTerminal implements Terminal {
 		this.#pendingDa1Sentinels++;
 		this.#safeWrite("\x1b]11;?\x07"); // OSC 11 query (BEL terminated)
 		this.#safeWrite("\x1b[c"); // DA1 sentinel
+		this.#stdinBuffer?.noteProbeIssued();
+		this.#armOsc11QueryWatchdog();
+	}
+
+	/**
+	 * OSC 11 pending-query watchdog. If neither the OSC 11 reply nor its DA1
+	 * sentinel comes back (dropped by a multiplexer or a TERM=dumb host),
+	 * #osc11Pending / #pendingDa1Sentinels latch forever: #queryBackgroundColor
+	 * stops re-querying and the reassembly branch swallows keystrokes.
+	 * Force-resolve the cycle after a bounded wait so the state machine self-heals.
+	 */
+	#armOsc11QueryWatchdog(): void {
+		this.#clearOsc11QueryWatchdog();
+		this.#osc11QueryWatchdog = setTimeout(() => {
+			this.#osc11QueryWatchdog = undefined;
+			if (this.#dead) return;
+			if (!this.#osc11Pending && this.#pendingDa1Sentinels === 0) return;
+			this.#osc11Pending = false;
+			this.#osc11ResponseBuffer = "";
+			this.#pendingDa1Sentinels = 0;
+			if (this.#osc11QueryQueued && !this.#dead) {
+				this.#osc11QueryQueued = false;
+				this.#startOsc11Query();
+			}
+		}, 1000);
+		this.#osc11QueryWatchdog.unref?.();
+	}
+
+	#clearOsc11QueryWatchdog(): void {
+		if (this.#osc11QueryWatchdog) {
+			clearTimeout(this.#osc11QueryWatchdog);
+			this.#osc11QueryWatchdog = undefined;
+		}
 	}
 	/**
 	 * Parse an OSC 11 background color response and compute BT.601 luminance.
@@ -631,6 +717,7 @@ export class ProcessTerminal implements Terminal {
 			return;
 		}
 		this.#safeWrite("\x1b[?u");
+		this.#stdinBuffer?.noteProbeIssued();
 		// Windows Terminal and conhost do not implement the Kitty keyboard
 		// protocol, so the query above never activates it there. They do honor the
 		// modifyOtherKeys fallback below — but that mode breaks Windows CJK/Hangul