@oh-my-pi/pi-coding-agent 15.10.2 → 15.10.4

package/src/lsp/index.ts

@@ -40,7 +40,6 @@ import {
 	rangesOverlap,
 } from "./edits";
 import { detectLspmux } from "./lspmux";
-import { renderCall, renderResult } from "./render";
 import {
 	type CodeAction,
 	type CodeActionContext,
@@ -302,6 +301,22 @@ function isProjectAwareLspServer(serverConfig: ServerConfig): boolean {
 const DIAGNOSTIC_MESSAGE_LIMIT = 50;
 const SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 3000;
 const BATCH_DIAGNOSTICS_WAIT_TIMEOUT_MS = 400;
+const DIAGNOSTICS_POLL_MS = 100;
+const DIAGNOSTICS_SETTLE_MS = 250;
+/**
+ * How long the edit/write writethrough blocks inline waiting for fresh
+ * diagnostics before handing slow servers off to the deferred late-injection
+ * channel. Keeps the common fast-server case inline while letting an edit
+ * return promptly when a server (e.g. a large-monorepo tsserver) is slow to
+ * publish fresh diagnostics.
+ */
+const INLINE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 500;
+/**
+ * Inner per-server diagnostics wait budget for the background/deferred fetch.
+ * Longer than the inline cap (and the old 3s default) so a slow server still
+ * delivers late instead of giving up before it ever publishes.
+ */
+const DEFERRED_DIAGNOSTICS_WAIT_TIMEOUT_MS = 12_000;
 const MAX_GLOB_DIAGNOSTIC_TARGETS = 20;
 const WORKSPACE_SYMBOL_LIMIT = 200;
 const PROJECT_INDEXED_ACTIONS: ReadonlySet<string> = new Set([
@@ -461,27 +476,15 @@ interface WaitForDiagnosticsOptions {
 	signal?: AbortSignal;
 	minVersion?: number;
 	expectedDocumentVersion?: number;
-	allowUnversioned?: boolean;
-}
-
-function getAcceptedDiagnostics(
-	publishedDiagnostics: PublishedDiagnostics | undefined,
-	expectedDocumentVersion?: number,
-	allowUnversioned = true,
-): Diagnostic[] | undefined {
-	if (!publishedDiagnostics) {
-		return undefined;
-	}
-	if (expectedDocumentVersion === undefined) {
-		return publishedDiagnostics.diagnostics;
-	}
-	if (publishedDiagnostics.version === expectedDocumentVersion) {
-		return publishedDiagnostics.diagnostics;
-	}
-	if (allowUnversioned && publishedDiagnostics.version == null) {
-		return publishedDiagnostics.diagnostics;
-	}
-	return undefined;
+	/**
+	 * Quiescence window (ms). typescript-language-server never echoes the document
+	 * version (issue #983) and emits diagnostics from several sources at different
+	 * times, so there is no single "complete, version-matched" publish to gate on.
+	 * When the server does not exact-version-match, accept the latest publish only
+	 * after no newer one has arrived for this long, letting an in-flight pre-edit
+	 * publish be superseded by the fresh one.
+	 */
+	settleMs?: number;
 }
 
 async function waitForDiagnostics(
@@ -489,26 +492,35 @@ async function waitForDiagnostics(
 	uri: string,
 	options: WaitForDiagnosticsOptions = {},
 ): Promise<Diagnostic[]> {
-	const { timeoutMs = 3000, signal, minVersion, expectedDocumentVersion, allowUnversioned = true } = options;
+	const { timeoutMs = 3000, signal, minVersion, expectedDocumentVersion, settleMs = DIAGNOSTICS_SETTLE_MS } = options;
 	const start = Date.now();
+	let settledRef: PublishedDiagnostics | undefined;
+	let settledAt = 0;
 	while (Date.now() - start < timeoutMs) {
 		throwIfAborted(signal);
 		const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
-		const diagnostics = getAcceptedDiagnostics(
-			client.diagnostics.get(uri),
-			expectedDocumentVersion,
-			allowUnversioned,
-		);
-		if (diagnostics !== undefined && versionOk) {
-			return diagnostics;
+		const published = client.diagnostics.get(uri);
+		if (published && versionOk) {
+			// Server honored our exact document version → authoritative, accept now.
+			if (expectedDocumentVersion !== undefined && published.version === expectedDocumentVersion) {
+				return published.diagnostics;
+			}
+			// Unversioned/mismatched publish: wait for the stream to go quiet so an
+			// in-flight publish for the pre-edit content is superseded by the fresh one.
+			if (published !== settledRef) {
+				settledRef = published;
+				settledAt = Date.now();
+			} else if (Date.now() - settledAt >= settleMs) {
+				return published.diagnostics;
+			}
 		}
-		await Bun.sleep(100);
+		await Bun.sleep(DIAGNOSTICS_POLL_MS);
 	}
 	const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
 	if (!versionOk) {
 		return [];
 	}
-	return getAcceptedDiagnostics(client.diagnostics.get(uri), expectedDocumentVersion, allowUnversioned) ?? [];
+	return client.diagnostics.get(uri)?.diagnostics ?? [];
 }
 
 /** Project type detection result */
@@ -613,7 +625,8 @@ interface GetDiagnosticsForFileOptions {
 	signal?: AbortSignal;
 	minVersions?: ServerVersionMap;
 	expectedDocumentVersions?: ServerVersionMap;
-	allowUnversionedLspDiagnostics?: boolean;
+	/** Per-server wait budget (ms). Defaults to {@link SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS}. */
+	timeoutMs?: number;
 }
 
 /**
@@ -669,7 +682,7 @@ async function getDiagnosticsForFile(
 	servers: Array<[string, ServerConfig]>,
 	options: GetDiagnosticsForFileOptions = {},
 ): Promise<FileDiagnosticsResult | undefined> {
-	const { signal, minVersions, expectedDocumentVersions, allowUnversionedLspDiagnostics = true } = options;
+	const { signal, minVersions, expectedDocumentVersions, timeoutMs } = options;
 	if (servers.length === 0) {
 		return undefined;
 	}
@@ -701,11 +714,10 @@ async function getDiagnosticsForFile(
 			const minVersion = minVersions?.get(serverName);
 			const expectedDocumentVersion = expectedDocumentVersions?.get(serverName);
 			const diagnostics = await waitForDiagnostics(client, uri, {
-				timeoutMs: 3000,
+				timeoutMs: timeoutMs ?? SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS,
 				signal,
 				minVersion,
 				expectedDocumentVersion,
-				allowUnversioned: allowUnversionedLspDiagnostics,
 			});
 			return { serverName, diagnostics };
 		}),
@@ -1007,6 +1019,7 @@ async function scheduleDeferredDiagnosticsFetch(args: {
 			signal: combined,
 			minVersions: args.minVersions,
 			expectedDocumentVersions: args.expectedDocumentVersions,
+			timeoutMs: DEFERRED_DIAGNOSTICS_WAIT_TIMEOUT_MS,
 		});
 		if (args.signal.aborted || diagnostics === undefined) return;
 		args.callback(diagnostics);
@@ -1015,6 +1028,70 @@ async function scheduleDeferredDiagnosticsFetch(args: {
 	}
 }
 
+/**
+ * Fetch post-write diagnostics without making the edit/write block on a slow
+ * language server.
+ *
+ * Blocks inline only briefly ({@link INLINE_DIAGNOSTICS_WAIT_TIMEOUT_MS}) for a
+ * fresh result. Freshness is enforced by the pre-edit `minVersions` baseline:
+ * exact document-version matches return immediately, and unversioned/mismatched
+ * publishes must settle with no newer publish before inline acceptance. If
+ * nothing fresh arrives in the inline window and a deferred
+ * channel is available, the in-flight fetch is handed off to deliver late via
+ * `onDeferredDiagnostics`, and this returns `undefined` so the tool result
+ * lands immediately. Without a deferred channel (direct/CI callers) it blocks
+ * for the standard budget so the result is still returned inline.
+ */
+async function fetchDiagnosticsWithDeferral(args: {
+	dst: string;
+	cwd: string;
+	servers: Array<[string, ServerConfig]>;
+	minVersions: ServerVersionMap | undefined;
+	expectedDocumentVersions: ServerVersionMap | undefined;
+	transformDiagnostics?: ResolvedWritethroughOptions["transformDiagnostics"];
+	deferred?: { onDeferredDiagnostics: (diagnostics: FileDiagnosticsResult) => void; signal: AbortSignal };
+	signal?: AbortSignal;
+}): Promise<FileDiagnosticsResult | undefined> {
+	const { dst, cwd, servers, minVersions, expectedDocumentVersions, transformDiagnostics, deferred, signal } = args;
+	const apply = (d: FileDiagnosticsResult | undefined) =>
+		d && transformDiagnostics ? transformDiagnostics(dst, d) : d;
+
+	if (!deferred) {
+		// No late-injection channel: block for the standard budget and return inline.
+		return apply(
+			await getDiagnosticsForFile(dst, cwd, servers, {
+				signal,
+				minVersions,
+				expectedDocumentVersions,
+			}),
+		);
+	}
+
+	// One background fetch with a generous inner budget; await it only briefly inline.
+	const fetchPromise = getDiagnosticsForFile(dst, cwd, servers, {
+		signal: deferred.signal,
+		minVersions,
+		expectedDocumentVersions,
+		timeoutMs: DEFERRED_DIAGNOSTICS_WAIT_TIMEOUT_MS,
+	});
+	const INLINE_TIMEOUT = Symbol("inline-diagnostics-timeout");
+	const raced = await Promise.race([
+		fetchPromise,
+		Bun.sleep(INLINE_DIAGNOSTICS_WAIT_TIMEOUT_MS).then(() => INLINE_TIMEOUT),
+	]);
+	if (raced !== INLINE_TIMEOUT) {
+		return apply(raced as FileDiagnosticsResult | undefined);
+	}
+	// Slow server: deliver late via the deferred channel; nothing inline. The
+	// deferred sink (edit tool) applies its own dedup, so pass the raw result.
+	void fetchPromise
+		.then(diagnostics => {
+			if (diagnostics && !deferred.signal.aborted) deferred.onDeferredDiagnostics(diagnostics);
+		})
+		.catch(() => {});
+	return undefined;
+}
+
 async function runLspWritethrough(
 	dst: string,
 	content: string,
@@ -1047,6 +1124,7 @@ async function runLspWritethrough(
 	let formatter: FileFormatResult | undefined;
 	let diagnostics: FileDiagnosticsResult | undefined;
 	let timedOut = false;
+	let synced = false;
 	try {
 		const timeoutSignal = AbortSignal.timeout(5_000);
 		timeoutSignal.addEventListener(
@@ -1090,19 +1168,8 @@ async function runLspWritethrough(
 
 			// 5. Notify saved to LSP servers
 			await notifyFileSaved(dst, cwd, lspServers, operationSignal);
-
-			// 6. Get diagnostics from all servers (wait for fresh results)
-			if (enableDiagnostics) {
-				const fetched = await getDiagnosticsForFile(dst, cwd, servers, {
-					signal: operationSignal,
-					minVersions,
-					expectedDocumentVersions,
-					allowUnversionedLspDiagnostics: false,
-				});
-				diagnostics =
-					fetched && options.transformDiagnostics ? options.transformDiagnostics(dst, fetched) : fetched;
-			}
 		});
+		synced = true;
 	} catch {
 		if (timedOut) {
 			formatter = undefined;
@@ -1123,6 +1190,19 @@ async function runLspWritethrough(
 		await getWritePromise();
 	}
 
+	if (synced && enableDiagnostics) {
+		diagnostics = await fetchDiagnosticsWithDeferral({
+			dst,
+			cwd,
+			servers,
+			minVersions,
+			expectedDocumentVersions,
+			transformDiagnostics: options.transformDiagnostics,
+			deferred,
+			signal,
+		});
+	}
+
 	if (formatter !== undefined) {
 		diagnostics ??= {
 			server: servers.map(([name]) => name).join(", "),
@@ -1229,10 +1309,6 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 	readonly summary = "Query LSP (language server) for diagnostics, hover info, and references";
 	readonly description: string;
 	readonly parameters = lspSchema;
-	readonly renderCall = renderCall;
-	readonly renderResult = renderResult;
-	readonly mergeCallAndResult = true;
-	readonly inline = true;
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {

package/src/main.ts

@@ -171,7 +171,8 @@ export async function submitInteractiveInput(
 
 	try {
 		using _keepalive = new EventLoopKeepalive();
-		// Continue shortcuts submit an already-started empty prompt with no optimistic user message.
+		// Continue shortcuts submit an already-started synthetic developer prompt with
+		// no optimistic user message.
 		if (!input.started && !mode.markPendingSubmissionStarted(input)) {
 			return;
 		}
@@ -182,6 +183,8 @@ export async function submitInteractiveInput(
 				display: input.display ?? false,
 				attribution: "agent",
 			});
+		} else if (input.synthetic) {
+			await session.prompt(input.text, { synthetic: true, expandPromptTemplates: false });
 		} else {
 			await session.prompt(input.text, { images: input.images });
 		}
@@ -381,6 +384,22 @@ async function promptMoveSession(session: SessionInfo): Promise<SessionPromptRes
 	}
 }
 
+/**
+ * Friendly CLI failure raised by {@link createSessionManager} when the user's
+ * session-resolution flags (`--resume`/`--fork`/cross-project prompts) cannot
+ * be satisfied. {@link runRootCommand} catches it and prints a clean stderr
+ * message instead of letting it surface as `[Uncaught Exception]`
+ * (see issue #2084).
+ */
+export class SessionResolutionError extends Error {
+	readonly hint?: string;
+	constructor(message: string, hint?: string) {
+		super(message);
+		this.name = "SessionResolutionError";
+		this.hint = hint;
+	}
+}
+
 type MissingCwdMoveResult =
 	| { status: "not-needed" }
 	| { status: "declined" }
@@ -400,7 +419,7 @@ async function moveMissingCwdSessionIfNeeded(
 
 	const movePromptResult = await askToMoveSession(session);
 	if (movePromptResult === "unavailable") {
-		throw new Error(
+		throw new SessionResolutionError(
 			`Session "${sessionArg}" belongs to a directory that no longer exists (${sourceCwd}); run interactively to move it into the current project.`,
 		);
 	}
@@ -463,7 +482,7 @@ export async function createSessionManager(
 ): Promise<SessionManager | undefined> {
 	if (parsed.fork) {
 		if (parsed.noSession) {
-			throw new Error("--fork requires session persistence");
+			throw new SessionResolutionError("--fork requires session persistence");
 		}
 		const forkSource = parsed.fork;
 		if (forkSource.includes("/") || forkSource.includes("\\") || forkSource.endsWith(".jsonl")) {
@@ -471,7 +490,10 @@ export async function createSessionManager(
 		}
 		const match = await resolveResumableSession(forkSource, cwd, parsed.sessionDir);
 		if (!match) {
-			throw new Error(`Session "${forkSource}" not found.`);
+			throw new SessionResolutionError(
+				`Session "${forkSource}" not found.`,
+				"Run `omp --resume` without an argument to pick from recent sessions, or `omp` to start a new one.",
+			);
 		}
 		return await SessionManager.forkFrom(match.session.path, cwd, parsed.sessionDir);
 	}
@@ -486,7 +508,10 @@ export async function createSessionManager(
 		}
 		const match = await resolveResumableSession(sessionArg, cwd, parsed.sessionDir);
 		if (!match) {
-			throw new Error(`Session "${sessionArg}" not found.`);
+			throw new SessionResolutionError(
+				`Session "${sessionArg}" not found.`,
+				"Run `omp --resume` without an argument to pick from recent sessions, or `omp` to start a new one.",
+			);
 		}
 		if (match.scope === "local") {
 			const moveResult = await moveMissingCwdSessionIfNeeded(
@@ -522,7 +547,7 @@ export async function createSessionManager(
 				}
 				const forkPromptResult = await askToForkSession(match.session);
 				if (forkPromptResult === "unavailable") {
-					throw new Error(
+					throw new SessionResolutionError(
 						`Session "${sessionArg}" is in another project (${match.session.cwd}); run interactively to fork it into the current project.`,
 					);
 				}
@@ -919,14 +944,29 @@ export async function runRootCommand(
 		);
 	}
 
-	// Create session manager based on CLI flags
-	let sessionManager = await logger.time(
-		"createSessionManager",
-		createSessionManager,
-		parsedArgs,
-		cwd,
-		settingsInstance,
-	);
+	// Create session manager based on CLI flags. SessionResolutionError signals a
+	// user-facing failure (unknown --resume/--fork id, non-interactive fork
+	// prompt, --fork with --no-session): print + exit cleanly instead of letting
+	// it surface as `[Uncaught Exception]` (see issue #2084).
+	let sessionManager: SessionManager | undefined;
+	try {
+		sessionManager = await logger.time(
+			"createSessionManager",
+			createSessionManager,
+			parsedArgs,
+			cwd,
+			settingsInstance,
+		);
+	} catch (error: unknown) {
+		if (error instanceof SessionResolutionError) {
+			process.stderr.write(`${chalk.red(`Error: ${error.message}`)}\n`);
+			if (error.hint) {
+				process.stderr.write(`${chalk.dim(error.hint)}\n`);
+			}
+			process.exit(1);
+		}
+		throw error;
+	}
 
 	// User declined the cross-project fork prompt — exit cleanly with a friendly
 	// message rather than letting the decline bubble up as an uncaught exception

package/src/modes/components/assistant-message.ts

@@ -4,7 +4,7 @@ import { formatNumber } from "@oh-my-pi/pi-utils";
 import { settings } from "../../config/settings";
 import type { AssistantThinkingRenderer } from "../../extensibility/extensions/types";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
-import { isSilentAbort, resolveAbortLabel } from "../../session/messages";
+import { resolveAbortLabel, shouldRenderAbortReason } from "../../session/messages";
 import { resolveImageOptions } from "../../tools/render-utils";
 
 /**
@@ -74,18 +74,6 @@ export class AssistantMessageComponent extends Container {
 		return this.#transcriptBlockFinalized;
 	}
 
-	/**
-	 * Assistant text/thinking streams in append-only: earlier rendered rows never
-	 * re-layout, new content only grows the block at the bottom. The transcript
-	 * reports this so the renderer may commit scrolled-off head rows of a long
-	 * streamed reply to native scrollback instead of dropping them (see
-	 * `NativeScrollbackLiveRegion#getNativeScrollbackCommitSafeEnd`). Volatile
-	 * blocks (tool previews that collapse) intentionally do not implement this.
-	 */
-	isTranscriptBlockAppendOnly(): boolean {
-		return true;
-	}
-
 	markTranscriptBlockFinalized(): void {
 		this.#transcriptBlockFinalized = true;
 	}
@@ -252,7 +240,7 @@ export class AssistantMessageComponent extends Container {
 		// But only if there are no tool calls (tool execution components will show the error)
 		const hasToolCalls = message.content.some(c => c.type === "toolCall");
 		if (!hasToolCalls) {
-			if (message.stopReason === "aborted" && !isSilentAbort(message.errorMessage)) {
+			if (message.stopReason === "aborted" && shouldRenderAbortReason(message.errorMessage)) {
 				const abortMessage = resolveAbortLabel(message.errorMessage);
 				if (hasVisibleContent) {
 					this.#contentContainer.addChild(new Spacer(1));
@@ -268,7 +256,7 @@ export class AssistantMessageComponent extends Container {
 		}
 		if (
 			message.errorMessage &&
-			!isSilentAbort(message.errorMessage) &&
+			shouldRenderAbortReason(message.errorMessage) &&
 			message.stopReason !== "aborted" &&
 			message.stopReason !== "error"
 		) {

package/src/modes/components/late-diagnostics-message.ts

@@ -0,0 +1,60 @@
+import { Container, Text } from "@oh-my-pi/pi-tui";
+import { formatDiagnostics } from "../../tools/render-utils";
+import { getLanguageFromPath, theme } from "../theme/theme";
+
+/** One file's worth of late LSP diagnostics, as carried on the transcript message. */
+export interface LateDiagnosticsFile {
+	path?: string;
+	summary?: string;
+	errored?: boolean;
+	messages?: string[];
+}
+
+/**
+ * Renders late LSP diagnostics (arrived after edit/write returned) in the
+ * transcript, reusing the same tree renderer the edit/write tools use so the
+ * styling stays consistent. Supports the global tool-output expand toggle.
+ */
+export class LateDiagnosticsMessageComponent extends Container {
+	#expanded = false;
+
+	constructor(private readonly files: LateDiagnosticsFile[]) {
+		super();
+		this.#rebuild();
+	}
+
+	setExpanded(expanded: boolean): void {
+		if (this.#expanded === expanded) return;
+		this.#expanded = expanded;
+		this.#rebuild();
+	}
+
+	override invalidate(): void {
+		super.invalidate();
+		this.#rebuild();
+	}
+
+	#rebuild(): void {
+		this.clear();
+
+		const messages: string[] = [];
+		const summaries: string[] = [];
+		let errored = false;
+		for (const file of this.files) {
+			if (file.messages?.length) messages.push(...file.messages);
+			if (file.summary) summaries.push(file.summary);
+			if (file.errored) errored = true;
+		}
+		if (messages.length === 0) return;
+
+		const text = formatDiagnostics(
+			{ errored, summary: summaries.join(", "), messages },
+			this.#expanded,
+			theme,
+			fp => theme.getLangIcon(getLanguageFromPath(fp)),
+			{ title: "Late diagnostics" },
+		);
+		const body = text.replace(/^\n+/, "");
+		if (body) this.addChild(new Text(body, 1, 0));
+	}
+}

package/src/modes/components/plan-review-overlay.ts

@@ -141,6 +141,9 @@ export class PlanReviewOverlay implements Component {
 	#bodyClickRows = new Set<number>();
 	/** 1-based column at/under which a region-row click targets the sidebar. */
 	#sidebarClickMaxCol = 0;
+	/** Option index the pointer is currently hovering, or undefined. Updated from
+	 *  motion mouse reports and cleared when the pointer leaves the option rows. */
+	#hoveredOption: number | undefined;
 
 	#annotating = false;
 	#input: Input;
@@ -315,9 +318,10 @@ export class PlanReviewOverlay implements Component {
 	 * Hit-test an SGR mouse report (`\x1b[<b;x;yM/m`) against the click maps the
 	 * last render recorded. Returns true when consumed. The fullscreen overlay
 	 * paints from screen row 0, so a 1-based mouse row maps directly to the
-	 * rendered-line index. Wheel scrolls the body; a left click on an option
-	 * activates it (select + confirm), on a ToC row jumps to that section, and on
-	 * the body column focuses the body.
+	 * rendered-line index. Wheel scrolls the body; pointer motion lights up the
+	 * hovered option row; a left click on an option activates it (select +
+	 * confirm), on a ToC row jumps to that section, and on the body column focuses
+	 * the body.
 	 */
 	#handleMouse(data: string): boolean {
 		const match = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/.exec(data);
@@ -331,7 +335,13 @@ export class PlanReviewOverlay implements Component {
 			return true;
 		}
 		if (match[4] !== "M") return true; // release
-		if (button & 32) return true; // motion/drag
+		if (button & 32) {
+			// Motion (hover or drag): light up the option row under the pointer so a
+			// mouse user gets the same affordance the keyboard cursor gives. Any
+			// non-option row clears the highlight.
+			this.#setHoveredOption(this.#optionClickRows.get(row));
+			return true;
+		}
 		if ((button & 3) !== 0) return true; // not the left button
 		const optionIndex = this.#optionClickRows.get(row);
 		if (optionIndex !== undefined) {
@@ -355,6 +365,12 @@ export class PlanReviewOverlay implements Component {
 		return true;
 	}
 
+	/** Set the hovered option from a hit-tested row, ignoring disabled rows and
+	 *  non-option rows (both clear the highlight). */
+	#setHoveredOption(index: number | undefined): void {
+		this.#hoveredOption = index !== undefined && !this.#disabled.has(index) ? index : undefined;
+	}
+
 	#cycleRegion(direction: number): void {
 		// Sidebar is skipped from the cycle when it is not shown.
 		const regions: Focus[] = this.#sidebarShown ? ["toc", "body", "actions"] : ["body", "actions"];
@@ -611,14 +627,19 @@ export class PlanReviewOverlay implements Component {
 		return this.#options.map((label, i) => {
 			const selected = i === this.#selectedIndex;
 			const isDisabled = this.#disabled.has(i);
+			const hovered = !isDisabled && i === this.#hoveredOption;
 			// The cursor marks the selected option; it dims when actions are not the
 			// focused region so the active region's highlight stays unambiguous.
 			const cursor = selected ? theme.fg(active ? "accent" : "dim", `${theme.nav.cursor} `) : "  ";
-			const text = isDisabled
+			let text = isDisabled
 				? theme.fg("dim", label)
 				: selected && active
 					? theme.bold(theme.fg("accent", label))
 					: theme.fg("text", label);
+			// A pointer hovering an option paints a highlight band behind its label,
+			// distinct from the keyboard selection (cursor glyph + bold accent) which
+			// stays where it is. One space of padding gives the band a button shape.
+			if (hovered) text = theme.bg("selectedBg", ` ${text} `);
 			return cursor + text;
 		});
 	}