@oh-my-pi/pi-tui 14.9.5 → 14.9.8

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 ## [Unreleased]
 
+## [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`)
+
+### 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
+
+### Changed
+
+- 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
+
+- 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

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "14.9.5",
+	"version": "14.9.8",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -37,8 +37,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "14.9.5",
-		"@oh-my-pi/pi-utils": "14.9.5",
+		"@oh-my-pi/pi-natives": "14.9.8",
+		"@oh-my-pi/pi-utils": "14.9.8",
 		"lru-cache": "11.3.6",
 		"marked": "^18.0.3"
 	},

package/src/autocomplete.ts

@@ -156,12 +156,15 @@ export interface AutocompleteItem {
 	hint?: string;
 }
 
+type Awaitable<T> = T | Promise<T>;
+
 export interface SlashCommand {
 	name: string;
 	description?: string;
+	argumentHint?: string;
 	// Function to get argument completions for this command
 	// Returns null if no argument completion is available
-	getArgumentCompletions?(argumentPrefix: string): AutocompleteItem[] | null;
+	getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
 	/** Return inline hint text for the current argument state (shown as dim ghost text after cursor) */
 	getInlineHint?(argumentText: string): string | null;
 }
@@ -268,11 +271,14 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 						// Score name matches higher than description matches
 						const nameScore = fuzzyMatch(lowerPrefix, lowerName) ? fuzzyScore(lowerPrefix, lowerName) : 0;
 						const descScore = fuzzyMatch(lowerPrefix, lowerDesc) ? fuzzyScore(lowerPrefix, lowerDesc) * 0.5 : 0;
+						const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : undefined;
+						const desc = cmd.description ?? "";
+						const fullDesc = hint ? (desc ? `${hint} — ${desc}` : hint) : desc;
 						return {
 							value: name,
 							label: "name" in cmd ? cmd.name : cmd.label,
 							score: Math.max(nameScore, descScore),
-							...(cmd.description && { description: cmd.description }),
+							...(fullDesc && { description: fullDesc }),
 						};
 					})
 					.sort((a, b) => b.score - a.score)
@@ -297,8 +303,8 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 					return null; // No argument completion for this command
 				}
 
-				const argumentSuggestions = command.getArgumentCompletions(argumentText);
-				if (!argumentSuggestions || argumentSuggestions.length === 0) {
+				const argumentSuggestions = await command.getArgumentCompletions(argumentText);
+				if (!Array.isArray(argumentSuggestions) || argumentSuggestions.length === 0) {
 					return null;
 				}
 
@@ -802,11 +808,14 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 				const lowerDesc = cmd.description?.toLowerCase() ?? "";
 				const nameScore = fuzzyMatch(lowerPrefix, lowerName) ? fuzzyScore(lowerPrefix, lowerName) : 0;
 				const descScore = fuzzyMatch(lowerPrefix, lowerDesc) ? fuzzyScore(lowerPrefix, lowerDesc) * 0.5 : 0;
+				const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : undefined;
+				const desc = cmd.description ?? "";
+				const fullDesc = hint ? (desc ? `${hint} — ${desc}` : hint) : desc;
 				return {
 					value: name,
 					label: "name" in cmd ? cmd.name : cmd.label,
 					score: Math.max(nameScore, descScore),
-					...(cmd.description && { description: cmd.description }),
+					...(fullDesc && { description: fullDesc }),
 				} as AutocompleteItem & { score: number };
 			})
 			.sort((a, b) => b.score - a.score)

package/src/components/editor.ts

@@ -1543,8 +1543,20 @@ export class Editor implements Component, Focusable {
 		this.#recordUndoState();
 
 		this.#withUndoSuspended(() => {
+			// Some terminals (e.g. tmux popups with extended-keys-format=csi-u) re-encode
+			// control bytes inside bracketed paste as CSI-u Ctrl+<letter> sequences
+			// (ESC [ <codepoint> ; 5 u). Decode those back to their literal byte so the
+			// per-char filter below preserves newlines instead of stripping ESC and
+			// leaking the printable tail (e.g. "[106;5u") into the editor.
+			const decodedText = pastedText.replace(/\x1b\[(\d+);5u/g, (match, code) => {
+				const cp = Number(code);
+				if (cp >= 97 && cp <= 122) return String.fromCharCode(cp - 96);
+				if (cp >= 65 && cp <= 90) return String.fromCharCode(cp - 64);
+				return match;
+			});
+
 			// Clean the pasted text
-			const cleanText = pastedText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+			const cleanText = decodedText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 
 			// Convert tabs to spaces (4 spaces per tab)
 			const tabExpandedText = cleanText.replace(/\t/g, "    ");
@@ -2427,7 +2439,7 @@ export class Editor implements Component, Focusable {
 		);
 		if (requestId !== this.#autocompleteRequestId) return;
 
-		if (suggestions && suggestions.items.length > 0) {
+		if (suggestions && Array.isArray(suggestions.items) && suggestions.items.length > 0) {
 			this.#autocompletePrefix = suggestions.prefix;
 			this.#autocompleteList = this.#createAutocompleteList(suggestions.prefix, suggestions.items);
 			this.#autocompleteState = "regular";
@@ -2491,7 +2503,7 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
 		);
 		if (requestId !== this.#autocompleteRequestId) return;
 
-		if (suggestions && suggestions.items.length > 0) {
+		if (suggestions && Array.isArray(suggestions.items) && suggestions.items.length > 0) {
 			// If there's exactly one suggestion and this was an explicit Tab press, apply it immediately
 			if (explicitTab && suggestions.items.length === 1) {
 				const item = suggestions.items[0]!;
@@ -2557,7 +2569,7 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
 		);
 		if (requestId !== this.#autocompleteRequestId) return;
 
-		if (suggestions && suggestions.items.length > 0) {
+		if (suggestions && Array.isArray(suggestions.items) && suggestions.items.length > 0) {
 			this.#autocompletePrefix = suggestions.prefix;
 			// Always create new SelectList to ensure update
 			this.#autocompleteList = this.#createAutocompleteList(suggestions.prefix, suggestions.items);

package/src/components/markdown.ts

@@ -1,10 +1,34 @@
 import { LRUCache } from "lru-cache/raw";
-import { marked, type Token, type Tokens } from "marked";
+import { Marked, marked, type Token, Tokenizer, type Tokens } from "marked";
 import type { SymbolTheme } from "../symbols";
 import { TERMINAL } from "../terminal-capabilities";
 import type { Component } from "../tui";
 import { applyBackgroundToLine, padding, replaceTabs, visibleWidth, wrapTextWithAnsi } from "../utils";
 
+const STRICT_STRIKETHROUGH_REGEX = /^(~~)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/;
+
+class StrictStrikethroughTokenizer extends Tokenizer {
+	override del(src: string): Tokens.Del | undefined {
+		const match = STRICT_STRIKETHROUGH_REGEX.exec(src);
+		if (!match) {
+			return undefined;
+		}
+
+		const text = match[2];
+		return {
+			type: "del",
+			raw: match[0],
+			text,
+			tokens: this.lexer.inlineTokens(text),
+		};
+	}
+}
+
+const markdownParser = new Marked();
+markdownParser.setOptions({
+	tokenizer: new StrictStrikethroughTokenizer(),
+});
+
 // ---------------------------------------------------------------------------
 // Module-level LRU render cache
 // ---------------------------------------------------------------------------
@@ -172,7 +196,18 @@ export class Markdown implements Component {
 		// L2: module-level LRU — survives component disposal/recreation across
 		// session-tree navigations. Key encodes every dimension that affects the
 		// render output so different configurations never collide.
-		const cacheKey = `${normalizedText}\x00${width}\x00${this.#paddingX}\x00${this.#paddingY}\x00${this.#codeBlockIndent}\x00${objectId(this.#theme)}\x00${this.#defaultTextStyle ? objectId(this.#defaultTextStyle) : -1}`;
+		// Encode terminal capability state and theme/style function output samples
+		// so that capability shifts (image protocol changes, hyperlink toggle) or
+		// caller-supplied theme/bgColor functions that mutate their output without
+		// changing object identity invalidate the cache entry.
+		// bgColor probe uses \x01 (single non-printable byte): chalk/ANSI wrappers
+		// pass arbitrary bytes through verbatim, so this is safe and minimizes the
+		// risk of clashing with a function that returns text verbatim.
+		// theme.heading is used as the representative theme probe — it's required
+		// by MarkdownTheme and is one of the most styling-sensitive entries.
+		const bgColorProbe = this.#defaultTextStyle?.bgColor ? this.#defaultTextStyle.bgColor("\x01") : "";
+		const headingProbe = this.#theme.heading("");
+		const cacheKey = `${normalizedText}\x00${width}\x00${this.#paddingX}\x00${this.#paddingY}\x00${this.#codeBlockIndent}\x00${objectId(this.#theme)}\x00${this.#defaultTextStyle ? objectId(this.#defaultTextStyle) : -1}\x00${TERMINAL.imageProtocol ?? ""}\x00${TERMINAL.hyperlinks ? 1 : 0}\x00${bgColorProbe}\x00${headingProbe}`;
 		const cached = renderCache.get(cacheKey);
 		if (cached !== undefined) {
 			// Populate L1 so subsequent calls from this instance are O(1) map lookup.
@@ -183,7 +218,7 @@ export class Markdown implements Component {
 		}
 
 		// Parse markdown to HTML-like tokens
-		const tokens = marked.lexer(normalizedText);
+		const tokens = markdownParser.lexer(normalizedText);
 
 		// Convert tokens to styled terminal output
 		const renderedLines: string[] = [];
@@ -582,6 +617,14 @@ export class Markdown implements Component {
 			}
 		}
 
+		// Strip dangling re-opened-default SGR prefix left over from the last inline
+		// token (strong/em/codespan/link/del/etc.) so the emitted line self-terminates
+		// at its last styled segment instead of carrying an unmatched SGR open into
+		// the next line. Matches upstream behavior.
+		while (stylePrefix && result.endsWith(stylePrefix)) {
+			result = result.slice(0, -stylePrefix.length);
+		}
+
 		return result;
 	}
 

package/src/keys.ts

@@ -174,28 +174,17 @@ type SpecialKey =
 	| "f12";
 
 type BaseKey = Letter | Digit | SymbolKey | SpecialKey;
+type ModifierName = "ctrl" | "shift" | "alt" | "super";
+
+type ModifiedKeyId<Key extends string, RemainingModifiers extends ModifierName = ModifierName> = {
+	[M in RemainingModifiers]: `${M}+${Key}` | `${M}+${ModifiedKeyId<Key, Exclude<RemainingModifiers, M>>}`;
+}[RemainingModifiers];
 
 /**
  * Union type of all valid key identifiers.
  * Provides autocomplete and catches typos at compile time.
  */
-export type KeyId =
-	| BaseKey
-	| `ctrl+${BaseKey}`
-	| `shift+${BaseKey}`
-	| `alt+${BaseKey}`
-	| `ctrl+shift+${BaseKey}`
-	| `shift+ctrl+${BaseKey}`
-	| `ctrl+alt+${BaseKey}`
-	| `alt+ctrl+${BaseKey}`
-	| `shift+alt+${BaseKey}`
-	| `alt+shift+${BaseKey}`
-	| `ctrl+shift+alt+${BaseKey}`
-	| `ctrl+alt+shift+${BaseKey}`
-	| `shift+ctrl+alt+${BaseKey}`
-	| `shift+alt+ctrl+${BaseKey}`
-	| `alt+ctrl+shift+${BaseKey}`
-	| `alt+shift+ctrl+${BaseKey}`;
+export type KeyId = BaseKey | ModifiedKeyId<BaseKey>;
 
 // =============================================================================
 // Kitty Protocol Parsing
@@ -218,7 +207,10 @@ const KITTY_CSI_U_PATTERN = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\
 const KITTY_MOD_SHIFT = 1;
 const KITTY_MOD_ALT = 2;
 const KITTY_MOD_CTRL = 4;
+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 KITTY_KEYPAD_OPERATOR_TEXT: Record<number, string> = {
 	57410: "/",
 	57411: "*",
@@ -311,11 +303,11 @@ function decodeKittyPrintable(data: string): string | undefined {
 	const shiftedKey = match[2] && match[2].length > 0 ? Number.parseInt(match[2], 10) : undefined;
 	const modValue = match[4] ? Number.parseInt(match[4], 10) : 1;
 	const modifier = Number.isFinite(modValue) ? modValue - 1 : 0;
-	const effectiveMod = modifier & ~(64 + 128);
-	const supportedModifierMask = KITTY_MOD_SHIFT | KITTY_MOD_ALT | KITTY_MOD_CTRL;
+	const effectiveMod = modifier & ~KITTY_LOCK_MASK;
+	const supportedModifierMask = KITTY_MOD_SHIFT | KITTY_MOD_ALT | KITTY_MOD_CTRL | KITTY_MOD_SUPER;
 
 	if (effectiveMod & ~supportedModifierMask) return undefined;
-	if (effectiveMod & (KITTY_MOD_ALT | KITTY_MOD_CTRL)) return undefined;
+	if (effectiveMod & (KITTY_MOD_ALT | KITTY_MOD_CTRL | KITTY_MOD_SUPER)) return undefined;
 
 	const textField = match[6];
 	if (textField && textField.length > 0) {
@@ -365,12 +357,59 @@ function decodeKittyPrintable(data: string): string | undefined {
  * keypad digits, keypad operators, and shifted symbols the same as direct character input.
  */
 export function extractPrintableText(data: string): string | undefined {
-	const kittyText = decodeKittyPrintable(data);
-	if (kittyText) return kittyText;
+	const printable = decodePrintableKey(data);
+	if (printable !== undefined) return printable;
 	if (data.length === 0 || hasControlChars(data)) return undefined;
 	return data;
 }
 
+interface ParsedModifyOtherKeysSequence {
+	codepoint: number;
+	modifier: number;
+}
+
+/**
+ * Parse an xterm `modifyOtherKeys` format sequence: `CSI 27 ; modifiers ; keycode ~`.
+ * Modifier values are 1-indexed in the wire format; we normalize to a 0-based bitmask.
+ */
+function parseModifyOtherKeysSequence(data: string): ParsedModifyOtherKeysSequence | null {
+	const match = data.match(MODIFY_OTHER_KEYS_PATTERN);
+	if (!match) return null;
+	const modValue = Number.parseInt(match[1] ?? "", 10);
+	const codepoint = Number.parseInt(match[2] ?? "", 10);
+	if (!Number.isFinite(modValue) || !Number.isFinite(codepoint)) return null;
+	return { codepoint, modifier: modValue - 1 };
+}
+
+/**
+ * Decode an xterm modifyOtherKeys sequence into the printable character it represents.
+ *
+ * Only sequences with no modifiers or Shift alone produce text; Ctrl/Alt/Super combos
+ * are treated as bindings, not text input.
+ */
+function decodeModifyOtherKeysPrintable(data: string): string | undefined {
+	const parsed = parseModifyOtherKeysSequence(data);
+	if (!parsed) return undefined;
+	const modifier = parsed.modifier & ~KITTY_LOCK_MASK;
+	if ((modifier & ~KITTY_MOD_SHIFT) !== 0) return undefined;
+	if (!Number.isFinite(parsed.codepoint) || parsed.codepoint < 32) return undefined;
+	try {
+		return String.fromCodePoint(parsed.codepoint);
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Decode terminal input into the printable character it represents.
+ *
+ * Tries Kitty CSI-u first, then falls back to xterm modifyOtherKeys. Returns
+ * undefined for control sequences and modifier-only events.
+ */
+export function decodePrintableKey(data: string): string | undefined {
+	return decodeKittyPrintable(data) ?? decodeModifyOtherKeysPrintable(data);
+}
+
 /**
  * Match input data against a key identifier string.
  *

package/src/stdin-buffer.ts

@@ -180,6 +180,14 @@ function isCompleteApcSequence(data: string): "complete" | "incomplete" {
 /**
  * Split accumulated buffer into complete sequences
  */
+function parseUnmodifiedKittyPrintableCodepoint(sequence: string): number | undefined {
+	const match = sequence.match(/^\x1b\[(\d+)(?::\d*)?(?::\d+)?u$/);
+	if (!match) return undefined;
+
+	const codepoint = parseInt(match[1]!, 10);
+	return codepoint >= 32 ? codepoint : undefined;
+}
+
 function extractCompleteSequences(buffer: string): { sequences: string[]; remainder: string } {
 	const sequences: string[] = [];
 	let pos = 0;
@@ -245,6 +253,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	readonly #timeoutMs: number;
 	#pasteMode: boolean = false;
 	#pasteBuffer: string = "";
+	#pendingKittyPrintableCodepoint: number | undefined;
 
 	constructor(options: StdinBufferOptions = {}) {
 		super();
@@ -273,7 +282,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		}
 
 		if (str.length === 0 && this.#buffer.length === 0) {
-			this.emit("data", "");
+			this.#emitDataSequence("");
 			return;
 		}
 
@@ -290,6 +299,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 
 				this.#pasteMode = false;
 				this.#pasteBuffer = "";
+				this.#pendingKittyPrintableCodepoint = undefined;
 
 				this.emit("paste", pastedContent);
 
@@ -306,10 +316,11 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 				const beforePaste = this.#buffer.slice(0, startIndex);
 				const result = extractCompleteSequences(beforePaste);
 				for (const sequence of result.sequences) {
-					this.emit("data", sequence);
+					this.#emitDataSequence(sequence);
 				}
 			}
 
+			this.#pendingKittyPrintableCodepoint = undefined;
 			this.#buffer = this.#buffer.slice(startIndex + BRACKETED_PASTE_START.length);
 			this.#pasteMode = true;
 			this.#pasteBuffer = this.#buffer;
@@ -322,6 +333,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 
 				this.#pasteMode = false;
 				this.#pasteBuffer = "";
+				this.#pendingKittyPrintableCodepoint = undefined;
 
 				this.emit("paste", pastedContent);
 
@@ -336,7 +348,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#buffer = result.remainder;
 
 		for (const sequence of result.sequences) {
-			this.emit("data", sequence);
+			this.#emitDataSequence(sequence);
 		}
 
 		if (this.#buffer.length > 0) {
@@ -344,12 +356,23 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 				const flushed = this.flush();
 
 				for (const sequence of flushed) {
-					this.emit("data", sequence);
+					this.#emitDataSequence(sequence);
 				}
 			}, this.#timeoutMs);
 		}
 	}
 
+	#emitDataSequence(sequence: string): void {
+		const rawCodepoint = sequence.length === 1 ? sequence.codePointAt(0) : undefined;
+		if (rawCodepoint !== undefined && rawCodepoint === this.#pendingKittyPrintableCodepoint) {
+			this.#pendingKittyPrintableCodepoint = undefined;
+			return;
+		}
+
+		this.#pendingKittyPrintableCodepoint = parseUnmodifiedKittyPrintableCodepoint(sequence);
+		this.emit("data", sequence);
+	}
+
 	flush(): string[] {
 		if (this.#timeout) {
 			clearTimeout(this.#timeout);
@@ -362,6 +385,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 
 		const sequences = [this.#buffer];
 		this.#buffer = "";
+		this.#pendingKittyPrintableCodepoint = undefined;
 		return sequences;
 	}
 
@@ -373,6 +397,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#buffer = "";
 		this.#pasteMode = false;
 		this.#pasteBuffer = "";
+		this.#pendingKittyPrintableCodepoint = undefined;
 	}
 
 	getBuffer(): string {

package/src/terminal-capabilities.ts

@@ -102,8 +102,8 @@ function getFallbackImageProtocol(terminalId: TerminalId): ImageProtocol | null
 }
 const KNOWN_TERMINALS = Object.freeze({
 	// Fallback terminals
-	base: new TerminalInfo("base", null, false, true, NotifyProtocol.Bell),
-	trueColor: new TerminalInfo("trueColor", null, true, true, NotifyProtocol.Bell),
+	base: new TerminalInfo("base", null, false, false, NotifyProtocol.Bell),
+	trueColor: new TerminalInfo("trueColor", null, true, false, NotifyProtocol.Bell),
 	// Recognized terminals
 	kitty: new TerminalInfo("kitty", ImageProtocol.Kitty, true, true, NotifyProtocol.Osc99),
 	ghostty: new TerminalInfo("ghostty", ImageProtocol.Kitty, true, true, NotifyProtocol.Osc9),
@@ -157,19 +157,19 @@ export const TERMINAL_ID: TerminalId = (() => {
 export const TERMINAL = (() => {
 	const terminal = getTerminalInfo(TERMINAL_ID);
 	const forcedImageProtocol = getForcedImageProtocol();
+	let resolved = terminal;
 	if (forcedImageProtocol !== undefined) {
-		return new TerminalInfo(
+		resolved = new TerminalInfo(
 			terminal.id,
 			forcedImageProtocol,
 			terminal.trueColor,
 			terminal.hyperlinks,
 			terminal.notifyProtocol,
 		);
-	}
-	if (!terminal.imageProtocol) {
+	} else if (!terminal.imageProtocol) {
 		const fallbackImageProtocol = getFallbackImageProtocol(terminal.id);
 		if (fallbackImageProtocol) {
-			return new TerminalInfo(
+			resolved = new TerminalInfo(
 				terminal.id,
 				fallbackImageProtocol,
 				terminal.trueColor,
@@ -178,7 +178,19 @@ export const TERMINAL = (() => {
 			);
 		}
 	}
-	return terminal;
+	// tmux and screen multiplexers do not reliably forward OSC 8 hyperlinks
+	// to the outer terminal, so force them off regardless of detected terminal.
+	const term = Bun.env.TERM?.toLowerCase() ?? "";
+	if (resolved.hyperlinks && (Bun.env.TMUX || term.startsWith("tmux") || term.startsWith("screen"))) {
+		resolved = new TerminalInfo(
+			resolved.id,
+			resolved.imageProtocol,
+			resolved.trueColor,
+			false,
+			resolved.notifyProtocol,
+		);
+	}
+	return resolved;
 })();
 
 type MutableTerminalInfo = {

package/src/terminal.ts

@@ -4,6 +4,10 @@ import { $env, logger } from "@oh-my-pi/pi-utils";
 import { setKittyProtocolActive } from "./keys";
 import { StdinBuffer } from "./stdin-buffer";
 
+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";
+
 /**
  * Minimal terminal interface for TUI
  */
@@ -85,6 +89,9 @@ export interface Terminal {
 	// Title operations
 	setTitle(title: string): void; // Set terminal window title
 
+	// Progress indicator (OSC 9;4)
+	setProgress(active: boolean): void;
+
 	/**
 	 * Register a callback for terminal appearance (dark/light) changes.
 	 * Detection uses OSC 11 background color query with Mode 2031 as a change trigger.
@@ -123,6 +130,7 @@ export class ProcessTerminal implements Terminal {
 	#pendingDa1Sentinels = 0;
 	#osc11PollTimer?: Timer;
 	#mode2031DebounceTimer?: Timer;
+	#progressTimer?: ReturnType<typeof setInterval>;
 
 	get kittyProtocolActive(): boolean {
 		return this.#kittyProtocolActive;
@@ -505,6 +513,10 @@ export class ProcessTerminal implements Terminal {
 			activeTerminal = null;
 		}
 
+		if (this.#clearProgressTimer()) {
+			this.#safeWrite(TERMINAL_PROGRESS_CLEAR_SEQUENCE);
+		}
+
 		// Disable bracketed paste mode
 		this.#safeWrite("\x1b[?2004l");
 
@@ -589,11 +601,11 @@ export class ProcessTerminal implements Terminal {
 	}
 
 	get columns(): number {
-		return process.stdout.columns || 80;
+		return process.stdout.columns || Number(Bun.env.COLUMNS) || 80;
 	}
 
 	get rows(): number {
-		return process.stdout.rows || 24;
+		return process.stdout.rows || Number(Bun.env.LINES) || 24;
 	}
 
 	moveBy(lines: number): void {
@@ -631,4 +643,26 @@ export class ProcessTerminal implements Terminal {
 		// OSC 0;title BEL - set terminal window title
 		this.#safeWrite(`\x1b]0;${title}\x07`);
 	}
+
+	setProgress(active: boolean): void {
+		if (active) {
+			this.#safeWrite(TERMINAL_PROGRESS_ACTIVE_SEQUENCE);
+			if (!this.#progressTimer) {
+				this.#progressTimer = setInterval(() => {
+					this.#safeWrite(TERMINAL_PROGRESS_ACTIVE_SEQUENCE);
+				}, TERMINAL_PROGRESS_KEEPALIVE_MS);
+				this.#progressTimer.unref?.();
+			}
+		} else {
+			this.#clearProgressTimer();
+			this.#safeWrite(TERMINAL_PROGRESS_CLEAR_SEQUENCE);
+		}
+	}
+
+	#clearProgressTimer(): boolean {
+		if (!this.#progressTimer) return false;
+		clearInterval(this.#progressTimer);
+		this.#progressTimer = undefined;
+		return true;
+	}
 }

package/src/tui.ts

@@ -3,13 +3,29 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { performance } from "node:perf_hooks";
 import { $flag, getDebugLogPath } from "@oh-my-pi/pi-utils";
 import { isKeyRelease, matchesKey } from "./keys";
 import type { Terminal } from "./terminal";
 import { ImageProtocol, setCellDimensions, setTerminalImageProtocol, TERMINAL } from "./terminal-capabilities";
-import { Ellipsis, extractSegments, sliceByColumn, sliceWithWidth, truncateToWidth, visibleWidth } from "./utils";
+import {
+	Ellipsis,
+	extractSegments,
+	normalizeTerminalOutput,
+	sliceByColumn,
+	sliceWithWidth,
+	truncateToWidth,
+	visibleWidth,
+} from "./utils";
 
 const SEGMENT_RESET = "\x1b[0m";
+/**
+ * Per-line terminator written at the end of every non-image line. Closes both
+ * SGR state and any in-flight OSC 8 hyperlink so styles/links cannot bleed
+ * across lines in scrollback. Applied by {@link TUI.#applyLineResets} before
+ * diffing so `#previousLines` mirrors what was actually written.
+ */
+const LINE_TERMINATOR = "\x1b[0m\x1b]8;;\x07";
 
 type InputListenerResult = { consume?: boolean; data?: string } | undefined;
 type InputListener = (data: string) => InputListenerResult;
@@ -218,11 +234,12 @@ export class TUI extends Container {
 	/** Global callback for debug key (Shift+Ctrl+D). Called before input is forwarded to focused component. */
 	onDebug?: () => void;
 	#renderRequested = false;
+	#renderTimer: NodeJS.Timeout | undefined;
+	#lastRenderAt = 0;
+	static readonly #MIN_RENDER_INTERVAL_MS = 16;
 	#cursorRow = 0; // Logical cursor row (end of rendered content)
 	#hardwareCursorRow = 0; // Actual terminal cursor row (may differ due to IME positioning)
 	#viewportTopRow = 0; // Content row currently mapped to screen row 0
-	#inputBuffer = ""; // Buffer for parsing terminal responses
-	#cellSizeQueryPending = false;
 	#sixelProbePendingDa = false;
 	#sixelProbePendingGraphics = false;
 	#sixelProbeBuffer = "";
@@ -540,13 +557,16 @@ export class TUI extends Container {
 		}
 		// Query terminal for cell size in pixels: CSI 16 t
 		// Response format: CSI 6 ; height ; width t
-		this.#cellSizeQueryPending = true;
 		this.terminal.write("\x1b[16t");
 	}
 
 	stop(): void {
 		this.#clearSixelProbeState();
 		this.#stopped = true;
+		if (this.#renderTimer) {
+			clearTimeout(this.#renderTimer);
+			this.#renderTimer = undefined;
+		}
 		// Move cursor to the end of the content to prevent overwriting/artifacts on exit
 		if (this.#previousLines.length > 0) {
 			const targetRow = this.#previousLines.length; // Line after the last content
@@ -572,13 +592,44 @@ export class TUI extends Container {
 			this.#hardwareCursorRow = 0;
 			this.#viewportTopRow = 0;
 			this.#maxLinesRendered = 0;
+			if (this.#renderTimer) {
+				clearTimeout(this.#renderTimer);
+				this.#renderTimer = undefined;
+			}
+			this.#renderRequested = true;
+			process.nextTick(() => {
+				if (this.#stopped || !this.#renderRequested) {
+					return;
+				}
+				this.#renderRequested = false;
+				this.#lastRenderAt = performance.now();
+				this.#doRender();
+			});
+			return;
 		}
 		if (this.#renderRequested) return;
 		this.#renderRequested = true;
-		process.nextTick(() => {
+		process.nextTick(() => this.#scheduleRender());
+	}
+
+	#scheduleRender(): void {
+		if (this.#stopped || this.#renderTimer || !this.#renderRequested) {
+			return;
+		}
+		const elapsed = performance.now() - this.#lastRenderAt;
+		const delay = Math.max(0, TUI.#MIN_RENDER_INTERVAL_MS - elapsed);
+		this.#renderTimer = setTimeout(() => {
+			this.#renderTimer = undefined;
+			if (this.#stopped || !this.#renderRequested) {
+				return;
+			}
 			this.#renderRequested = false;
+			this.#lastRenderAt = performance.now();
 			this.#doRender();
-		});
+			if (this.#renderRequested) {
+				this.#scheduleRender();
+			}
+		}, delay);
 	}
 
 	#handleInput(data: string): void {
@@ -599,12 +650,9 @@ export class TUI extends Container {
 			data = current;
 		}
 
-		// If we're waiting for cell size response, buffer input and parse
-		if (this.#cellSizeQueryPending) {
-			this.#inputBuffer += data;
-			const filtered = this.#parseCellSizeResponse();
-			if (filtered.length === 0) return;
-			data = filtered;
+		// Consume terminal cell size responses without blocking unrelated input.
+		if (this.#consumeCellSizeResponse(data)) {
+			return;
 		}
 
 		// Global debug key handler (Shift+Ctrl+D)
@@ -639,46 +687,24 @@ export class TUI extends Container {
 		}
 	}
 
-	#parseCellSizeResponse(): string {
+	#consumeCellSizeResponse(data: string): boolean {
 		// Response format: ESC [ 6 ; height ; width t
-		// Match the response pattern
-		const responsePattern = /\x1b\[6;(\d+);(\d+)t/;
-		const match = this.#inputBuffer.match(responsePattern);
-
-		if (match) {
-			const heightPx = parseInt(match[1], 10);
-			const widthPx = parseInt(match[2], 10);
-
-			if (heightPx > 0 && widthPx > 0) {
-				setCellDimensions({ widthPx, heightPx });
-				// Invalidate all components so images re-render with correct dimensions
-				this.invalidate();
-				this.requestRender();
-			}
-
-			// Remove the response from buffer
-			this.#inputBuffer = this.#inputBuffer.replace(responsePattern, "");
-			this.#cellSizeQueryPending = false;
+		const match = data.match(/^\x1b\[6;(\d+);(\d+)t$/);
+		if (!match) {
+			return false;
 		}
 
-		// Check if we have a partial cell size response starting (wait for more data)
-		// Patterns that could be incomplete cell size response: \x1b, \x1b[, \x1b[6, \x1b[6;...(no t yet)
-		const partialCellSizePattern = /\x1b(\[6?;?[\d;]*)?$/;
-		if (partialCellSizePattern.test(this.#inputBuffer)) {
-			// Check if it's actually a complete different escape sequence (ends with a letter)
-			// Cell size response ends with 't', Kitty keyboard ends with 'u', arrows end with A-D, etc.
-			const lastChar = this.#inputBuffer[this.#inputBuffer.length - 1];
-			if (!/[a-zA-Z~]/.test(lastChar)) {
-				// Doesn't end with a terminator, might be incomplete - wait for more
-				return "";
-			}
+		const heightPx = parseInt(match[1], 10);
+		const widthPx = parseInt(match[2], 10);
+		if (heightPx <= 0 || widthPx <= 0) {
+			return true;
 		}
 
-		// No cell size response found, return buffered data as user input
-		const result = this.#inputBuffer;
-		this.#inputBuffer = "";
-		this.#cellSizeQueryPending = false; // Give up waiting
-		return result;
+		setCellDimensions({ widthPx, heightPx });
+		// Invalidate all components so images re-render with correct dimensions.
+		this.invalidate();
+		this.requestRender();
+		return true;
 	}
 
 	/**
@@ -978,6 +1004,26 @@ export class TUI extends Container {
 		return null;
 	}
 
+	/**
+	 * Append the per-line terminator ({@link LINE_TERMINATOR}) to every
+	 * non-image line and normalize for terminal rendering. Mutates the input
+	 * array in place so downstream diffing/storage sees exactly the bytes
+	 * written to the terminal — without this, the diff cache disagrees with
+	 * emitted output and OSC 8 hyperlink state can leak across lines.
+	 */
+	#applyLineResets(lines: string[]): string[] {
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (TERMINAL.isImageLine(line)) continue;
+			const normalized = normalizeTerminalOutput(line);
+			// Only close OSC 8 hyperlinks when the line actually opened one;
+			// emitting `\x1b]8;;\x07` on every line just feeds the terminal's OSC
+			// parser for no reason (measurable cost in xterm.js parse loop).
+			lines[i] = normalized + (normalized.includes("\x1b]8;") ? LINE_TERMINATOR : SEGMENT_RESET);
+		}
+		return lines;
+	}
+
 	#doRender(): void {
 		if (this.#stopped) return;
 		const width = this.terminal.columns;
@@ -1002,6 +1048,12 @@ export class TUI extends Container {
 		// Extract cursor position (marker must be found before diff comparison)
 		const cursorPos = this.#extractCursorPosition(newLines, height);
 
+		// Terminate every non-image line so #previousLines mirrors emitted bytes
+		// (closes SGR + OSC 8 hyperlink state). Must run after cursor extraction
+		// because the marker is embedded mid-line, and before any diff/full render
+		// path so cache comparisons stay byte-accurate.
+		newLines = this.#applyLineResets(newLines);
+
 		// Width changed - need full re-render (line wrapping changes)
 		const widthChanged = this.#previousWidth !== 0 && this.#previousWidth !== width;
 		const heightChanged = this.#previousHeight !== 0 && this.#previousHeight !== height;
@@ -1012,11 +1064,11 @@ export class TUI extends Container {
 			let buffer = "\x1b[?2026h"; // Begin synchronized output
 			// Skip clearing scrollback (3J) in multiplexers — users actively navigate scrollback history
 			if (clear) buffer += isMultiplexer ? "\x1b[2J\x1b[H" : "\x1b[2J\x1b[H\x1b[3J";
-			const reset = SEGMENT_RESET;
 			for (let i = 0; i < newLines.length; i++) {
 				if (i > 0) buffer += "\r\n";
-				const line = newLines[i];
-				buffer += TERMINAL.isImageLine(line) ? line : line + reset;
+				// Lines were pre-terminated/normalized by #applyLineResets; image
+				// lines were left untouched there.
+				buffer += newLines[i];
 			}
 			this.#cursorRow = Math.max(0, newLines.length - 1);
 			const { seq, toRow } = this.#cursorControlSequence(cursorPos, newLines.length, this.#cursorRow);
@@ -1151,29 +1203,13 @@ export class TUI extends Container {
 			return;
 		}
 
-		// Check if firstChanged is above what was previously visible
-		const previousContentViewportTop = Math.max(0, this.#previousLines.length - height);
-		if (firstChanged < previousContentViewportTop) {
-			const newViewportTop = Math.max(0, newLines.length - height);
-			if (newViewportTop < previousContentViewportTop) {
-				// Viewport needs to shift up — can only be done with a full redraw
-				logRedraw(`viewport shift up (new=${newViewportTop} < prev=${previousContentViewportTop})`);
-				fullRender(true);
-				return;
-			}
-			// Viewport is stable or shifting down — skip invisible above-viewport changes
-			firstChanged = previousContentViewportTop;
-			if (lastChanged < firstChanged) {
-				// All changes are above the viewport — nothing visible to update
-				this.#cursorRow = Math.max(0, newLines.length - 1);
-				this.#maxLinesRendered = newLines.length;
-				this.#viewportTopRow = Math.max(0, newLines.length - height);
-				this.#writeCursorPosition(cursorPos, newLines.length);
-				this.#previousLines = newLines;
-				this.#previousWidth = width;
-				this.#previousHeight = height;
-				return;
-			}
+		// Differential rendering can only touch what was actually visible.
+		// Any change above the previous viewport requires a full redraw so terminal
+		// scrollback ends up consistent with the new transcript state.
+		if (firstChanged < prevViewportTop) {
+			logRedraw(`firstChanged < viewportTop (${firstChanged} < ${prevViewportTop})`);
+			fullRender(true);
+			return;
 		}
 
 		// Render from first changed line to end
@@ -1228,8 +1264,15 @@ export class TUI extends Container {
 					}
 				}
 				truncatedLine = truncateToWidth(line, width, Ellipsis.Omit);
+				// Re-append the terminator: truncateToWidth removes trailing
+				// content past the visible-width budget, which may also drop the
+				// terminator appended by #applyLineResets. Match the conditional
+				// OSC 8 close strategy used there.
+				truncatedLine += truncatedLine.includes("\x1b]8;") ? LINE_TERMINATOR : SEGMENT_RESET;
 			}
-			buffer += isImage ? truncatedLine : truncatedLine + SEGMENT_RESET;
+			// Non-image lines are pre-terminated/normalized by #applyLineResets;
+			// truncated lines re-append LINE_TERMINATOR above.
+			buffer += truncatedLine;
 		}
 
 		// Track where cursor ended up after rendering

package/src/utils.ts

@@ -112,12 +112,26 @@ export function visibleWidth(str: string): number {
 	return visibleWidthRaw(str);
 }
 
-const makeBoolArray = (chars: string): ReadonlyArray<boolean> => {
-	const table = Array.from({ length: 128 }, () => false);
+const THAI_LAO_AM_REGEX = /[\u0e33\u0eb3]/;
+const THAI_LAO_AM_GLOBAL_REGEX = /[\u0e33\u0eb3]/g;
+
+/**
+ * Normalize text for terminal output without changing logical editor content.
+ * Some terminals render precomposed Thai/Lao AM vowels inconsistently during
+ * differential repaint. Their compatibility decompositions have the same cell
+ * width but avoid stale-cell artifacts in terminal renderers.
+ */
+export function normalizeTerminalOutput(str: string): string {
+	if (!THAI_LAO_AM_REGEX.test(str)) return str;
+	return str.replace(THAI_LAO_AM_GLOBAL_REGEX, char => (char === "\u0e33" ? "\u0e4d\u0e32" : "\u0ecd\u0eb2"));
+}
+
+const makeBoolArray = (chars: string): Uint8Array => {
+	const table = new Uint8Array(128);
 	for (let i = 0; i < chars.length; i++) {
 		const code = chars.charCodeAt(i);
 		if (code < table.length) {
-			table[code] = true;
+			table[code] = 1;
 		}
 	}
 	return table;
@@ -129,8 +143,8 @@ const ASCII_WHITESPACE = makeBoolArray("\x09\x0a\x0b\x0c\x0d\x20");
  * Check if a character is whitespace.
  */
 export function isWhitespaceChar(char: string): boolean {
-	const code = char.codePointAt(0) || 0;
-	return ASCII_WHITESPACE[code] ?? false;
+	const code = char.codePointAt(0) ?? 0;
+	return code < 128 && ASCII_WHITESPACE[code] === 1;
 }
 
 const ASCII_PUNCTUATION = makeBoolArray("(){}[]<>.,;:'\"!?+-=*/\\|&%^$#@~`");
@@ -139,8 +153,8 @@ const ASCII_PUNCTUATION = makeBoolArray("(){}[]<>.,;:'\"!?+-=*/\\|&%^$#@~`");
  * Check if a character is punctuation.
  */
 export function isPunctuationChar(char: string): boolean {
-	const code = char.codePointAt(0) || 0;
-	return ASCII_PUNCTUATION[code] ?? false;
+	const code = char.codePointAt(0) ?? 0;
+	return code < 128 && ASCII_PUNCTUATION[code] === 1;
 }
 
 export type WordNavKind = "whitespace" | "delimiter" | "cjk" | "word" | "other";