@oh-my-pi/pi-tui 18.3.0 → 18.3.2

package/src/chat/read-tool-group.ts

@@ -3,14 +3,13 @@ import type { AssistantMessage, Usage } from "@oh-my-pi/pi-ai";
 import { type Component } from "../tui";
 import { Container } from "../tui";
 import { Text } from "../components/text";
-import { XD_URL_PREFIX } from "../tools/xd-url";
 import { getLanguageFromPath, theme } from "../theme";
 import { parseLineRanges, selectorLineRanges } from "../tools/line-ranges";
 import { type ReadRenderArgs, type ReadToolDetails, readSourceFsPath, splitPathAndSel } from "../tools/read";
 import { PREVIEW_LIMITS, shortenPath } from "../render/render-utils";
 import { fileHyperlink, renderCodeCell } from "../render";
 import { canonicalizeMessage } from "./thinking-display";
-import { internalReadTargetPredicate } from "./read-target";
+import { internalUrlSchemeSpec, splitUrlScheme } from "../tools/url-scheme-host";
 import type { ToolExecutionHandle } from "./tool-execution";
 import { formatUsageRow } from "../overlays/usage-row";
 
@@ -35,14 +34,16 @@ export function readArgsHaveTarget(args: unknown): boolean {
 /**
  * Whether a read collapses into the compact {@link ReadToolGroupComponent}
  * rather than a full tool execution. Filesystem/external targets always
- * collapse; other internal URLs (`skill://`, `agent://`, …) render full so
- * their resolved content is visible. `xd://` device reads are the exception —
- * they list devices/docs and read better in the compact grouped view.
+ * collapse; registered internal-URL schemes render full so their resolved
+ * content is visible, unless their spec declares `compactTranscript`
+ * (device listings/docs read better in the compact grouped view).
  */
 export function readArgsCollapseIntoGroup(args: unknown): boolean {
 	const target = readArgsTarget(args);
 	if (target === undefined) return false;
-	return target.startsWith(XD_URL_PREFIX) || !internalReadTargetPredicate?.(target);
+	const url = splitUrlScheme(target);
+	const spec = url && internalUrlSchemeSpec(url.scheme);
+	return spec === undefined || spec.compactTranscript === true;
 }
 
 /**
@@ -137,8 +138,6 @@ const READ_STATUS_RANK: Record<ReadEntry["status"], number> = {
 	error: 3,
 };
 
-const URL_LIKE_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
-
 function getDisplayReadTargets(details: ReadToolDetails | undefined): ReadDisplayPathSpec[] | undefined {
 	if (!Array.isArray(details?.displayReadTargets)) return undefined;
 	const links = Array.isArray(details.displayReadTargetLinks) ? details.displayReadTargetLinks : undefined;
@@ -237,7 +236,7 @@ function commaContinuesLineRangeSelector(input: string, partStart: number, comma
 
 function splitReadDisplayPathSpecs(rawPath: string): string[] {
 	const normalized = rawPath.trim();
-	if (!normalized || URL_LIKE_RE.test(normalized)) return [rawPath];
+	if (!normalized || splitUrlScheme(normalized)) return [rawPath];
 
 	const parts: string[] = [];
 	let braceDepth = 0;

package/src/chat/tool-execution.ts

@@ -1297,12 +1297,14 @@ export class ToolExecutionComponent extends Container {
 			}
 			context.renderDiff = renderDiff;
 		} else if (this.#toolName === "write") {
-			// Device-dispatch previews resolve renderers from the canonical tool map.
+			// Device-dispatch previews render through the host's canonical resolver,
+			// which covers mounted devices and active top-level tools (the `write`
+			// transport accepts both). Deciding the predicate here instead would
+			// leave a `write xd://<top-level tool>` card on the generic fallback.
 			const writeTool = this.#tool as { session?: { xdev?: XdevMountedState } } | undefined;
-			const xdev = writeTool?.session?.xdev;
-			if (xdev) {
-				context.resolveXdevMounted = (name: string) =>
-					xdev.mountedNames.has(name) ? xdev.tools.get(name) : undefined;
+			const resolveXdevMounted = writeTool?.session?.xdev?.resolve;
+			if (resolveXdevMounted) {
+				context.resolveXdevMounted = resolveXdevMounted;
 			}
 		}
 

package/src/chat/user-message.ts

@@ -48,6 +48,8 @@ export interface UserBubbleOptions {
 	imageLinks?: readonly (string | undefined)[];
 	/** Agent-attributed input: dim, flat prose. */
 	synthetic?: boolean;
+	/** Delivered into the response that was streaming; marked `*` at the bubble's top-left. */
+	liveSteered?: boolean;
 	/** SKILL.md path for a skill chip by name; `undefined` leaves the chip unlinked. */
 	skillPath?: (name: string) => string | undefined;
 }
@@ -102,7 +104,8 @@ export function userBubbleColor(
 
 /**
  * Component that renders a user message. Accepts an agent reaction badge
- * (see {@link ReactionTarget}) drawn right-aligned in the bubble's top padding row.
+ * (see {@link ReactionTarget}) drawn right-aligned in the bubble's top padding row;
+ * a live-steered message carries a `*` marker left-aligned in the same row.
  */
 export class UserMessageComponent extends Container implements ReactionTarget {
 	// Memoized OSC 133 zone wrapping keyed on the underlying container render
@@ -112,6 +115,7 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 	#zoneSource: readonly string[] | undefined;
 	#zoneLines: string[] | undefined;
 	readonly #bgColor: (value: string) => string;
+	readonly #liveSteered: boolean;
 	#reaction: string | undefined;
 
 	constructor(text: string, options: UserBubbleOptions = {}) {
@@ -130,6 +134,7 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 		});
 		const bgColor = (value: string) => theme.bg("userMessageBg", value);
 		this.#bgColor = bgColor;
+		this.#liveSteered = options.liveSteered === true;
 		const md = new Markdown(text, 1, 1, getMarkdownTheme(), {
 			bgColor,
 			color: userBubbleColor(options, composerTokenRegex(mentionLabels)),
@@ -144,10 +149,15 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 		this.#zoneLines = undefined;
 	}
 
-	/** The top padding row with the reaction badge right-aligned inside the horizontal padding. */
-	#reactionRow(width: number): string {
-		const emoji = this.#reaction!;
-		return applyBackgroundToLine(padding(width - 1 - visibleWidth(emoji)) + emoji, width, this.#bgColor);
+	/**
+	 * The top padding row: the live-steering marker left-aligned and the reaction
+	 * badge right-aligned, both inside the horizontal padding.
+	 */
+	#badgeRow(width: number): string {
+		const marker = this.#liveSteered ? theme.fg("accent", "*") : "";
+		const emoji = this.#reaction ?? "";
+		const gap = Math.max(0, width - 2 - visibleWidth(marker) - visibleWidth(emoji));
+		return applyBackgroundToLine(` ${marker}${padding(gap)}${emoji}`, width, this.#bgColor);
 	}
 
 	override render(width: number): readonly string[] {
@@ -159,7 +169,7 @@ export class UserMessageComponent extends Container implements ReactionTarget {
 			return this.#zoneLines;
 		}
 		const wrapped = lines.slice();
-		if (this.#reaction !== undefined) wrapped[0] = this.#reactionRow(width);
+		if (this.#reaction !== undefined || this.#liveSteered) wrapped[0] = this.#badgeRow(width);
 		wrapped[0] = OSC133_ZONE_START + wrapped[0];
 		wrapped[wrapped.length - 1] = wrapped[wrapped.length - 1] + OSC133_ZONE_CLOSE;
 		this.#zoneSource = lines;

package/src/components/editor.ts

@@ -528,8 +528,6 @@ export class Editor implements Component, Focusable {
 
 	/** When set, replaces the normal cursor glyph at end-of-text with this ANSI-styled string. */
 	cursorOverride: string | undefined;
-	/** Display width of the cursorOverride glyph (needed because override may contain ANSI escapes). */
-	cursorOverrideWidth: number | undefined;
 	/** Optional hook that decorates displayed user text after source-text layout.
 	 *  Width-changing output is allowed on lines without the cursor; it is truncated
 	 *  to the content width rather than reflowed. Cursor glyphs and inline hints are excluded. */
@@ -1304,7 +1302,7 @@ export class Editor implements Component, Focusable {
 				if (hasCursor && !this.#useTerminalCursor) {
 					const zeroWidthCursorBudget = visibleWidth(gutterText);
 					const zeroWidthCursorReplacement = this.cursorOverride
-						? { text: this.cursorOverride, width: this.cursorOverrideWidth ?? 1 }
+						? { text: this.cursorOverride, width: visibleWidth(this.cursorOverride) }
 						: this.#getStyledInputCursor();
 					if (showPromptGutter && zeroWidthCursorBudget > 0) {
 						// Keep the leading prompt glyph visible when the gutter consumes the whole row.
@@ -1405,7 +1403,7 @@ export class Editor implements Component, Focusable {
 					// displayWidth stays the same - we're replacing, not adding
 				} else if (this.cursorOverride) {
 					// Cursor override replaces the normal end-of-text cursor glyph
-					const overrideWidth = this.cursorOverrideWidth ?? 1;
+					const overrideWidth = visibleWidth(this.cursorOverride);
 					if (!isSideBordered && displayWidth + overrideWidth > lineContentWidth) {
 						// Borderless editors have no spare padding cell for an end-of-line cursor glyph.
 						// Preserve cursorOverride by replacing the tail of the line with it.

package/src/components/input.ts

@@ -1,7 +1,8 @@
 import { BracketedPasteHandler, decodeReencodedPasteControls } from "../bracketed-paste";
 import { getKeybindings } from "../keybindings";
-import { extractPrintableText } from "../keys";
+import { extractPrintableText, matchesKey } from "../keys";
 import { KillRing } from "../kill-ring";
+import { SpaceHoldGesture } from "../space-hold";
 import { type Component, CURSOR_MARKER, type Focusable } from "../tui";
 import { cursorColumnWindow } from "./scroll-viewport";
 import {
@@ -17,6 +18,30 @@ import {
 
 const segmenter = getSegmenter();
 
+/**
+ * Clean text entering the single-line value from outside the keyboard (pastes, dictation) —
+ * decode tmux's re-encoded control bytes (both extended-keys formats, e.g. Ctrl+J → "\n") back to
+ * literal bytes so the escape tail does not leak in, remove newlines/carriage returns, expand tabs,
+ * NFC-normalize, then strip any remaining control bytes. The decoder can synthesize Ctrl+A..Ctrl+Z
+ * (0x01..0x1A) from a paste, and a single-line value must hold none of them — newlines are already
+ * gone and tabs are already spaces by the time the C0/DEL strip runs.
+ *
+ * NFC normalization rationale: macOS Finder drag-drops file paths in NFD
+ * (Conjoining Jamo, U+1100..U+11FF). `Bun.stringWidth` counts each
+ * conjoining jamo as a separate cell — a Korean syllable like `화` is
+ * 1 char and 2 cells in NFC, but 2 chars and 3 cells in NFD (ᄒ=2 cells
+ * + ᅪ=1 cell). The terminal renders the NFD sequence as a single
+ * combined syllable (2 cells visible), so the width mismatch shows up
+ * as cursor drift past the visible filename — N×~1.5 cells for a path
+ * with N Korean syllables. NFC normalization at insert time stores the
+ * value in the same form everything else in the codebase assumes.
+ */
+function toSingleLine(text: string): string {
+	return replaceTabs(decodeReencodedPasteControls(text).replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, ""))
+		.normalize("NFC")
+		.replace(/[\x00-\x1F\x7F]/g, "");
+}
+
 interface InputState {
 	value: string;
 	cursor: number;
@@ -35,6 +60,10 @@ export class Input implements Component, Focusable {
 	mask = false;
 	onSubmit?: (value: string) => void;
 	onEscape?: () => void;
+	/** Space-bar push-to-talk; set its `handler` to enable it. */
+	readonly spaceHold = new SpaceHoldGesture(count => this.deleteBeforeCursor(count));
+	/** When set, replaces the cursor glyph at end-of-text with this ANSI-styled string. */
+	cursorOverride: string | undefined;
 
 	/** Focusable interface - set by TUI when focus changes */
 	focused: boolean = false;
@@ -49,6 +78,9 @@ export class Input implements Component, Focusable {
 	// Undo support
 	#undoStack: InputState[] = [];
 
+	/** Code units of the current volatile speech-to-text preview (see {@link setVolatileText}). */
+	#volatileTextLen = 0;
+
 	getValue(): string {
 		return this.#value;
 	}
@@ -93,6 +125,15 @@ export class Input implements Component, Focusable {
 			return;
 		}
 
+		// Space-hold push-to-talk: a sustained space bar starts/stops STT instead of typing spaces.
+		switch (this.spaceHold.process(matchesKey(data, "space"))) {
+			case "type":
+				this.#insertCharacter(" ");
+				return;
+			case "swallow":
+				return;
+		}
+
 		const kb = getKeybindings();
 
 		// Escape/Cancel
@@ -212,6 +253,52 @@ export class Input implements Component, Focusable {
 		this.#handlePaste(text);
 	}
 
+	/** Programmatically trigger submission (e.g. for voice submit). */
+	submit(): void {
+		this.onSubmit?.(this.#value);
+	}
+
+	/** Delete up to `count` characters immediately before the cursor. */
+	deleteBeforeCursor(count: number): void {
+		const removable = Math.min(count, this.#cursor);
+		if (removable <= 0) return;
+		this.#lastAction = null;
+		this.#pushUndo();
+		this.#replaceBeforeCursor(removable, "");
+	}
+
+	/** Show or replace a volatile speech-to-text preview at the cursor, outside undo history.
+	 *  Finalize it with {@link commitVolatileText} or drop it with {@link clearVolatileText}. */
+	setVolatileText(text: string): void {
+		const clean = toSingleLine(text);
+		this.#replaceBeforeCursor(this.#volatileTextLen, clean);
+		this.#volatileTextLen = clean.length;
+	}
+
+	/** Remove the current volatile preview without committing it. */
+	clearVolatileText(): void {
+		this.setVolatileText("");
+	}
+
+	/** Drop any volatile preview, then insert `text` as a single undoable edit. */
+	commitVolatileText(text: string): void {
+		this.clearVolatileText();
+		const clean = toSingleLine(text);
+		if (!clean) return;
+		this.#lastAction = null;
+		this.#pushUndo();
+		this.#replaceBeforeCursor(0, clean);
+	}
+
+	/** Replace up to `count` code units before the cursor with `text`, leaving the cursor after it. The
+	 *  range stops at the start of the value: a volatile preview's length can outrun the cursor once
+	 *  the caret moves while dictation is still streaming. */
+	#replaceBeforeCursor(count: number, text: string): void {
+		const start = Math.max(0, this.#cursor - count);
+		this.#value = this.#value.slice(0, start) + text + this.#value.slice(this.#cursor);
+		this.#cursor = start + text.length;
+	}
+
 	#insertCharacter(text: string): void {
 		const isWordChunk = [...segmenter.segment(text)].every(seg => getWordNavKind(seg.segment) !== "whitespace");
 		// Undo coalescing: consecutive word typing coalesces into one undo unit.
@@ -390,32 +477,7 @@ export class Input implements Component, Focusable {
 	#handlePaste(pastedText: string): void {
 		this.#lastAction = null;
 		this.#pushUndo();
-
-		// Clean the pasted text — decode tmux's re-encoded control bytes (both
-		// extended-keys formats, e.g. Ctrl+J → "\n") back to literal bytes so the escape
-		// tail does not leak in, remove newlines/carriage returns, expand tabs, NFC-normalize,
-		// then strip any remaining control bytes. The decoder can synthesize Ctrl+A..Ctrl+Z
-		// (0x01..0x1A) from a paste, and a single-line value must hold none of them — newlines
-		// are already gone and tabs are already spaces by the time the C0/DEL strip runs.
-		//
-		// NFC normalization rationale: macOS Finder drag-drops file paths in NFD
-		// (Conjoining Jamo, U+1100..U+11FF). `Bun.stringWidth` counts each
-		// conjoining jamo as a separate cell — a Korean syllable like `화` is
-		// 1 char and 2 cells in NFC, but 2 chars and 3 cells in NFD (ᄒ=2 cells
-		// + ᅪ=1 cell). The terminal renders the NFD sequence as a single
-		// combined syllable (2 cells visible), so the width mismatch shows up
-		// as cursor drift past the visible filename — N×~1.5 cells for a path
-		// with N Korean syllables. NFC normalization at paste time stores the
-		// value in the same form everything else in the codebase assumes.
-		const cleanText = replaceTabs(
-			decodeReencodedPasteControls(pastedText).replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, ""),
-		)
-			.normalize("NFC")
-			.replace(/[\x00-\x1F\x7F]/g, "");
-
-		// Insert at cursor position
-		this.#value = this.#value.slice(0, this.#cursor) + cleanText + this.#value.slice(this.#cursor);
-		this.#cursor += cleanText.length;
+		this.#replaceBeforeCursor(0, toSingleLine(pastedText));
 	}
 
 	invalidate(): void {
@@ -440,7 +502,13 @@ export class Input implements Component, Focusable {
 			visibleValue = "•".repeat(graphemes.length);
 			cursorIndex = graphemes.filter(grapheme => grapheme.index < this.#cursor).length;
 		}
-		const displayValue = this.#cursor >= this.#value.length ? `${visibleValue} ` : visibleValue;
+		// At end of text the cursor sits on trailing padding, sized to fit a (possibly wide) cursor override.
+		const atEnd = this.#cursor >= this.#value.length;
+		const override =
+			atEnd && this.cursorOverride !== undefined
+				? { text: this.cursorOverride, width: visibleWidth(this.cursorOverride) }
+				: undefined;
+		const displayValue = atEnd ? visibleValue + " ".repeat(override?.width ?? 1) : visibleValue;
 
 		const window = cursorColumnWindow(displayValue, cursorIndex, availableWidth);
 		const visibleText = window.text;
@@ -456,11 +524,10 @@ export class Input implements Component, Focusable {
 
 		// Hardware cursor marker (zero-width, emitted before the cursor cell for IME positioning)
 		const marker = this.focused ? CURSOR_MARKER : "";
-		const cursorChar = this.#useTerminalCursor ? atCursor : `\x1b[7m${atCursor || " "}\x1b[27m`;
+		const { text: cursorChar, width: cursorWidth } = override ?? this.#cursorCell(atCursor);
 
 		// Clamp only the trailing text (measured in terminal cells), keeping the cursor marker intact.
 		const beforeWidth = visibleWidth(beforeCursor);
-		const cursorWidth = this.#useTerminalCursor ? visibleWidth(atCursor) : visibleWidth(atCursor || " ");
 		const remainingAfterWidth = Math.max(0, availableWidth - beforeWidth - cursorWidth);
 		const clampedAfterCursor = sliceWithWidth(afterCursor, 0, remainingAfterWidth, true).text;
 		const renderedNoMarker = beforeCursor + cursorChar + clampedAfterCursor;
@@ -471,4 +538,10 @@ export class Input implements Component, Focusable {
 		const line = prompt + textWithCursor + pad;
 		return [line];
 	}
+
+	/** The rendered cursor cell: the grapheme under the cursor, inverted unless the terminal draws its own cursor. */
+	#cursorCell(atCursor: string): { text: string; width: number } {
+		if (this.#useTerminalCursor) return { text: atCursor, width: visibleWidth(atCursor) };
+		return { text: `\x1b[7m${atCursor || " "}\x1b[27m`, width: visibleWidth(atCursor || " ") };
+	}
 }

package/src/components/markdown.ts

@@ -2882,6 +2882,14 @@ export class Markdown implements Component {
 		};
 	}
 
+	#quoteStyle(text: string): string {
+		return this.#theme.quote(this.#theme.italic(text));
+	}
+
+	#getQuoteStylePrefix(): string {
+		return this.#getStylePrefix(text => this.#quoteStyle(text));
+	}
+
 	#renderToken(
 		token: Token,
 		width: number,
@@ -3004,7 +3012,7 @@ export class Markdown implements Component {
 			case "blockquote": {
 				const quoteInlineStyleContext: InlineStyleContext = {
 					applyText: (text: string) => text,
-					stylePrefix: "",
+					stylePrefix: this.#getQuoteStylePrefix(),
 				};
 				const quoteContentWidth = Math.max(1, width - 2);
 				const quoteTokens = token.tokens || [];
@@ -3074,14 +3082,13 @@ export class Markdown implements Component {
 	 * `width` is the full content width; the border reserves two cells.
 	 */
 	#applyQuoteBorder(renderedLines: RenderedLine[], width: number): RenderedLine[] {
-		const quoteStyle = (text: string) => this.#theme.quote(this.#theme.italic(text));
-		const quoteStylePrefix = this.#getStylePrefix(quoteStyle);
+		const quoteStylePrefix = this.#getQuoteStylePrefix();
 		const applyQuoteStyle = (line: string): string => {
 			if (!quoteStylePrefix) {
-				return quoteStyle(line);
+				return this.#quoteStyle(line);
 			}
 			const lineWithReappliedStyle = line.replace(/\x1b\[0m/g, `\x1b[0m${quoteStylePrefix}`);
-			return quoteStyle(lineWithReappliedStyle);
+			return this.#quoteStyle(lineWithReappliedStyle);
 		};
 		const quoteContentWidth = Math.max(1, width - 2);
 		const lines: RenderedLine[] = [];
@@ -3140,7 +3147,12 @@ export class Markdown implements Component {
 
 	/** Render the inner content of an HTML `<blockquote>` with quote styling. */
 	#renderHtmlBlockquote(inner: string, width: number): RenderedLine[] {
-		const cleaned = normalizeHtmlForTerminal(inner, createHtmlNormalizationState(), text => this.#theme.code(text));
+		const quoteStylePrefix = this.#getQuoteStylePrefix();
+		const cleaned = normalizeHtmlForTerminal(
+			inner,
+			createHtmlNormalizationState(),
+			text => this.#theme.code(text) + quoteStylePrefix,
+		);
 		const innerLines = splitTerminalLines(cleaned).map(line => renderedLine(line.trimEnd()));
 		while (innerLines.length > 0 && innerLines[innerLines.length - 1].text === "") innerLines.pop();
 		return this.#applyQuoteBorder(innerLines, width);

package/src/overlays/annotation-overlay.ts

@@ -251,7 +251,6 @@ export class AnnotationOverlay implements Component {
 		// Keep the editor's CURSOR_MARKER for terminal cursor placement, but
 		// replace its visible end-of-input caret with a stable blank cell.
 		this.#editor.cursorOverride = " ";
-		this.#editor.cursorOverrideWidth = 1;
 		this.#editor.setScrollbarVisible(true);
 		this.#editor.onSubmit = value => this.#commitAnnotation(value);
 		this.#externalEditorLabel = keybindings.getDisplayString("app.editor.external");

package/src/overlays/btw-history-panel.ts

@@ -25,6 +25,7 @@ import {
 	matchesSelectPageUp,
 	matchesSelectUp,
 } from "../keybinding-matchers";
+import type { SpaceHoldHandler } from "../space-hold";
 import { sanitizeErrorLine } from "../chrome/error-block";
 import { sanitizeDisplayLine, sanitizeDisplayText } from "./extensions/display-text";
 import { editorKey, rawKeyHint } from "../chrome/keybinding-hints";
@@ -40,6 +41,8 @@ interface BtwHistoryPanelOptions {
 	onCancel: (record: BtwHistoryRecord) => void;
 	canFollowUp?: (record: BtwHistoryRecord) => boolean;
 	onFollowUp?: (record: BtwHistoryRecord, question: string, signal: AbortSignal) => Promise<boolean>;
+	/** Space-bar push-to-talk for a follow-up composer: dictates into `input` while Space is held. */
+	spaceHold?: (input: Input) => SpaceHoldHandler;
 	requestRender: () => void;
 	getHeight: () => number;
 }
@@ -226,6 +229,7 @@ export class BtwHistoryPanel implements Component, Focusable {
 	#openComposer(record: BtwHistoryRecord): void {
 		const input = new Input();
 		input.prompt = theme.fg("accent", "Follow up: ");
+		input.spaceHold.handler = this.#options.spaceHold?.(input);
 		const composer: FollowUpComposer = { recordId: record.id, input, abortController: new AbortController() };
 		input.onEscape = () => {
 			composer.abortController.abort();

package/src/overlays/model-hub.ts

@@ -1630,6 +1630,13 @@ export class ModelHubComponent implements Component {
 			return;
 		}
 
+		// Enter on the sidebar is a pane switch, like →: it lands on the model
+		// rows instead of acting on a row the user cannot see is selected.
+		if (this.#focus === "scope" && (matchesKey(data, "enter") || matchesKey(data, "return") || data === "\n")) {
+			this.#focus = "list";
+			return;
+		}
+
 		const beforeQuery = this.#browser.query;
 		const isPrintable = extractPrintableText(data) !== undefined;
 		this.#browser.handleInput(data);
@@ -2274,19 +2281,22 @@ export class ModelHubComponent implements Component {
 			return "←/→ thinking level · Enter apply · Esc keep";
 		}
 		if (this.#assigning !== null) {
+			if (this.#focus === "scope") {
+				return "Enter/→ models · ↑/↓ providers · type to search · Alt+←/→ kind · Esc cancel";
+			}
 			switch (this.#assigning.kind) {
 				case "fallback":
-					return "Enter pick fallback · ↑/↓ providers · type to search · Alt+←/→ kind · Esc cancel";
+					return "Enter pick fallback · ↑/↓ models · ← providers · type to search · Alt+←/→ kind · Esc cancel";
 				case "fallbackKey":
-					return "Enter pick the protected model · ↑/↓ providers · type to search · Alt+←/→ kind · Esc cancel";
+					return "Enter pick the protected model · ↑/↓ models · ← providers · type to search · Alt+←/→ kind · Esc cancel";
 				default:
-					return "Enter assign · ↑/↓ providers · type to search · Alt+←/→ kind · Esc cancel";
+					return "Enter assign · ↑/↓ models · ← providers · type to search · Alt+←/→ kind · Esc cancel";
 			}
 		}
 		const entry = this.#activeEntry();
 		if (entry.kind === "roles") {
 			if (this.#focus !== "list") {
-				return "↑/↓ providers · → roles · Alt+←/→ tabs · Esc close";
+				return "↑/↓ providers · Enter/→ roles · Alt+←/→ tabs · Esc close";
 			}
 			const row = this.#rolesRows[this.#roleIndex];
 			if (row?.kind === "fallback") {
@@ -2308,9 +2318,11 @@ export class ModelHubComponent implements Component {
 		if (entry.kind === "provider" && entry.locked) {
 			return entry.oauth ? "Enter log in · ↑/↓ providers · Esc close" : "↑/↓ providers · Esc close";
 		}
-		const arrows = this.#focus === "scope" ? "↑/↓ providers · → models" : "↑/↓ models · ← providers";
 		const refresh = entry.kind === "provider" ? " · F5 refresh" : "";
-		return `Enter assign roles · ${arrows} · type to search · Alt+←/→ kind${refresh} · Esc close`;
+		if (this.#focus === "scope") {
+			return `Enter/→ models · ↑/↓ providers · type to search · Alt+←/→ kind${refresh} · Esc close`;
+		}
+		return `Enter assign roles · ↑/↓ models · ← providers · type to search · Alt+←/→ kind${refresh} · Esc close`;
 	}
 
 	#renderFooter(width: number): string {