@oh-my-pi/pi-coding-agent 15.7.3 → 15.7.6

package/src/modes/components/hook-selector.ts

@@ -7,6 +7,7 @@ import {
 	extractPrintableText,
 	fuzzyFilter,
 	Markdown,
+	type MarkdownTheme,
 	matchesKey,
 	padding,
 	renderInlineMarkdown,
@@ -14,8 +15,8 @@ import {
 	Spacer,
 	Text,
 	type TUI,
-	truncateToWidth,
 	visibleWidth,
+	wrapTextWithAnsi,
 } from "@oh-my-pi/pi-tui";
 import { getMarkdownTheme, type ThemeColor, theme } from "../../modes/theme/theme";
 import {
@@ -69,6 +70,34 @@ export interface HookSelectorOptions {
 	slider?: HookSelectorSlider;
 }
 
+export interface HookSelectorOption {
+	label: string;
+	description?: string;
+}
+
+export type HookSelectorOptionInput = string | HookSelectorOption;
+
+function normalizeHookSelectorOption(option: HookSelectorOptionInput): HookSelectorOption {
+	if (typeof option === "string") return { label: option };
+	if (option.description?.trim()) {
+		return { label: option.label, description: option.description.trim() };
+	}
+	return { label: option.label };
+}
+
+function splitLeadingSpacesForWrap(line: string, width: number): { indent: string; body: string } {
+	let indentLength = 0;
+	while (indentLength < line.length && line.charCodeAt(indentLength) === 32) {
+		indentLength += 1;
+	}
+	const maxIndentLength = Math.max(0, width - 1);
+	const clampedIndentLength = Math.min(indentLength, maxIndentLength);
+	return {
+		indent: line.slice(0, clampedIndentLength),
+		body: line.slice(indentLength),
+	};
+}
+
 class OutlinedList extends Container {
 	#lines: string[] = [];
 
@@ -81,19 +110,26 @@ class OutlinedList extends Container {
 		const borderColor = (text: string) => theme.fg("border", text);
 		const horizontal = borderColor(theme.boxSharp.horizontal.repeat(Math.max(1, width)));
 		const innerWidth = Math.max(1, width - 2);
-		const content = this.#lines.map(line => {
+		const content: string[] = [];
+		for (const line of this.#lines) {
 			const normalized = replaceTabs(line);
-			const fitted = truncateToWidth(normalized, innerWidth);
-			const pad = Math.max(0, innerWidth - visibleWidth(fitted));
-			return `${borderColor(theme.boxSharp.vertical)}${fitted}${padding(pad)}${borderColor(theme.boxSharp.vertical)}`;
-		});
+			const { indent, body } = splitLeadingSpacesForWrap(normalized, innerWidth);
+			const wrapped = wrapTextWithAnsi(body, Math.max(1, innerWidth - visibleWidth(indent)));
+			for (const wrappedBody of wrapped.length > 0 ? wrapped : [""]) {
+				const wrappedLine = `${indent}${wrappedBody}`;
+				const pad = Math.max(0, innerWidth - visibleWidth(wrappedLine));
+				content.push(
+					`${borderColor(theme.boxSharp.vertical)}${wrappedLine}${padding(pad)}${borderColor(theme.boxSharp.vertical)}`,
+				);
+			}
+		}
 		return [horizontal, ...content, horizontal];
 	}
 }
 
 export class HookSelectorComponent extends Container {
-	#options: string[];
-	#filteredOptions: string[];
+	#options: HookSelectorOption[];
+	#filteredOptions: HookSelectorOption[];
 	#searchQuery = "";
 	#selectedIndex: number;
 	#maxVisible: number;
@@ -110,17 +146,18 @@ export class HookSelectorComponent extends Container {
 	#slider: HookSelectorSlider | undefined;
 	#sliderIndex: number = 0;
 	#sliderComponent: Text | undefined;
+	#lastRenderWidth: number | undefined;
 	constructor(
 		title: string,
-		options: string[],
+		options: HookSelectorOptionInput[],
 		onSelect: (option: string) => void,
 		onCancel: () => void,
 		opts?: HookSelectorOptions,
 	) {
 		super();
 
-		this.#options = options;
-		this.#filteredOptions = options;
+		this.#options = options.map(normalizeHookSelectorOption);
+		this.#filteredOptions = this.#options;
 		this.#selectedIndex = Math.min(opts?.initialIndex ?? 0, this.#filteredOptions.length - 1);
 		this.#maxVisible = Math.max(3, opts?.maxVisible ?? 12);
 		this.#onSelectCallback = onSelect;
@@ -156,7 +193,7 @@ export class HookSelectorComponent extends Container {
 					opts?.onTimeout?.();
 					const selected = this.#filteredOptions[this.#selectedIndex];
 					if (selected) {
-						this.#onSelectCallback(selected);
+						this.#onSelectCallback(selected.label);
 					} else {
 						this.#onCancelCallback();
 					}
@@ -180,32 +217,111 @@ export class HookSelectorComponent extends Container {
 		this.#updateList();
 	}
 
-	#updateList(): void {
+	#renderOptionLines(option: HookSelectorOption, isSelected: boolean, mdTheme: MarkdownTheme): string[] {
+		const label = isSelected
+			? renderInlineMarkdown(option.label, mdTheme, t => theme.fg("accent", t))
+			: renderInlineMarkdown(option.label, mdTheme, t => theme.fg("text", t));
+		const prefix = isSelected ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
+		const lines = [prefix + label];
+		if (option.description) {
+			const description = renderInlineMarkdown(option.description, mdTheme, t => theme.fg("muted", t));
+			lines.push(`    ${description}`);
+		}
+		return lines;
+	}
+
+	#renderedLineRowCount(line: string, renderWidth: number): number {
+		const normalized = replaceTabs(line);
+		if (this.#outlinedList) {
+			const innerWidth = Math.max(1, renderWidth - 2);
+			const { indent, body } = splitLeadingSpacesForWrap(normalized, innerWidth);
+			const wrapped = wrapTextWithAnsi(body, Math.max(1, innerWidth - visibleWidth(indent)));
+			return Math.max(1, wrapped.length);
+		}
+		const wrapped = wrapTextWithAnsi(normalized, Math.max(1, renderWidth - 2));
+		return Math.max(1, wrapped.length);
+	}
+
+	#optionRowCount(
+		option: HookSelectorOption,
+		renderWidth: number | undefined,
+		isSelected: boolean,
+		mdTheme: MarkdownTheme,
+	): number {
+		if (renderWidth === undefined) return option.description ? 2 : 1;
+		let rows = 0;
+		for (const line of this.#renderOptionLines(option, isSelected, mdTheme)) {
+			rows += this.#renderedLineRowCount(line, renderWidth);
+		}
+		return rows;
+	}
+
+	#totalOptionRows(options: HookSelectorOption[], renderWidth?: number, mdTheme?: MarkdownTheme): number {
+		const themeForRows = mdTheme ?? getMarkdownTheme();
+		let rows = 0;
+		for (const option of options) {
+			rows += this.#optionRowCount(option, renderWidth, false, themeForRows);
+		}
+		return rows;
+	}
+
+	#getVisibleOptionRange(
+		total: number,
+		renderWidth?: number,
+		mdTheme: MarkdownTheme = getMarkdownTheme(),
+	): { startIndex: number; endIndex: number } {
+		if (total === 0) return { startIndex: 0, endIndex: 0 };
+
+		const rowBudget = Math.max(1, this.#maxVisible);
+		const selectedIndex = Math.max(0, Math.min(this.#selectedIndex, total - 1));
+		let startIndex = selectedIndex;
+		let endIndex = selectedIndex + 1;
+		let rows = this.#optionRowCount(this.#filteredOptions[selectedIndex]!, renderWidth, true, mdTheme);
+		let beforeRows = 0;
+		const targetBeforeRows = Math.max(0, Math.floor((rowBudget - rows) / 2));
+
+		while (startIndex > 0) {
+			const cost = this.#optionRowCount(this.#filteredOptions[startIndex - 1]!, renderWidth, false, mdTheme);
+			if (beforeRows + cost > targetBeforeRows || rows + cost > rowBudget) break;
+			startIndex--;
+			beforeRows += cost;
+			rows += cost;
+		}
+
+		while (endIndex < total) {
+			const cost = this.#optionRowCount(this.#filteredOptions[endIndex]!, renderWidth, false, mdTheme);
+			if (rows + cost > rowBudget) break;
+			endIndex++;
+			rows += cost;
+		}
+
+		while (startIndex > 0) {
+			const cost = this.#optionRowCount(this.#filteredOptions[startIndex - 1]!, renderWidth, false, mdTheme);
+			if (rows + cost > rowBudget) break;
+			startIndex--;
+			rows += cost;
+		}
+
+		return { startIndex, endIndex };
+	}
+
+	#updateList(renderWidth = this.#lastRenderWidth): void {
 		const lines: string[] = [];
 		const total = this.#filteredOptions.length;
-		const startIndex = Math.max(
-			0,
-			Math.min(this.#selectedIndex - Math.floor(this.#maxVisible / 2), total - this.#maxVisible),
-		);
-		const endIndex = Math.min(startIndex + this.#maxVisible, total);
-
 		const mdTheme = getMarkdownTheme();
+		const { startIndex, endIndex } = this.#getVisibleOptionRange(total, renderWidth, mdTheme);
+
 		for (let i = startIndex; i < endIndex; i++) {
 			const option = this.#filteredOptions[i];
 			if (option === undefined) continue;
-			const isSelected = i === this.#selectedIndex;
-			const label = isSelected
-				? renderInlineMarkdown(option, mdTheme, t => theme.fg("accent", t))
-				: renderInlineMarkdown(option, mdTheme, t => theme.fg("text", t));
-			const prefix = isSelected ? theme.fg("accent", `${theme.nav.cursor} `) : "  ";
-			lines.push(prefix + label);
+			lines.push(...this.#renderOptionLines(option, i === this.#selectedIndex, mdTheme));
 		}
 
 		if (total === 0) {
 			lines.push(theme.fg("dim", "  No matching options"));
 		}
 
-		if (startIndex > 0 || endIndex < total || this.#shouldRenderSearchStatus()) {
+		if (startIndex > 0 || endIndex < total || this.#shouldRenderSearchStatus(renderWidth, mdTheme)) {
 			lines.push(this.#renderStatusLine(total));
 		}
 		if (this.#outlinedList) {
@@ -253,12 +369,12 @@ export class HookSelectorComponent extends Container {
 		slider.onChange?.(next);
 	}
 
-	#isSearchEnabled(): boolean {
-		return this.#options.length > this.#maxVisible;
+	#isSearchEnabled(renderWidth = this.#lastRenderWidth, mdTheme?: MarkdownTheme): boolean {
+		return this.#totalOptionRows(this.#options, renderWidth, mdTheme) > this.#maxVisible;
 	}
 
-	#shouldRenderSearchStatus(): boolean {
-		return this.#isSearchEnabled() || this.#searchQuery.length > 0;
+	#shouldRenderSearchStatus(renderWidth = this.#lastRenderWidth, mdTheme?: MarkdownTheme): boolean {
+		return this.#isSearchEnabled(renderWidth, mdTheme) || this.#searchQuery.length > 0;
 	}
 
 	#renderStatusLine(total: number): string {
@@ -273,7 +389,9 @@ export class HookSelectorComponent extends Container {
 
 	#setSearchQuery(query: string): void {
 		this.#searchQuery = query;
-		this.#filteredOptions = query.trim() ? fuzzyFilter(this.#options, query, option => option) : this.#options;
+		this.#filteredOptions = query.trim()
+			? fuzzyFilter(this.#options, query, option => `${option.label} ${option.description ?? ""}`)
+			: this.#options;
 		this.#selectedIndex = 0;
 		this.#updateList();
 	}
@@ -322,7 +440,7 @@ export class HookSelectorComponent extends Container {
 			}
 		} else if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			const selected = this.#filteredOptions[this.#selectedIndex];
-			if (selected) this.#onSelectCallback(selected);
+			if (selected) this.#onSelectCallback(selected.label);
 		} else if (matchesKey(keyData, "left") || (this.#slider && !this.#isSearchEnabled() && keyData === "h")) {
 			if (this.#slider) this.#moveSlider(-1);
 			else this.#onLeftCallback?.();
@@ -334,6 +452,15 @@ export class HookSelectorComponent extends Container {
 		}
 	}
 
+	override render(width: number): string[] {
+		const renderWidth = Math.max(1, width);
+		if (this.#lastRenderWidth !== renderWidth) {
+			this.#lastRenderWidth = renderWidth;
+			this.#updateList(renderWidth);
+		}
+		return super.render(renderWidth);
+	}
+
 	dispose(): void {
 		this.#countdown?.dispose();
 	}

package/src/modes/components/tool-execution.ts

@@ -141,6 +141,14 @@ export interface ToolExecutionHandle {
 	setExpanded(expanded: boolean): void;
 }
 
+/** Drive pending-tool redraws at ~60fps so the animated border sweep is smooth.
+ * The TUI already throttles at its 16ms `MIN_RENDER_INTERVAL_MS`, so this is the
+ * natural upper bound and static frames diff to a no-op redraw at ~zero cost. */
+const SPINNER_RENDER_INTERVAL_MS = 16;
+/** Advance the spinner glyph at its classic ~12.5fps step, decoupled from the
+ * 60fps render cadence (mirrors `Loader`). */
+const SPINNER_GLYPH_ADVANCE_MS = 80;
+
 /**
  * Component that renders a tool call with its result (updateable)
  */
@@ -177,6 +185,7 @@ export class ToolExecutionComponent extends Container {
 	// Spinner animation for partial task results
 	#spinnerFrame?: number;
 	#spinnerInterval?: NodeJS.Timeout;
+	#lastSpinnerAdvanceAt = 0;
 	// Todo write completion strikethrough reveal animation
 	#todoStrikeInterval?: NodeJS.Timeout;
 	// Track if args are still being streamed (for edit/write spinner)
@@ -404,13 +413,20 @@ export class ToolExecutionComponent extends Container {
 			this.#isPartial && shimmerEnabled() && (this.#toolName === "bash" || this.#toolName === "eval");
 		const needsSpinner = isStreamingArgs || isPartialTask || isPendingExecBlock;
 		if (needsSpinner && !this.#spinnerInterval) {
+			this.#lastSpinnerAdvanceAt = performance.now();
 			this.#spinnerInterval = setInterval(() => {
+				const now = performance.now();
 				const frameCount = theme.spinnerFrames.length;
-				if (frameCount === 0) return;
-				this.#spinnerFrame = ((this.#spinnerFrame ?? -1) + 1) % frameCount;
-				this.#renderState.spinnerFrame = this.#spinnerFrame;
+				// Redraw at ~60fps for a smooth border sweep, but only step the spinner
+				// glyph at its classic ~12.5fps cadence. The TUI throttles renders at
+				// 16ms and the differ drops no-op redraws, so the extra ticks are free.
+				if (frameCount > 0 && now - this.#lastSpinnerAdvanceAt >= SPINNER_GLYPH_ADVANCE_MS) {
+					this.#spinnerFrame = ((this.#spinnerFrame ?? -1) + 1) % frameCount;
+					this.#renderState.spinnerFrame = this.#spinnerFrame;
+					this.#lastSpinnerAdvanceAt = now;
+				}
 				this.#ui.requestRender();
-			}, 80);
+			}, SPINNER_RENDER_INTERVAL_MS);
 		} else if (!needsSpinner && this.#spinnerInterval) {
 			clearInterval(this.#spinnerInterval);
 			this.#spinnerInterval = undefined;

package/src/modes/controllers/command-controller.ts

@@ -1124,48 +1124,16 @@ export class CommandController {
 	}
 
 	/**
-	 * TUI handler for `/shake`. `elide`/`images` are instant structural drops;
-	 * `summary` runs the local on-device compressor behind a cancelable loader
-	 * (Esc aborts via `abortCompaction`). Rebuilds the chat and reports counts.
+	 * TUI handler for `/shake`. `elide` drops heavy structural content and
+	 * `images` strips image blocks. Rebuilds the chat and reports counts.
 	 */
 	async handleShakeCommand(mode: ShakeMode): Promise<void> {
 		let result: ShakeResult;
-		if (mode === "summary") {
-			if (this.ctx.loadingAnimation) {
-				this.ctx.loadingAnimation.stop();
-				this.ctx.loadingAnimation = undefined;
-			}
-			this.ctx.statusContainer.clear();
-			const originalOnEscape = this.ctx.editor.onEscape;
-			this.ctx.editor.onEscape = () => {
-				this.ctx.session.abortCompaction();
-			};
-			const loader = new Loader(
-				this.ctx.ui,
-				spinner => theme.fg("accent", spinner),
-				text => theme.fg("muted", text),
-				"Shaking context (summary)… (esc to cancel)",
-				getSymbolTheme().spinnerFrames,
-			);
-			this.ctx.statusContainer.addChild(loader);
-			this.ctx.ui.requestRender();
-			try {
-				result = await this.ctx.session.shake("summary");
-			} catch (error) {
-				this.ctx.showError(`Shake failed: ${error instanceof Error ? error.message : String(error)}`);
-				return;
-			} finally {
-				loader.stop();
-				this.ctx.statusContainer.clear();
-				this.ctx.editor.onEscape = originalOnEscape;
-			}
-		} else {
-			try {
-				result = await this.ctx.session.shake(mode);
-			} catch (error) {
-				this.ctx.showError(`Shake failed: ${error instanceof Error ? error.message : String(error)}`);
-				return;
-			}
+		try {
+			result = await this.ctx.session.shake(mode);
+		} catch (error) {
+			this.ctx.showError(`Shake failed: ${error instanceof Error ? error.message : String(error)}`);
+			return;
 		}
 
 		const dropped = result.toolResultsDropped + result.blocksDropped + (result.imagesDropped ?? 0);

package/src/modes/controllers/event-controller.ts

@@ -25,12 +25,14 @@ type AgentSessionEventKind = AgentSessionEvent["type"];
 
 const IRC_MESSAGE_VISIBLE_TTL_MS = 10_000;
 
-// Events that change which foreground tools are executing, or that reset a turn.
-// The eager native-scrollback rebuild mode is recomputed only on these — other
-// events (assistant text streaming, IRC, notices) leave it untouched so plain
-// streaming keeps the no-yank deferral.
-const TOOL_RENDER_MODE_EVENTS: Record<string, true> = {
+// Events that change foreground streaming state, or that reset a turn. The TUI
+// eager native-scrollback rebuild mode is recomputed only on these so unrelated
+// IRC/notices/status refreshes do not toggle scrollback replay policy.
+const STREAM_RENDER_MODE_EVENTS: Record<string, true> = {
 	agent_start: true,
+	agent_end: true,
+	message_start: true,
+	message_end: true,
 	tool_execution_start: true,
 	tool_execution_update: true,
 	tool_execution_end: true,
@@ -46,6 +48,7 @@ export class EventController {
 	#renderedCustomMessages = new Set<string>();
 	#lastIntent: string | undefined = undefined;
 	#backgroundToolCallIds = new Set<string>();
+	#assistantMessageStreaming = false;
 	#readToolCallArgs = new Map<string, Record<string, unknown>>();
 	#readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
 	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
@@ -169,24 +172,27 @@ export class EventController {
 
 		const run = this.#handlers[event.type] as (e: AgentSessionEvent) => Promise<void>;
 		await run(event);
-		// While a foreground tool is executing, its streaming result re-renders and can
-		// re-lay-out rows that already scrolled into native scrollback. Let the TUI
-		// rebuild history on those offscreen edits (a snap to the tail is acceptable
-		// mid-tool) instead of deferring, which would leave stale/duplicated rows.
-		// Background-running tools are excluded so their late async updates — and the
-		// assistant text that streams alongside them — keep the no-yank deferral;
-		// agent_start resets the mode at every turn boundary.
-		if (TOOL_RENDER_MODE_EVENTS[event.type]) {
+		// While assistant text or a foreground tool is streaming, rows above the
+		// viewport can re-layout after they have already entered native scrollback
+		// (Markdown fences, wrapping, previews). Let the TUI rebuild history on
+		// those offscreen edits instead of deferring, which otherwise leaves stale
+		// tail rows duplicated above the live viewport.
+		// Background-running tools are excluded so late async updates outside the
+		// active foreground stream keep the no-yank deferral; agent_start resets
+		// the mode at every turn boundary.
+		if (STREAM_RENDER_MODE_EVENTS[event.type]) {
 			this.#refreshToolRenderMode();
 		}
 	}
 
 	#refreshToolRenderMode(): void {
-		let foregroundToolActive = false;
-		for (const toolCallId of this.ctx.pendingTools.keys()) {
-			if (!this.#backgroundToolCallIds.has(toolCallId)) {
-				foregroundToolActive = true;
-				break;
+		let foregroundToolActive = this.#assistantMessageStreaming;
+		if (!foregroundToolActive) {
+			for (const toolCallId of this.ctx.pendingTools.keys()) {
+				if (!this.#backgroundToolCallIds.has(toolCallId)) {
+					foregroundToolActive = true;
+					break;
+				}
 			}
 		}
 		this.ctx.ui.setEagerNativeScrollbackRebuild(foregroundToolActive);
@@ -196,6 +202,7 @@ export class EventController {
 		this.#lastIntent = undefined;
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
+		this.#assistantMessageStreaming = false;
 		this.#lastAssistantComponent = undefined;
 		if (this.ctx.retryEscapeHandler) {
 			this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
@@ -268,9 +275,13 @@ export class EventController {
 			this.ctx.ui.requestRender();
 		} else if (event.message.role === "assistant") {
 			this.#lastThinkingCount = 0;
+			this.#assistantMessageStreaming = true;
 			this.#resetReadGroup();
-			this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock, () =>
-				this.ctx.ui.requestRender(),
+			this.ctx.streamingComponent = new AssistantMessageComponent(
+				undefined,
+				this.ctx.hideThinkingBlock,
+				() => this.ctx.ui.requestRender(),
+				this.ctx.session.extensionRunner?.getAssistantThinkingRenderers(),
 			);
 			this.ctx.streamingMessage = event.message;
 			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
@@ -414,6 +425,9 @@ export class EventController {
 
 	async #handleMessageEnd(event: Extract<AgentSessionEvent, { type: "message_end" }>): Promise<void> {
 		if (event.message.role === "user") return;
+		if (event.message.role === "assistant") {
+			this.#assistantMessageStreaming = false;
+		}
 		if (this.ctx.streamingComponent && event.message.role === "assistant") {
 			this.ctx.streamingMessage = event.message;
 			let errorMessage: string | undefined;
@@ -596,8 +610,8 @@ export class EventController {
 			}
 		}
 	}
-
 	async #handleAgentEnd(_event: Extract<AgentSessionEvent, { type: "agent_end" }>): Promise<void> {
+		this.#assistantMessageStreaming = false;
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
 			this.ctx.loadingAnimation = undefined;
@@ -647,9 +661,7 @@ export class EventController {
 				? "Auto-handoff"
 				: event.action === "shake"
 					? "Auto-shake"
-					: event.action === "shake-summary"
-						? "Auto-shake (summary)"
-						: "Auto context-full maintenance";
+					: "Auto context-full maintenance";
 		this.ctx.autoCompactionLoader = new Loader(
 			this.ctx.ui,
 			spinner => theme.fg("accent", spinner),
@@ -673,7 +685,7 @@ export class EventController {
 			this.ctx.statusContainer.clear();
 		}
 		const isHandoffAction = event.action === "handoff";
-		const isShakeAction = event.action === "shake" || event.action === "shake-summary";
+		const isShakeAction = event.action === "shake";
 		if (event.aborted) {
 			this.ctx.showStatus(
 				isHandoffAction
@@ -690,9 +702,7 @@ export class EventController {
 				this.ctx.rebuildChatFromMessages();
 				this.ctx.statusLine.invalidate();
 				this.ctx.updateEditorTopBorder();
-				this.ctx.showStatus(
-					event.action === "shake-summary" ? "Auto-shake (summary) completed" : "Auto-shake completed",
-				);
+				this.ctx.showStatus("Auto-shake completed");
 			}
 		} else if (event.result) {
 			this.ctx.rebuildChatFromMessages();

package/src/modes/controllers/extension-ui-controller.ts

@@ -10,6 +10,7 @@ import type {
 	ExtensionError,
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
+	ExtensionUISelectItem,
 	ExtensionUiComponent,
 	ExtensionWidgetContent,
 	ExtensionWidgetOptions,
@@ -483,7 +484,7 @@ export class ExtensionUiController {
 
 	createBackgroundUiContext(): ExtensionUIContext {
 		return {
-			select: async (_title: string, _options: string[], _dialogOptions) => undefined,
+			select: async (_title: string, _options: ExtensionUISelectItem[], _dialogOptions) => undefined,
 			confirm: async (_title: string, _message: string, _dialogOptions) => false,
 			input: async (_title: string, _placeholder?: string, _dialogOptions?: unknown) => undefined,
 			notify: () => {},
@@ -581,7 +582,7 @@ export class ExtensionUiController {
 	 */
 	showHookSelector(
 		title: string,
-		options: string[],
+		options: ExtensionUISelectItem[],
 		dialogOptions?: ExtensionUIDialogOptions,
 		extra?: { slider?: HookSelectorSlider },
 	): Promise<string | undefined> {

package/src/modes/controllers/input-controller.ts

@@ -86,21 +86,6 @@ export class InputController {
 
 	setupKeyHandlers(): void {
 		this.ctx.editor.setActionKeys("app.interrupt", this.ctx.keybindings.getKeys("app.interrupt"));
-		this.ctx.editor.shouldBypassAutocompleteOnEscape = () =>
-			Boolean(
-				this.ctx.loadingAnimation ||
-					this.ctx.hasActiveBtw() ||
-					this.ctx.hasActiveOmfg() ||
-					this.ctx.session.isStreaming ||
-					this.ctx.session.isCompacting ||
-					this.ctx.session.isGeneratingHandoff ||
-					this.ctx.session.isBashRunning ||
-					this.ctx.session.isEvalRunning ||
-					this.ctx.autoCompactionLoader ||
-					this.ctx.retryLoader ||
-					this.ctx.autoCompactionEscapeHandler ||
-					this.ctx.retryEscapeHandler,
-			);
 		this.ctx.editor.onEscape = () => {
 			if (this.ctx.loopModeEnabled) {
 				this.ctx.pauseLoop();

package/src/modes/controllers/mcp-command-controller.ts

@@ -1425,7 +1425,7 @@ export class MCPCommandController {
 		this.#showMessage(["", theme.fg("muted", `Reconnecting to "${name}"...`), ""].join("\n"));
 
 		try {
-			const connection = await this.ctx.mcpManager.reconnectServer(name);
+			const connection = await this.ctx.mcpManager.reconnectServer(name, { manual: true });
 			if (connection) {
 				// refreshMCPTools re-registers tools and preserves the user's prior
 				// MCP tool selection. No need to call activateDiscoveredMCPTools —

package/src/modes/interactive-mode.ts

@@ -40,6 +40,7 @@ import { isSettingsInitialized, Settings, settings } from "../config/settings";
 import type {
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
+	ExtensionUISelectItem,
 	ExtensionWidgetContent,
 	ExtensionWidgetOptions,
 } from "../extensibility/extensions";
@@ -2896,7 +2897,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	showHookSelector(
 		title: string,
-		options: string[],
+		options: ExtensionUISelectItem[],
 		dialogOptions?: ExtensionUIDialogOptions,
 		extra?: { slider?: HookSelectorSlider },
 	): Promise<string | undefined> {

package/src/modes/rpc/rpc-mode.ts

@@ -12,10 +12,12 @@
  */
 import { getOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import { $env, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
-import type {
-	ExtensionUIContext,
-	ExtensionUIDialogOptions,
-	ExtensionWidgetOptions,
+import {
+	type ExtensionUIContext,
+	type ExtensionUIDialogOptions,
+	type ExtensionUISelectItem,
+	type ExtensionWidgetOptions,
+	getExtensionUISelectOptionLabel,
 } from "../../extensibility/extensions";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
@@ -256,11 +258,20 @@ export async function runRpcMode(
 			return promise;
 		}
 
-		select(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined> {
+		select(
+			title: string,
+			options: ExtensionUISelectItem[],
+			dialogOptions?: ExtensionUIDialogOptions,
+		): Promise<string | undefined> {
 			return this.#createDialogPromise(
 				dialogOptions,
 				undefined,
-				{ method: "select", title, options, timeout: dialogOptions?.timeout },
+				{
+					method: "select",
+					title,
+					options: options.map(getExtensionUISelectOptionLabel),
+					timeout: dialogOptions?.timeout,
+				},
 				response => parseValueDialogResponse(response, dialogOptions),
 			);
 		}