@oh-my-pi/pi-tui 8.12.10 → 9.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-tui",
-	"version": "8.12.10",
+	"version": "9.0.0",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -47,7 +47,7 @@
 		"bun": ">=1.3.7"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "8.12.10",
+		"@oh-my-pi/pi-natives": "9.0.0",
 		"@types/mime-types": "^3.0.1",
 		"chalk": "^5.6.2",
 		"marked": "^17.0.1",

package/src/autocomplete.ts

@@ -363,9 +363,9 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 			return pathPrefix;
 		}
 
-		// Return empty string only if we're at the beginning of the line or after a space
-		// (not after quotes or other delimiters that don't suggest file paths)
-		if (pathPrefix === "" && (text === "" || text.endsWith(" "))) {
+		// Return empty string only after a space (not for completely empty text)
+		// Empty text should not trigger file suggestions - that's for forced Tab completion
+		if (pathPrefix === "" && text.endsWith(" ")) {
 			return pathPrefix;
 		}
 

package/src/components/editor.ts

@@ -289,9 +289,10 @@ export class Editor implements Component, Focusable {
 	// Autocomplete support
 	private autocompleteProvider?: AutocompleteProvider;
 	private autocompleteList?: SelectList;
-	private isAutocompleting: boolean = false;
+	private autocompleteState: "regular" | "force" | null = null;
 	private autocompletePrefix: string = "";
 	private autocompleteRequestId: number = 0;
+	private autocompleteMaxVisible: number = 5;
 	public onAutocompleteUpdate?: () => void;
 
 	// Paste tracking for large pastes
@@ -301,7 +302,6 @@ export class Editor implements Component, Focusable {
 	// Bracketed paste mode buffering
 	private pasteBuffer: string = "";
 	private isInPaste: boolean = false;
-	private pendingShiftEnter: boolean = false;
 
 	// Prompt history for up/down navigation
 	private history: string[] = [];
@@ -357,6 +357,17 @@ export class Editor implements Component, Focusable {
 		this.paddingXOverride = Math.max(0, paddingX);
 	}
 
+	getAutocompleteMaxVisible(): number {
+		return this.autocompleteMaxVisible;
+	}
+
+	setAutocompleteMaxVisible(maxVisible: number): void {
+		const newMaxVisible = Number.isFinite(maxVisible) ? Math.max(3, Math.min(20, Math.floor(maxVisible))) : 5;
+		if (this.autocompleteMaxVisible !== newMaxVisible) {
+			this.autocompleteMaxVisible = newMaxVisible;
+		}
+	}
+
 	setHistoryStorage(storage: HistoryStorage): void {
 		this.historyStorage = storage;
 		const recent = storage.getRecent(100);
@@ -512,7 +523,7 @@ export class Editor implements Component, Focusable {
 
 		// Render each layout line
 		// Emit hardware cursor marker only when focused and not showing autocomplete
-		const emitCursorMarker = this.focused && !this.isAutocompleting;
+		const emitCursorMarker = this.focused && !this.autocompleteState;
 		const lineContentWidth = contentAreaWidth;
 
 		for (const layoutLine of visibleLayoutLines) {
@@ -574,7 +585,7 @@ export class Editor implements Component, Focusable {
 		}
 
 		// Add autocomplete list if active
-		if (this.isAutocompleting && this.autocompleteList) {
+		if (this.autocompleteState && this.autocompleteList) {
 			const autocompleteResult = this.autocompleteList.render(width);
 			result.push(...autocompleteResult);
 		}
@@ -664,21 +675,6 @@ export class Editor implements Component, Focusable {
 
 		// Handle special key combinations first
 
-		if (this.pendingShiftEnter) {
-			if (data === "\r") {
-				this.pendingShiftEnter = false;
-				this.addNewLine();
-				return;
-			}
-			this.pendingShiftEnter = false;
-			this.insertCharacter("\\");
-		}
-
-		if (data === "\\") {
-			this.pendingShiftEnter = true;
-			return;
-		}
-
 		// Ctrl+C - Exit (let parent handle this)
 		if (matchesKey(data, "ctrl+c")) {
 			return;
@@ -691,7 +687,7 @@ export class Editor implements Component, Focusable {
 		}
 
 		// Handle autocomplete special keys first (but don't block other input)
-		if (this.isAutocompleting && this.autocompleteList) {
+		if (this.autocompleteState && this.autocompleteList) {
 			// Escape - cancel autocomplete
 			if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
 				this.cancelAutocomplete(true);
@@ -798,7 +794,7 @@ export class Editor implements Component, Focusable {
 		}
 
 		// Tab key - context-aware completion (but not when already autocompleting)
-		if (matchesKey(data, "tab") && !this.isAutocompleting) {
+		if (matchesKey(data, "tab") && !this.autocompleteState) {
 			this.handleTabCompletion();
 			return;
 		}
@@ -853,8 +849,7 @@ export class Editor implements Component, Focusable {
 			data === "\x1b[13;2~" || // Shift+Enter in some terminals (legacy format)
 			matchesKey(data, "shift+enter") || // Shift+Enter (Kitty protocol, handles lock bits)
 			(data.length > 1 && data.includes("\x1b") && data.includes("\r")) ||
-			(data === "\n" && data.length === 1) || // Shift+Enter from iTerm2 mapping
-			data === "\\\r" // Shift+Enter in VS Code terminal
+			(data === "\n" && data.length === 1) // Shift+Enter from iTerm2 mapping
 		) {
 			// Modifier + Enter = new line
 			this.addNewLine();
@@ -866,6 +861,15 @@ export class Editor implements Component, Focusable {
 				return;
 			}
 
+			// Workaround for terminals without Shift+Enter support:
+			// If char before cursor is \, delete it and insert newline instead of submitting.
+			const currentLine = this.state.lines[this.state.cursorLine] || "";
+			if (this.state.cursorCol > 0 && currentLine[this.state.cursorCol - 1] === "\\") {
+				this.handleBackspace();
+				this.addNewLine();
+				return;
+			}
+
 			this.resetKillSequence();
 
 			// Get text and substitute paste markers with actual content
@@ -1120,7 +1124,7 @@ export class Editor implements Component, Focusable {
 		}
 
 		// Check if we should trigger or update autocomplete
-		if (!this.isAutocompleting) {
+		if (!this.autocompleteState) {
 			// Auto-trigger for "/" at the start of a line (slash commands)
 			if (char === "/" && this.isAtStartOfMessage()) {
 				this.tryTriggerAutocomplete();
@@ -1275,7 +1279,7 @@ export class Editor implements Component, Focusable {
 		}
 
 		// Update or re-trigger autocomplete after backspace
-		if (this.isAutocompleting) {
+		if (this.autocompleteState) {
 			this.debouncedUpdateAutocomplete();
 		} else {
 			// If autocomplete was cancelled (no matches), re-trigger if we're in a completable context
@@ -1361,7 +1365,7 @@ export class Editor implements Component, Focusable {
 			this.onChange(this.getText());
 		}
 
-		if (this.isAutocompleting) {
+		if (this.autocompleteState) {
 			this.debouncedUpdateAutocomplete();
 		} else {
 			const currentLine = this.state.lines[this.state.cursorLine] || "";
@@ -1586,7 +1590,7 @@ export class Editor implements Component, Focusable {
 		}
 
 		// Update or re-trigger autocomplete after forward delete
-		if (this.isAutocompleting) {
+		if (this.autocompleteState) {
 			this.debouncedUpdateAutocomplete();
 		} else {
 			const currentLine = this.state.lines[this.state.cursorLine] || "";
@@ -1839,8 +1843,8 @@ export class Editor implements Component, Focusable {
 
 		if (suggestions && suggestions.items.length > 0) {
 			this.autocompletePrefix = suggestions.prefix;
-			this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
-			this.isAutocompleting = true;
+			this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
+			this.autocompleteState = "regular";
 			this.onAutocompleteUpdate?.();
 		} else {
 			this.cancelAutocomplete();
@@ -1858,7 +1862,7 @@ export class Editor implements Component, Focusable {
 		if (beforeCursor.trimStart().startsWith("/") && !beforeCursor.trimStart().includes(" ")) {
 			this.handleSlashCommandCompletion();
 		} else {
-			this.forceFileAutocomplete();
+			this.forceFileAutocomplete(true);
 		}
 	}
 
@@ -1871,7 +1875,7 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
 17 this job fails with https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19
 536643416/job/55932288317 havea  look at .gi
     */
-	private async forceFileAutocomplete(): Promise<void> {
+	private async forceFileAutocomplete(explicitTab: boolean = false): Promise<void> {
 		if (!this.autocompleteProvider) return;
 
 		// Check if provider supports force file suggestions via runtime check
@@ -1892,9 +1896,30 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
 		if (requestId !== this.autocompleteRequestId) return;
 
 		if (suggestions && 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]!;
+				const result = this.autocompleteProvider.applyCompletion(
+					this.state.lines,
+					this.state.cursorLine,
+					this.state.cursorCol,
+					item,
+					suggestions.prefix,
+				);
+
+				this.state.lines = result.lines;
+				this.state.cursorLine = result.cursorLine;
+				this.state.cursorCol = result.cursorCol;
+
+				if (this.onChange) {
+					this.onChange(this.getText());
+				}
+				return;
+			}
+
 			this.autocompletePrefix = suggestions.prefix;
-			this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
-			this.isAutocompleting = true;
+			this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
+			this.autocompleteState = "force";
 			this.onAutocompleteUpdate?.();
 		} else {
 			this.cancelAutocomplete();
@@ -1903,10 +1928,10 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
 	}
 
 	private cancelAutocomplete(notifyCancel: boolean = false): void {
-		const wasAutocompleting = this.isAutocompleting;
+		const wasAutocompleting = this.autocompleteState !== null;
 		this.clearAutocompleteTimeout();
 		this.autocompleteRequestId += 1;
-		this.isAutocompleting = false;
+		this.autocompleteState = null;
 		this.autocompleteList = undefined;
 		this.autocompletePrefix = "";
 		if (notifyCancel && wasAutocompleting) {
@@ -1915,11 +1940,18 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
 	}
 
 	public isShowingAutocomplete(): boolean {
-		return this.isAutocompleting;
+		return this.autocompleteState !== null;
 	}
 
 	private async updateAutocomplete(): Promise<void> {
-		if (!this.isAutocompleting || !this.autocompleteProvider) return;
+		if (!this.autocompleteState || !this.autocompleteProvider) return;
+
+		// In force mode, use forceFileAutocomplete to get suggestions
+		if (this.autocompleteState === "force") {
+			this.forceFileAutocomplete();
+			return;
+		}
+
 		const requestId = ++this.autocompleteRequestId;
 
 		const suggestions = await this.autocompleteProvider.getSuggestions(
@@ -1932,7 +1964,7 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
 		if (suggestions && suggestions.items.length > 0) {
 			this.autocompletePrefix = suggestions.prefix;
 			// Always create new SelectList to ensure update
-			this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
+			this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
 			this.onAutocompleteUpdate?.();
 		} else {
 			this.cancelAutocomplete();

package/src/components/input.ts

@@ -19,7 +19,6 @@ export class Input implements Component, Focusable {
 	// Bracketed paste mode buffering
 	private pasteBuffer: string = "";
 	private isInPaste: boolean = false;
-	private pendingShiftEnter: boolean = false;
 
 	getValue(): string {
 		return this.value;
@@ -68,22 +67,6 @@ export class Input implements Component, Focusable {
 			return;
 		}
 
-		if (this.pendingShiftEnter) {
-			if (data === "\r") {
-				this.pendingShiftEnter = false;
-				if (this.onSubmit) this.onSubmit(this.value);
-				return;
-			}
-			this.pendingShiftEnter = false;
-			this.value = `${this.value.slice(0, this.cursor)}\\${this.value.slice(this.cursor)}`;
-			this.cursor += 1;
-		}
-
-		if (data === "\\") {
-			this.pendingShiftEnter = true;
-			return;
-		}
-
 		const kb = getEditorKeybindings();
 
 		// Escape/Cancel

package/src/components/markdown.ts

@@ -561,6 +561,21 @@ export class Markdown implements Component {
 		return lines;
 	}
 
+	/**
+	 * Get the visible width of the longest word in a string.
+	 */
+	private getLongestWordWidth(text: string, maxWidth?: number): number {
+		const words = text.split(/\s+/).filter(word => word.length > 0);
+		let longest = 0;
+		for (const word of words) {
+			longest = Math.max(longest, visibleWidth(word));
+		}
+		if (maxWidth === undefined) {
+			return longest;
+		}
+		return Math.min(longest, maxWidth);
+	}
+
 	/**
 	 * Wrap a table cell to fit into a column.
 	 *
@@ -589,56 +604,101 @@ export class Markdown implements Component {
 		// Calculate border overhead: "│ " + (n-1) * " │ " + " │"
 		// = 2 + (n-1) * 3 + 2 = 3n + 1
 		const borderOverhead = 3 * numCols + 1;
-
-		// Minimum width for a bordered table with at least 1 char per column.
-		const minTableWidth = borderOverhead + numCols;
-		if (availableWidth < minTableWidth) {
+		const availableForCells = availableWidth - borderOverhead;
+		if (availableForCells < numCols) {
 			// Too narrow to render a stable table. Fall back to raw markdown.
 			const fallbackLines = token.raw ? wrapTextWithAnsi(token.raw, availableWidth) : [];
 			fallbackLines.push("");
 			return fallbackLines;
 		}
 
+		const maxUnbrokenWordWidth = 30;
+
 		// Calculate natural column widths (what each column needs without constraints)
 		const naturalWidths: number[] = [];
+		const minWordWidths: number[] = [];
 		for (let i = 0; i < numCols; i++) {
 			const headerText = this.renderInlineTokens(token.header[i].tokens || []);
 			naturalWidths[i] = visibleWidth(headerText);
+			minWordWidths[i] = Math.max(1, this.getLongestWordWidth(headerText, maxUnbrokenWordWidth));
 		}
 		for (const row of token.rows) {
 			for (let i = 0; i < row.length; i++) {
 				const cellText = this.renderInlineTokens(row[i].tokens || []);
 				naturalWidths[i] = Math.max(naturalWidths[i] || 0, visibleWidth(cellText));
+				minWordWidths[i] = Math.max(
+					minWordWidths[i] || 1,
+					this.getLongestWordWidth(cellText, maxUnbrokenWordWidth),
+				);
 			}
 		}
 
+		let minColumnWidths = minWordWidths;
+		let minCellsWidth = minColumnWidths.reduce((a, b) => a + b, 0);
+
+		if (minCellsWidth > availableForCells) {
+			minColumnWidths = new Array(numCols).fill(1);
+			const remaining = availableForCells - numCols;
+
+			if (remaining > 0) {
+				const totalWeight = minWordWidths.reduce((total, width) => total + Math.max(0, width - 1), 0);
+				const growth = minWordWidths.map(width => {
+					const weight = Math.max(0, width - 1);
+					return totalWeight > 0 ? Math.floor((weight / totalWeight) * remaining) : 0;
+				});
+
+				for (let i = 0; i < numCols; i++) {
+					minColumnWidths[i] += growth[i] ?? 0;
+				}
+
+				const allocated = growth.reduce((total, width) => total + width, 0);
+				let leftover = remaining - allocated;
+				for (let i = 0; leftover > 0 && i < numCols; i++) {
+					minColumnWidths[i]++;
+					leftover--;
+				}
+			}
+
+			minCellsWidth = minColumnWidths.reduce((a, b) => a + b, 0);
+		}
+
 		// Calculate column widths that fit within available width
 		const totalNaturalWidth = naturalWidths.reduce((a, b) => a + b, 0) + borderOverhead;
 		let columnWidths: number[];
 
 		if (totalNaturalWidth <= availableWidth) {
 			// Everything fits naturally
-			columnWidths = naturalWidths;
+			columnWidths = naturalWidths.map((width, index) => Math.max(width, minColumnWidths[index]));
 		} else {
 			// Need to shrink columns to fit
-			const availableForCells = availableWidth - borderOverhead;
-			if (availableForCells <= numCols) {
-				// Extremely narrow - give each column at least 1 char
-				columnWidths = naturalWidths.map(() => Math.max(1, Math.floor(availableForCells / numCols)));
-			} else {
-				// Distribute space proportionally based on natural widths
-				const totalNatural = naturalWidths.reduce((a, b) => a + b, 0);
-				columnWidths = naturalWidths.map(w => {
-					const proportion = w / totalNatural;
-					return Math.max(1, Math.floor(proportion * availableForCells));
-				});
+			const totalGrowPotential = naturalWidths.reduce((total, width, index) => {
+				return total + Math.max(0, width - minColumnWidths[index]);
+			}, 0);
+			const extraWidth = Math.max(0, availableForCells - minCellsWidth);
+			columnWidths = minColumnWidths.map((minWidth, index) => {
+				const naturalWidth = naturalWidths[index];
+				const minWidthDelta = Math.max(0, naturalWidth - minWidth);
+				let grow = 0;
+				if (totalGrowPotential > 0) {
+					grow = Math.floor((minWidthDelta / totalGrowPotential) * extraWidth);
+				}
+				return minWidth + grow;
+			});
 
-				// Adjust for rounding errors - distribute remaining space
-				const allocated = columnWidths.reduce((a, b) => a + b, 0);
-				let remaining = availableForCells - allocated;
-				for (let i = 0; remaining > 0 && i < numCols; i++) {
-					columnWidths[i]++;
-					remaining--;
+			// Adjust for rounding errors - distribute remaining space
+			const allocated = columnWidths.reduce((a, b) => a + b, 0);
+			let remaining = availableForCells - allocated;
+			while (remaining > 0) {
+				let grew = false;
+				for (let i = 0; i < numCols && remaining > 0; i++) {
+					if (columnWidths[i] < naturalWidths[i]) {
+						columnWidths[i]++;
+						remaining--;
+						grew = true;
+					}
+				}
+				if (!grew) {
+					break;
 				}
 			}
 		}
@@ -669,10 +729,12 @@ export class Markdown implements Component {
 
 		// Render separator
 		const separatorCells = columnWidths.map(w => h.repeat(w));
-		lines.push(`${t.teeRight}${h}${separatorCells.join(`${h}${t.cross}${h}`)}${h}${t.teeLeft}`);
+		const separatorLine = `${t.teeRight}${h}${separatorCells.join(`${h}${t.cross}${h}`)}${h}${t.teeLeft}`;
+		lines.push(separatorLine);
 
 		// Render rows with wrapping
-		for (const row of token.rows) {
+		for (let rowIndex = 0; rowIndex < token.rows.length; rowIndex++) {
+			const row = token.rows[rowIndex];
 			const rowCellLines: string[][] = row.map((cell, i) => {
 				const text = this.renderInlineTokens(cell.tokens || []);
 				return this.wrapCellText(text, columnWidths[i]);
@@ -686,6 +748,10 @@ export class Markdown implements Component {
 				});
 				lines.push(`${v} ${rowParts.join(` ${v} `)} ${v}`);
 			}
+
+			if (rowIndex < token.rows.length - 1) {
+				lines.push(separatorLine);
+			}
 		}
 
 		// Render bottom border

package/src/keybindings.ts

@@ -53,13 +53,13 @@ export const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig> = {
 	cursorDown: "down",
 	cursorLeft: "left",
 	cursorRight: "right",
-	cursorWordLeft: ["alt+left", "ctrl+left"],
-	cursorWordRight: ["alt+right", "ctrl+right"],
+	cursorWordLeft: ["alt+left", "ctrl+left", "alt+b"],
+	cursorWordRight: ["alt+right", "ctrl+right", "alt+f"],
 	cursorLineStart: ["home", "ctrl+a"],
 	cursorLineEnd: ["end", "ctrl+e"],
 	// Deletion
 	deleteCharBackward: "backspace",
-	deleteCharForward: "delete",
+	deleteCharForward: ["delete", "ctrl+d"],
 	deleteWordBackward: ["ctrl+w", "alt+backspace", "ctrl+backspace"],
 	deleteWordForward: ["alt+delete", "alt+d"],
 	deleteToLineStart: "ctrl+u",

package/src/terminal-image.ts

@@ -1,9 +1,10 @@
 export type ImageProtocol = "kitty" | "iterm2" | null;
 
 export interface TerminalCapabilities {
-	images: ImageProtocol;
-	trueColor: boolean;
-	hyperlinks: boolean;
+	readonly images: ImageProtocol;
+	readonly trueColor: boolean;
+	readonly hyperlinks: boolean;
+	containsImage(line: string): boolean;
 }
 
 export interface CellDimensions {
@@ -35,37 +36,72 @@ export function setCellDimensions(dims: CellDimensions): void {
 	cellDimensions = dims;
 }
 
+const kBaseCaps: TerminalCapabilities = {
+	images: null,
+	trueColor: false,
+	hyperlinks: true,
+	containsImage() {
+		return false;
+	},
+};
+
+function createTerminalCaps(parts: Partial<TerminalCapabilities>): TerminalCapabilities {
+	return Object.freeze({ ...kBaseCaps, ...parts });
+}
+
+const kKittyCaps = createTerminalCaps({
+	images: "kitty",
+	trueColor: true,
+	hyperlinks: true,
+	containsImage(line: string) {
+		return line.includes("\x1b_G");
+	},
+});
+const kGhosttyCaps = kKittyCaps;
+const kWeztermCaps = kKittyCaps;
+
+const kIterm2Caps = createTerminalCaps({
+	images: "iterm2",
+	trueColor: true,
+	hyperlinks: true,
+	containsImage(line: string) {
+		return line.includes("\x1b]1337;File=");
+	},
+});
+
+const kTrueColorCaps = createTerminalCaps({
+	...kBaseCaps,
+	trueColor: true,
+});
+
+const kVscodeCaps = kTrueColorCaps;
+const kAlacrittyCaps = kTrueColorCaps;
+
 export function detectCapabilities(): TerminalCapabilities {
 	const termProgram = process.env.TERM_PROGRAM?.toLowerCase() || "";
 	const term = process.env.TERM?.toLowerCase() || "";
 	const colorTerm = process.env.COLORTERM?.toLowerCase() || "";
 
 	if (process.env.KITTY_WINDOW_ID || termProgram === "kitty") {
-		return { images: "kitty", trueColor: true, hyperlinks: true };
+		return kKittyCaps;
 	}
-
 	if (termProgram === "ghostty" || term.includes("ghostty") || process.env.GHOSTTY_RESOURCES_DIR) {
-		return { images: "kitty", trueColor: true, hyperlinks: true };
+		return kGhosttyCaps;
 	}
-
 	if (process.env.WEZTERM_PANE || termProgram === "wezterm") {
-		return { images: "kitty", trueColor: true, hyperlinks: true };
+		return kWeztermCaps;
 	}
-
 	if (process.env.ITERM_SESSION_ID || termProgram === "iterm.app") {
-		return { images: "iterm2", trueColor: true, hyperlinks: true };
+		return kIterm2Caps;
 	}
-
 	if (termProgram === "vscode") {
-		return { images: null, trueColor: true, hyperlinks: true };
+		return kVscodeCaps;
 	}
-
 	if (termProgram === "alacritty") {
-		return { images: null, trueColor: true, hyperlinks: true };
+		return kAlacrittyCaps;
 	}
-
 	const trueColor = colorTerm === "truecolor" || colorTerm === "24bit";
-	return { images: null, trueColor, hyperlinks: true };
+	return trueColor ? kTrueColorCaps : kBaseCaps;
 }
 
 export function getCapabilities(): TerminalCapabilities {

package/src/tui.ts

@@ -541,8 +541,8 @@ export class TUI extends Container {
 		return result;
 	}
 
-	private containsImage(line: string): boolean {
-		return line.includes("\x1b_G") || line.includes("\x1b]1337;File=");
+	static containsImage(line: string): boolean {
+		return getCapabilities().containsImage(line);
 	}
 
 	/**
@@ -764,7 +764,13 @@ export class TUI extends Container {
 
 	private applyLineResets(lines: string[]): string[] {
 		const reset = TUI.SEGMENT_RESET;
-		return lines.map(line => (this.containsImage(line) ? line : line + reset));
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (!TUI.containsImage(line)) {
+				lines[i] = line + reset;
+			}
+		}
+		return lines;
 	}
 
 	/**
@@ -839,7 +845,7 @@ export class TUI extends Container {
 		overlayWidth: number,
 		totalWidth: number,
 	): string {
-		if (this.containsImage(baseLine)) return baseLine;
+		if (TUI.containsImage(baseLine)) return baseLine;
 
 		// Single pass through baseLine extracts both before and after segments
 		const afterStart = startCol + overlayWidth;
@@ -1081,7 +1087,7 @@ export class TUI extends Container {
 			if (i > firstChanged) buffer += "\r\n";
 			buffer += "\x1b[2K"; // Clear current line
 			const line = newLines[i];
-			const isImageLine = this.containsImage(line);
+			const isImageLine = TUI.containsImage(line);
 			if (!isImageLine && visibleWidth(line) > width) {
 				// Log all lines to crash file for debugging
 				const crashLogPath = path.join(os.homedir(), ".omp", "agent", "omp-crash.log");