@oh-my-pi/pi-tui 18.6.0 → 18.6.3

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

@@ -284,6 +284,13 @@ export interface ImageRenderOptions {
     placementId?: number;
     /** When true (Kitty + {@link imageId}), also return the one-time transmit sequence. */
     includeTransmit?: boolean;
+    /**
+     * SIXEL sequence for the target pixel size renderImage computes, so the
+     * caller can encode off the JS thread: answer `undefined` while the encode
+     * is pending (the image's rows stay reserved) and `null` once it failed.
+     * Without a provider, renderImage encodes synchronously.
+     */
+    sixel?: (widthPx: number, heightPx: number) => string | null | undefined;
 }
 export declare function getCellDimensions(): CellDimensions;
 export declare function setCellDimensions(dims: CellDimensions): void;
@@ -381,6 +388,12 @@ export declare function getJpegDimensions(base64Data: string): ImageDimensions |
 export declare function getGifDimensions(base64Data: string): ImageDimensions | null;
 export declare function getWebpDimensions(base64Data: string): ImageDimensions | null;
 export declare function getImageDimensions(base64Data: string, mimeType: string): ImageDimensions | null;
+/**
+ * SIXEL sequence for `base64Data` at the given pixel size, encoded on the JS
+ * thread; `null` when the encode fails. For output that cannot wait for an
+ * off-thread encode.
+ */
+export declare function encodeSixelNow(base64Data: string, widthPx: number, heightPx: number): string | null;
 export declare function renderImage(base64Data: string, imageDimensions: ImageDimensions, options?: ImageRenderOptions): {
     sequence?: string;
     lines?: string[];

package/dist/types/tui.d.ts

@@ -150,6 +150,11 @@ export interface Component {
     describeScreen?(cx: DescribeContext): NativeScreen;
     /** User actions on nodes this component described (toggle, select, activate, custom). */
     handleNativeEvent?(event: NativeUiEvent): void;
+    /**
+     * Pure preflight for focused input that must precede TUI-wide input listeners
+     * and debug shortcuts. A true result routes the event to this component first.
+     */
+    capturesInput?(data: string): boolean;
     /**
      * Optional handler for keyboard input when component has focus
      */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.6.0",
+	"version": "18.6.3",
 	"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.6.0",
-		"@oh-my-pi/pi-agent-core": "18.6.0",
-		"@oh-my-pi/pi-ai": "18.6.0",
-		"@oh-my-pi/pi-catalog": "18.6.0",
-		"@oh-my-pi/pi-natives": "18.6.0",
-		"@oh-my-pi/pi-utils": "18.6.0",
-		"@oh-my-pi/pi-wire": "18.6.0",
-		"@oh-my-pi/snapcompact": "18.6.0"
+		"@oh-my-pi/omptype": "18.6.3",
+		"@oh-my-pi/pi-agent-core": "18.6.3",
+		"@oh-my-pi/pi-ai": "18.6.3",
+		"@oh-my-pi/pi-catalog": "18.6.3",
+		"@oh-my-pi/pi-natives": "18.6.3",
+		"@oh-my-pi/pi-utils": "18.6.3",
+		"@oh-my-pi/pi-wire": "18.6.3",
+		"@oh-my-pi/snapcompact": "18.6.3"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/app-keybindings.ts

@@ -60,6 +60,7 @@ interface AppKeybindings {
 	"app.tree.unfoldOrDown": true;
 	"app.plan.toggle": true;
 	"app.history.search": true;
+	"app.stt.pushToTalk": true;
 	"app.stt.toggle": true;
 	"app.live.toggle": true;
 }
@@ -237,9 +238,13 @@ export const KEYBINDINGS = {
 		defaultKeys: "ctrl+r",
 		description: "Search history",
 	},
+	"app.stt.pushToTalk": {
+		defaultKeys: "space",
+		description: "Hold to record speech-to-text",
+	},
 	"app.stt.toggle": {
 		defaultKeys: [],
-		description: "Toggle speech-to-text (default gesture: hold Space)",
+		description: "Toggle speech-to-text recording",
 	},
 	"app.live.toggle": {
 		defaultKeys: "ctrl+l",

package/src/apps/git/diff-pane.ts

@@ -184,6 +184,10 @@ export interface DiffBuildOptions {
 	streamResult?: DiffStreamResult;
 }
 
+function filePatchHeader(filePath: string): string {
+	return `diff --git a/${filePath} b/${filePath}\n--- a/${filePath}\n+++ b/${filePath}\n`;
+}
+
 /** Build the aligned document for one file from its raw old/new texts. */
 export function buildDiffDocument(
 	oldRaw: string,
@@ -376,10 +380,11 @@ export function buildDiffDocument(
 	// cannot use the raw streamed result because its equality basis differs.
 	const canPatch = !ignoreWs;
 	const tightHunks = streamed?.hunks ?? structuredPatchHunks(oldBasis, newBasis, DIFF_CONTEXT_LINES);
+	const patchHeader = canPatch && tightHunks.length > 0 ? filePatchHeader(filePath) : "";
 	const allHunks: HunkBlock[] = tightHunks.map(hunk => ({
 		header: `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
 		patch: canPatch
-			? `--- a/${filePath}\n+++ b/${filePath}\n@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@\n${hunk.lines.join("\n")}\n`
+			? `${patchHeader}@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@\n${hunk.lines.join("\n")}\n`
 			: "",
 		rows: walkHunk(hunk, false),
 	}));
@@ -476,7 +481,7 @@ export function buildLineSelectionPatch(
 				`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@\n${hunk.lines.join("\n")}`,
 		)
 		.join("\n");
-	return `--- a/${doc.filePath}\n+++ b/${doc.filePath}\n${body}\n`;
+	return `${filePatchHeader(doc.filePath)}${body}\n`;
 }
 
 // ── palette ──────────────────────────────────────────────────────────────────
@@ -596,6 +601,12 @@ export class DiffPane {
 	#layoutCache: { key: string; visuals: Visual[] } | undefined;
 	/** Per visible row: clickable hunk-button ranges recorded during render. */
 	#hits: ({ hunk: number; primary?: [number, number]; discard?: [number, number] } | undefined)[] = [];
+	/**
+	 * Asset images from the last render, by placement and size. Reusing them
+	 * lets a SIXEL image show the sequence its off-thread encode delivers on a
+	 * later render; a fresh `Image` per render would restart the encode forever.
+	 */
+	#assetImages = new Map<string, Image>();
 	constructor(imageBudget?: ImageBudget) {
 		this.#imageBudget = imageBudget;
 	}
@@ -721,6 +732,7 @@ export class DiffPane {
 		this.scrollLeft = 0;
 		this.cursor = 0;
 		this.anchor = null;
+		if (mode === "hunk") this.selectedHunk = 0;
 	}
 
 	cycleMode(): void {
@@ -771,6 +783,7 @@ export class DiffPane {
 			this.anchor = null;
 		}
 		this.cursor = Math.max(0, Math.min(total - 1, this.cursor + delta));
+		this.#syncHunkToCursor();
 		this.scrollTop = scrollOffsetForRow(this.scrollTop, this.cursor, total, this.#lastHeight);
 		this.#clampScroll();
 	}
@@ -854,6 +867,7 @@ export class DiffPane {
 		if (total === 0) return;
 		this.anchor = null;
 		this.cursor = edge === "start" ? 0 : total - 1;
+		this.#syncHunkToCursor();
 		this.scrollTop = scrollOffsetForRow(this.scrollTop, this.cursor, total, this.#lastHeight);
 		this.#clampScroll();
 	}
@@ -870,6 +884,19 @@ export class DiffPane {
 		}
 	}
 
+	/** Keep the hunk action and highlighted header on the cursor's hunk, including blank separators. */
+	#syncHunkToCursor(): void {
+		if (this.mode !== "hunk") return;
+		const visuals = this.#layout(this.#lastWidth || 80);
+		for (let row = this.cursor; row >= 0; row--) {
+			const visual = visuals[row];
+			if (visual?.t === "header") {
+				this.selectedHunk = visual.hunk;
+				return;
+			}
+		}
+	}
+
 	/** First visual row of every change block, in document order. */
 	#changeStarts(visuals: Visual[]): number[] {
 		const starts: number[] = [];
@@ -917,6 +944,10 @@ export class DiffPane {
 		const hit = this.#hits[row];
 		if (hit && this.#doc) {
 			this.selectedHunk = hit.hunk;
+			if (this.mode === "hunk") {
+				this.cursor = this.scrollTop + row;
+				this.anchor = null;
+			}
 			if (hit.primary && col >= hit.primary[0] && col < hit.primary[1] && this.patchTarget) {
 				return { type: "hunk-action", hunk: this.#doc.hunks[hit.hunk], action: this.patchTarget };
 			}
@@ -933,6 +964,7 @@ export class DiffPane {
 				this.anchor = null;
 			}
 			this.cursor = visual;
+			this.#syncHunkToCursor();
 			return { type: "handled" };
 		}
 		return null;
@@ -1077,8 +1109,16 @@ export class DiffPane {
 		const leftWidth = Math.max(1, Math.floor((width - 1) / 2));
 		const rightWidth = Math.max(1, width - leftWidth - 1);
 		const bodyHeight = Math.max(0, height - 1);
-		const oldLines = this.#renderAssetSide(asset.old, leftWidth, bodyHeight, `old:${asset.filePath}`);
-		const newLines = this.#renderAssetSide(asset.new, rightWidth, bodyHeight, `new:${asset.filePath}`);
+		const previousImages = this.#assetImages;
+		this.#assetImages = new Map();
+		const oldLines = this.#renderAssetSide(asset.old, leftWidth, bodyHeight, `old:${asset.filePath}`, previousImages);
+		const newLines = this.#renderAssetSide(
+			asset.new,
+			rightWidth,
+			bodyHeight,
+			`new:${asset.filePath}`,
+			previousImages,
+		);
 		const border = theme.fg("borderMuted", "│");
 		const lines: string[] = [];
 		for (let index = 0; index < height; index++) {
@@ -1099,24 +1139,36 @@ export class DiffPane {
 		return lines;
 	}
 
-	#renderAssetSide(side: FileAssetSide, width: number, height: number, placementKey: string): readonly string[] {
+	#renderAssetSide(
+		side: FileAssetSide,
+		width: number,
+		height: number,
+		placementKey: string,
+		previousImages: ReadonlyMap<string, Image>,
+	): readonly string[] {
 		if (height <= 0) return [];
 		let content: readonly string[];
 		if (side.kind === "image") {
 			const image = side.image;
-			content = new Image(
-				image.data,
-				image.mimeType,
-				{ fallbackColor: text => theme.fg("dim", text) },
-				{
-					maxWidthCells: Math.max(1, width - 2),
-					maxHeightCells: height,
-					filename: this.#asset?.filePath,
-					budget: this.#imageBudget,
-					imageKey: `git-review:${placementKey}:${image.key}`,
-				},
-				{ widthPx: image.widthPx, heightPx: image.heightPx },
-			).render(width);
+			const imageKey = `git-review:${placementKey}:${image.key}`;
+			const cacheKey = `${imageKey}:${width}x${height}`;
+			const component =
+				previousImages.get(cacheKey) ??
+				new Image(
+					image.data,
+					image.mimeType,
+					{ fallbackColor: text => theme.fg("dim", text) },
+					{
+						maxWidthCells: Math.max(1, width - 2),
+						maxHeightCells: height,
+						filename: this.#asset?.filePath,
+						budget: this.#imageBudget,
+						imageKey,
+					},
+					{ widthPx: image.widthPx, heightPx: image.heightPx },
+				);
+			this.#assetImages.set(cacheKey, component);
+			content = component.render(width);
 		} else {
 			let details: string[];
 			switch (side.kind) {

package/src/apps/git/git-tui.ts

@@ -13,8 +13,9 @@
  * arrows/PgUp/PgDn, vim motions (`j`/`k`/`h`/`l`/`g`/`G`), and mouse
  * clicks/wheel. All toolbar buttons are clickable and mirrored by keys:
  * `v` cycles the view (`1`–`4` pick one), `alt+↓`/`alt+↑` jump hunks and roll
- * into the adjacent file at the edges, `]`/`[` switch files, `s`/`u`
- * stage/unstage (hunk-aware), `x` discards a hunk, `delete` discards the
+ * into the adjacent file at the edges, `space` stages/unstages the focused
+ * diff row (the focused hunk in hunk view), `s`/`u` stage/unstage
+ * (hunk-aware), `x` discards a hunk, `delete` discards the
  * whole file (press twice to confirm), `w` wraps, `b` cycles
  * whitespace handling (exact → ignore whitespace → ignore
  * formatting/import-only changes), `c` jumps to the commit form, `r`
@@ -25,7 +26,7 @@
  */
 
 import type { TspSpan } from "@oh-my-pi/pi-wire";
-import { formatKeyHint, formatKeyHints } from "../../app-keybindings";
+import { formatKeyHint, formatKeyHints, formatTooltipKey } from "../../app-keybindings";
 import { SplitPane } from "../../components/layout/split-pane";
 import { Stack } from "../../components/layout/stack";
 import { matchesKey } from "../../keys";
@@ -669,14 +670,20 @@ class GitTuiComponent implements Component {
 			else if (matchesKey(data, "up") || data === "k") this.#pane.moveCursor(-1, false);
 			else if (matchesKey(data, "down") || data === "j") this.#pane.moveCursor(1, false);
 			else if (matchesKey(data, "pageUp")) this.#pane.moveCursor(-Math.max(1, this.#contentHeight - 2), false);
-			else if (matchesKey(data, "pageDown") || data === " ")
-				this.#pane.moveCursor(Math.max(1, this.#contentHeight - 2), false);
+			else if (matchesKey(data, "pageDown")) this.#pane.moveCursor(Math.max(1, this.#contentHeight - 2), false);
 			else if (matchesKey(data, "left") || data === "h") this.#pane.scrollLeftBy(-8);
 			else if (matchesKey(data, "right") || data === "l") this.#pane.scrollLeftBy(8);
 			else if (matchesKey(data, "home") || data === "g") this.#pane.cursorToEdge("start");
 			else if (matchesKey(data, "end") || data === "G") this.#pane.cursorToEdge("end");
 			else if (matchesKey(data, "enter")) return this.#jumpHunkOrFile(1);
-			else if (data === "s" || data === "u") {
+			else if (matchesKey(data, "space")) {
+				// Hunk-view rows do not map back to document rows, so Space acts on the focused hunk there.
+				const target = this.#pane.patchTarget;
+				const hunk = this.#pane.mode === "hunk" ? this.#pane.currentHunk : null;
+				if (target && hunk) void this.#hunkAction(hunk, target);
+				else if (target && this.#pane.selection) void this.#lineAction(target);
+				return;
+			} else if (data === "s" || data === "u") {
 				if (this.#pane.selection?.explicit && this.#pane.patchTarget) {
 					void this.#lineAction(this.#pane.patchTarget);
 					return;
@@ -1023,8 +1030,8 @@ class GitTuiComponent implements Component {
 		const right: NativeNode[] = [
 			row(
 				[
-					iconButton("chev-up", "prev-hunk", `Previous change (${formatKeyHint("alt+up")})`),
-					iconButton("chev", "next-hunk", `Next change (${formatKeyHint("alt+down")})`),
+					iconButton("chev-up", "prev-hunk", `Previous change (${formatTooltipKey("alt+up")})`),
+					iconButton("chev", "next-hunk", `Next change (${formatTooltipKey("alt+down")})`),
 				],
 				{ gap: "none", align: "center" },
 			),
@@ -1045,13 +1052,13 @@ class GitTuiComponent implements Component {
 					"type",
 					"whitespace",
 					this.#whitespace === "off"
-						? `Ignore whitespace (${formatKeyHint("b")})`
+						? `Ignore whitespace (${formatTooltipKey("b")})`
 						: this.#whitespace === "whitespace"
-							? `Ignoring whitespace; also ignore formatting (${formatKeyHint("b")})`
-							: `Ignoring formatting and imports; show all (${formatKeyHint("b")})`,
+							? `Ignoring whitespace; also ignore formatting (${formatTooltipKey("b")})`
+							: `Ignoring formatting and imports; show all (${formatTooltipKey("b")})`,
 					this.#whitespace !== "off",
 				),
-				iconButton("corner-down-right", "wrap", `Wrap lines (${formatKeyHint("w")})`, this.#pane.wrap),
+				iconButton("corner-down-right", "wrap", `Wrap lines (${formatTooltipKey("w")})`, this.#pane.wrap),
 			);
 		}
 		if (file?.area === "unstaged" || file?.area === "staged") {
@@ -1063,8 +1070,8 @@ class GitTuiComponent implements Component {
 			);
 		}
 		right.push(
-			iconButton("keyboard", "help", `Keyboard shortcuts (${formatKeyHint("?")})`),
-			iconButton("x", "close", `Close (${formatKeyHint("q")})`),
+			iconButton("keyboard", "help", `Keyboard shortcuts (${formatTooltipKey("?")})`),
+			iconButton("x", "close", `Close (${formatTooltipKey("q")})`),
 		);
 		return keyed(
 			row(

package/src/apps/git/sidebar.ts

@@ -1699,7 +1699,12 @@ export class Sidebar {
 					png,
 					"image/png",
 					{ fallbackColor: text => theme.fg("dim", text) },
-					{ maxHeightCells: 3, budget: this.#imageBudget, imageKey: `git-avatar:${email}` },
+					{
+						maxHeightCells: 3,
+						budget: this.#imageBudget,
+						imageKey: `git-avatar:${email}`,
+						requestRender: this.#requestRender,
+					},
 				),
 			};
 		}

package/src/chat/assistant-message.ts

@@ -456,6 +456,7 @@ export class AssistantMessageComponent extends Container {
 	readonly #thinkingRenderers: readonly AssistantThinkingRenderer[];
 	readonly #imageBudget?: ImageBudget;
 	#proseOnlyThinking: boolean;
+	#expandThinkingBlocks: boolean;
 
 	constructor(
 		message?: AssistantMessage,
@@ -465,6 +466,7 @@ export class AssistantMessageComponent extends Container {
 		imageBudget?: ImageBudget,
 		proseOnlyThinking = true,
 		linkTargets?: ReadonlyMap<string, string>,
+		expandThinkingBlocks = false,
 	) {
 		super();
 		this.#hideThinkingBlock = hideThinkingBlock;
@@ -472,6 +474,7 @@ export class AssistantMessageComponent extends Container {
 		this.#thinkingRenderers = thinkingRenderers;
 		this.#imageBudget = imageBudget;
 		this.#proseOnlyThinking = proseOnlyThinking;
+		this.#expandThinkingBlocks = expandThinkingBlocks;
 
 		ensureThemeSync();
 		this.#transcriptBlockFinalized = message !== undefined;
@@ -560,6 +563,16 @@ export class AssistantMessageComponent extends Container {
 		this.#proseOnlyThinking = proseOnly;
 	}
 
+	/**
+	 * Keep finished thinking sections expanded instead of folding them to "Thought for 12s".
+	 * Sections the user folded or unfolded by hand keep that choice.
+	 */
+	setExpandThinkingBlocks(expand: boolean): void {
+		if (this.#expandThinkingBlocks === expand) return;
+		this.#expandThinkingBlocks = expand;
+		this.#nativeViewVersion++;
+	}
+
 	override dispose(): void {
 		this.#stopThinkingAnimation();
 		super.dispose();
@@ -831,8 +844,10 @@ export class AssistantMessageComponent extends Container {
 								// `.live` while streaming: the body clamps to its tail under a fade.
 								role: thinkingLive ? "omp.thinking.live" : "omp.thinking",
 								collapsible: true,
-								// Open while it streams; a finished thought folds to its "Thought for 12s" line.
-								collapsed: this.#thinkingCollapsed.get(index) ?? (this.#hideThinkingBlock || !thinkingLive),
+								// Open while it streams; a finished thought folds to its "Thought for 12s" line unless the user keeps thinking expanded.
+								collapsed:
+									this.#thinkingCollapsed.get(index) ??
+									(this.#hideThinkingBlock || (!thinkingLive && !this.#expandThinkingBlocks)),
 								// Tern's fold head sums it into "Worked for 12s".
 								took: clock?.end === undefined ? undefined : Math.max(0, Math.round(clock.end - clock.start)),
 							},
@@ -1373,7 +1388,12 @@ export class AssistantMessageComponent extends Container {
 						displayImage.data,
 						displayImage.mimeType,
 						{ fallbackColor: (text: string) => theme.fg("toolOutput", text) },
-						{ ...resolveImageOptions(), budget: this.#imageBudget, imageKey: key },
+						{
+							...resolveImageOptions(),
+							budget: this.#imageBudget,
+							imageKey: key,
+							requestRender: this.#onImageUpdate,
+						},
 					),
 				);
 				continue;
@@ -1415,7 +1435,9 @@ export class AssistantMessageComponent extends Container {
 	}
 
 	#computeShapeKey(message: AssistantMessage): string {
-		const parts: string[] = [`htb:${this.#hideThinkingBlock ? 1 : 0}|pot:${this.#proseOnlyThinking ? 1 : 0}`];
+		const parts: string[] = [
+			`htb:${this.#hideThinkingBlock ? 1 : 0}|pot:${this.#proseOnlyThinking ? 1 : 0}|etb:${this.#expandThinkingBlocks ? 1 : 0}`,
+		];
 		for (const content of message.content) {
 			if (content.type === "text") {
 				parts.push(canonicalizeMessage(content.text) ? "T1" : "T0");

package/src/chat/chat-transcript-builder.ts

@@ -80,6 +80,7 @@ export interface ChatTranscriptBuilderDeps {
 	cwd: string;
 	hideThinkingBlock?: () => boolean;
 	proseOnlyThinking?: () => boolean;
+	expandThinkingBlocks?: () => boolean;
 	/** Session-scoped resolved destinations for model-authored Markdown links. */
 	linkTargets?: ReadonlyMap<string, string>;
 	requestRender: () => void;
@@ -404,6 +405,7 @@ export class ChatTranscriptBuilder {
 	#appendAssistantMessage(message: Extract<AgentMessage, { role: "assistant" }>): void {
 		const hideThinkingBlock = this.#deps.hideThinkingBlock?.() ?? false;
 		const proseOnlyThinking = this.#deps.proseOnlyThinking ? this.#deps.proseOnlyThinking() : true;
+		const expandThinkingBlocks = this.#deps.expandThinkingBlocks?.() ?? false;
 		const timeline = splitAssistantMessageToolTimeline(message);
 		const assistantComponent = new AssistantMessageComponent(
 			timeline.beforeTools,
@@ -413,6 +415,7 @@ export class ChatTranscriptBuilder {
 			this.#deps.ui.imageBudget,
 			proseOnlyThinking,
 			this.#deps.linkTargets,
+			expandThinkingBlocks,
 		);
 		assistantComponent.setImagesVisible(displayPreferences.showImages);
 		assistantComponent.setToolResultImagesVisible(!displayPreferences.hideToolActivity);
@@ -450,6 +453,7 @@ export class ChatTranscriptBuilder {
 				undefined,
 				proseOnlyThinking,
 				this.#deps.linkTargets,
+				expandThinkingBlocks,
 			);
 			component.setImagesVisible(displayPreferences.showImages);
 			component.setToolResultImagesVisible(!displayPreferences.hideToolActivity);

package/src/chat/tool-execution.ts

@@ -1639,7 +1639,12 @@ export class ToolExecutionComponent extends Container {
 						imageData,
 						imageMimeType,
 						{ fallbackColor: (s: string) => theme.fg("toolOutput", s) },
-						{ ...resolveImageOptions(), budget: this.#ui.imageBudget, imageKey: `te${this.#instanceId}:${i}` },
+						{
+							...resolveImageOptions(),
+							budget: this.#ui.imageBudget,
+							imageKey: `te${this.#instanceId}:${i}`,
+							requestRender: () => this.#ui.requestRender(),
+						},
 					);
 					this.#imageComponents.push(imageComponent);
 					this.addChild(imageComponent);

package/src/chat/user-message.ts

@@ -24,7 +24,13 @@ import type { ReactionTarget } from "./reaction";
 import { card, md, node, row, span, text } from "../native/describe";
 import { base64ImageNode } from "../native/blobs";
 import { hasTranscriptActions, runTranscriptAction } from "./transcript-actions";
-import { type NativeChild, type NativeNode, type NativeUiEvent, rootToggleExpanded } from "../native/node";
+import {
+	type DescribeContext,
+	type NativeChild,
+	type NativeNode,
+	type NativeUiEvent,
+	rootToggleExpanded,
+} from "../native/node";
 import { Memo } from "../native/memo";
 
 // OSC 133 shell integration: marks prompt zones for terminal multiplexers.
@@ -137,6 +143,8 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 	readonly #tokens: RegExp;
 	#reaction: string | undefined;
 	#native: NativeNode | undefined;
+	/** The terminal's clock {@link #native} was described with. */
+	#nativeHour12: boolean | undefined;
 
 	constructor(text: string, options: UserBubbleOptions = {}) {
 		super();
@@ -184,17 +192,20 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 	 * agent's reaction are chips at the bottom-right, so a reaction landing
 	 * later updates the frame in place, even deep in scrollback.
 	 */
-	override describe(): NativeNode {
-		if (this.#native) return this.#native;
+	override describe(cx?: DescribeContext): NativeNode {
+		// The terminal's clock: Bun's own default locale ignores the user's.
+		const hour12 = cx?.hour12;
+		if (this.#native && this.#nativeHour12 === hour12) return this.#native;
+		this.#nativeHour12 = hour12;
 		const children: NativeChild[] = [];
 		if (!this.#synthetic && hasTranscriptActions()) {
 			const tools: NativeChild[] = [];
 			if (this.#timestamp !== undefined) {
 				const at = new Date(this.#timestamp);
 				tools.push(
-					text([span(at.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }), "dim mono")], {
+					text([span(at.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", hour12 }), "dim mono")], {
 						role: "omp.user.time",
-						title: at.toLocaleString(),
+						title: at.toLocaleString([], { hour12 }),
 					}),
 				);
 			}

package/src/chrome/status-notice.ts

@@ -1,6 +1,6 @@
 import { Spacer } from "../components/spacer";
 import { Text } from "../components/text";
-import { node } from "../native/describe";
+import { EMPTY_NODE, node } from "../native/describe";
 import type { NativeNode } from "../native/node";
 import { styledSpans } from "../native/spans";
 import { Container } from "../tui";
@@ -8,33 +8,51 @@ import { Container } from "../tui";
 /** How long a native status toast stays up (ms). */
 const TOAST_TTL = 2400;
 
+/** How a {@link StatusNotice} shows. */
+export interface StatusNoticeOptions {
+	/** Styles the ANSI line; resolved at render so a theme change re-shapes it. */
+	styleFn?: (text: string) => string;
+	/**
+	 * Whether a native terminal toasts it (default). False keeps the notice to
+	 * the ANSI transcript: background chatter such as MCP connection progress,
+	 * which would otherwise re-toast on every server that connects or fails.
+	 */
+	toast?: boolean;
+}
+
 /**
  * A transient status notice (`showStatus`: "Thinking blocks: hidden", "Copied
  * to clipboard"). The ANSI render appends a blank row and the dim line to the
  * transcript; a native terminal shows it as a toast instead, so notices never
- * pile up in the history. Updating the text re-shows the toast.
+ * pile up in the history. Updating the text re-shows the toast; a notice
+ * with `toast: false` describes nothing natively.
  */
 export class StatusNotice extends Container {
 	readonly #text: Text;
 	#message: string;
+	#toast: boolean;
 	#native: NativeNode | undefined;
 
-	constructor(message: string, styleFn?: (text: string) => string) {
+	constructor(message: string, options: StatusNoticeOptions = {}) {
 		super();
 		this.#message = message;
-		this.#text = new Text(message, 1, 0).setStyleFn(styleFn);
+		this.#toast = options.toast ?? true;
+		this.#text = new Text(message, 1, 0).setStyleFn(options.styleFn);
 		this.addChild(new Spacer(1));
 		this.addChild(this.#text);
 	}
 
-	setMessage(message: string, styleFn?: (text: string) => string): void {
-		this.#text.setStyleFn(styleFn);
+	setMessage(message: string, options: StatusNoticeOptions = {}): void {
+		const toast = options.toast ?? true;
+		this.#text.setStyleFn(options.styleFn);
 		this.#text.setText(message);
-		if (message !== this.#message) this.#native = undefined;
+		if (message !== this.#message || toast !== this.#toast) this.#native = undefined;
 		this.#message = message;
+		this.#toast = toast;
 	}
 
 	override describe(): NativeNode {
+		if (!this.#toast) return EMPTY_NODE;
 		if (this.#native) return this.#native;
 		// Callers may pass pre-styled text; a toast takes plain text.
 		const plain = styledSpans(this.#message)

package/src/chrome/transcript-container.ts

@@ -1,6 +1,7 @@
 import { type Component, Container, type HistoryBatch } from "../tui";
 import * as logger from "@oh-my-pi/pi-utils/logger";
 import { popLoopPhase, pushLoopPhase } from "@oh-my-pi/pi-utils";
+import { renderForScrollback } from "../components/image";
 import { col } from "../native/describe";
 import type { NativeNode } from "../native/node";
 import { isNativeSettled, settleNative } from "../native/settle";
@@ -1000,9 +1001,11 @@ export class TranscriptContainer extends Container {
 			// Only the range head is sliced by its emitted stable prefix; every other
 			// entry renders whole, so the append-only verification pass (a second
 			// full render of the block's stable prefix) is skipped for them. This
-			// keeps a complete-ledger replay at one render per block.
-			const rendered =
-				index === start ? this.#renderEntry(entry, width) : trimBlankEdges(entry.component.render(width));
+			// keeps a complete-ledger replay at one render per block. These rows go
+			// to native scrollback, where nothing can repaint them.
+			const rendered = renderForScrollback(() =>
+				index === start ? this.#renderEntry(entry, width) : trimBlankEdges(entry.component.render(width)),
+			);
 			const emittedRows = index === start ? this.#renderStablePrefix(entry, entry.emitted, width).length : 0;
 			const block = rendered.slice(emittedRows);
 			reached = index + 1;

package/src/components/editor.ts

@@ -3042,6 +3042,20 @@ export class Editor implements Component, Focusable {
 		return true;
 	}
 
+	/** Whether a character-jump hotkey is waiting for its target character. */
+	get isJumpPending(): boolean {
+		return this.#jumpMode !== null;
+	}
+
+	/** Type literal text through the character-editing pipeline without keybinding dispatch. */
+	typeCharacter(text: string): void {
+		// Same as #handleInputChunk: typed input wins over a stale in-flight provider lookup.
+		if (this.#autocompleteRequestRunning && this.#autocompleteState === null) {
+			this.#invalidateAutocompleteRequests();
+		}
+		this.#insertCharacter(text);
+	}
+
 	#insertCharacter(char: string): void {
 		this.#exitHistoryForEditing();
 		// Undo coalescing: consecutive word typing collapses into one undo unit