@oh-my-pi/pi-tui 18.5.1 → 18.6.1

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [18.6.1] - 2026-10-04
+
+### Fixed
+
+- Fixed the Space key in the Git diff pane so it stages or unstages the focused hunk instead of scrolling or acting on the wrong change.
+- Fixed the BTW history sheet in Tern: the history list no longer collapses beside a long answer, the panes lose their foldable `##` headings, and the arrow/page keys scroll the answer ([#14331](https://github.com/can1357/oh-my-pi/pull/14331) by [@H4vC](https://github.com/H4vC))
+- Fixed a single saved side question in the BTW history panel opening on its one-row list: its answer now has focus, and Enter or `f` to follow up jumps to the bottom of the conversation ([#14331](https://github.com/can1357/oh-my-pi/pull/14331) by [@H4vC](https://github.com/H4vC))
+
+## [18.6.0] - 2026-10-03
+
+### Fixed
+
+- Fixed Alt+Up (restore queued steering), arrows and other escape-sequence keys on Windows acting as Esc (interrupting the turn) and typing `[1;3A` into the editor when the console host relays them one byte at a time ([#14216](https://github.com/can1357/oh-my-pi/pull/14216) by [@H4vC](https://github.com/H4vC)).
+
 ## [18.5.1] - 2026-10-03
 
 ### Added

package/dist/types/apps/git/git-tui.d.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`

package/dist/types/components/editor.d.ts

@@ -138,6 +138,9 @@ export declare class Editor implements Component, Focusable {
     onLargePaste?: (text: string, lineCount: number, options: PasteOptions) => boolean;
     onAutocompleteCancel?: () => void;
     disableSubmit: boolean;
+    /** Base editors accept native edits, not atomic sends. Implementations that
+     *  handle `send` override this readiness check for their submission path. */
+    protected get nativeSendable(): boolean;
     /** Placeholder painted right-aligned on the cursor row while the editor is empty and no
      *  autocomplete is open; hidden when it can't keep {@link PLACEHOLDER_MIN_GAP} cells from the
      *  cursor. The host styles it (ANSI allowed). Re-evaluated on every render, so hosts can derive

package/dist/types/native/apply.d.ts

@@ -1,8 +1,9 @@
 /**
  * Reference document applier: applies TSP frames to a node tree the way the
- * spec says the terminal does (§5.1). Ops are validated and applied one by
- * one; a rejected op is reported and skipped without affecting the rest of
- * the frame. `settle` is recorded as a hint and never restricts later ops.
+ * spec says the terminal does (Tern SDK, `protocol/documents.md`, frame ops).
+ * Ops are validated and applied one by one; a rejected op is reported and
+ * skipped without affecting the rest of the frame. `settle` is recorded as a
+ * hint and never restricts later ops.
  *
  * Used by tests, the debug server's `doc` op, and the TSP test harness.
  */

package/dist/types/native/encode.d.ts

@@ -26,9 +26,10 @@ export declare function encodeTspMessage(verb: TspVerb, body: string, params?: T
 export declare function encodeTspJson(verb: TspVerb, value: unknown, params?: TspParams, limit?: number): string;
 /**
  * The `hello` query; callers follow it with a DA1 sentinel. `features: ["edit"]`
- * tells the terminal that omp applies its `edit` events (TSP §8.5), so it may keep a
- * native selection in omp's editors; without it, every key stays omp's. `"undo"`
- * says omp applies `undo` events, so the terminal may turn ⌃Z in a field into one.
+ * tells the terminal that omp applies its `edit` events (Tern SDK,
+ * `protocol/input.md`), so it may keep a native selection in omp's editors;
+ * without it, every key stays omp's. `"undo"` says omp applies `undo` events,
+ * so the terminal may turn ⌃Z in a field into one.
  * `"send"` accepts an explicit prompt for a live composer without simulating keys.
  */
 export declare function encodeTspHelloQuery(version?: string): string;

package/dist/types/native/node.d.ts

@@ -11,7 +11,8 @@
  * `rows` fallback node rendered through `render(cx.cols)`.
  *
  * See `packages/wire/src/tsp.ts` for the wire vocabulary and
- * `crates/tern/SURFACE_PROTOCOL.md` (Stencil repository) for the spec.
+ * the Tern SDK's Surface Protocol reference (`docs/sdk/src/protocol` in the
+ * Stencil repository, https://docs.stencil.so/tern/protocol/) for the spec.
  */
 import type { TspEvent, TspKind, TspProps, TspScrollBy, TspSpan } from "@oh-my-pi/pi-wire";
 import type { Component } from "../tui.js";

package/dist/types/native/settle.d.ts

@@ -1,8 +1,9 @@
 /**
  * Settling: the frame provider marks finalized transcript blocks so the
- * native reconciler stops keeping their description (spec §12 "Settling and
- * program memory"). A settled block stays editable: a later change is sent as
- * targeted ops by id, followed by a fresh `settle` hint.
+ * native reconciler stops keeping their description (Tern SDK,
+ * `protocol/operations.md`, "Settling"). A settled block stays editable: a
+ * later change is sent as targeted ops by id, followed by a fresh `settle`
+ * hint.
  */
 import type { Component } from "../tui.js";
 /** Mark `component` (and everything it describes) as finalized. Idempotent; a no-op outside a TSP terminal. */

package/dist/types/overlays/btw-history-panel.d.ts

@@ -13,6 +13,12 @@ interface BtwHistoryPanelOptions {
     spaceHold?: (input: Input) => SpaceHoldHandler;
     requestRender: () => void;
     getHeight: () => number;
+    /**
+     * Esc closes the panel even while the selected answer runs (it keeps
+     * streaming in the background) and `x` cancels it, instead of Esc cancelling
+     * first. For a host with no inline panel to fall back to (Tern).
+     */
+    escapeHides?: boolean;
 }
 /** Session-local side questions. Selecting or copying never promotes them into chat. */
 export declare class BtwHistoryPanel implements Component, Focusable {
@@ -25,6 +31,8 @@ export declare class BtwHistoryPanel implements Component, Focusable {
     markCopied(recordId: string, text: string): void;
     invalidate(): void;
     openFollowUp(recordId: string): boolean;
+    /** Select a record with its answer pane focused, read from the top (a just-asked /btw). */
+    showRecord(recordId: string): void;
     /** Enhanced clipboard pastes belong only to the active composer. */
     pasteText(text: string): void;
     handleInput(data: string): void;

package/dist/types/overlays/model-hub.d.ts

@@ -12,6 +12,14 @@ export interface ModelHubSource extends ModelBrowserSource {
     getProjectModelRole(role: string): string | undefined;
     getGlobalModelRole(role: string): string | undefined;
     getModelRoleSource(role: string): "global" | "project" | "default";
+    /**
+     * Saved model presets (in switch order) and the one the current role setup
+     * matches, if any. Absent hosts have no presets to switch between.
+     */
+    getModelPresets?(): {
+        names: readonly string[];
+        active: string | undefined;
+    };
 }
 /** Catalog capabilities required by the model hub. */
 export interface ModelHubRegistry extends ModelBrowserRegistry {
@@ -48,6 +56,12 @@ export interface ModelHubCallbacks {
     onLoginRequest?: (providerId: string) => void;
     /** Save the current role assignments and default thinking level as a named model preset. */
     onSavePreset?: (name: string) => void;
+    /**
+     * Apply a saved model preset (ctrl+←/→ or p/⇧P in the Roles view) and report
+     * the outcome itself. A switch that writes nothing (a refused preset) still
+     * advances the hub's preset cursor, so the next press moves past it.
+     */
+    onSwitchPreset?: (name: string) => void | Promise<void>;
     /** Persist a new quick-switch cycle order (the ctrl+p role cycle). */
     onCycleOrderChange?: (order: string[]) => void;
     onCancel: () => void;

package/dist/types/prompt/custom-editor.d.ts

@@ -213,6 +213,8 @@ export declare class CustomEditor extends Editor {
      *  once after construction (and again after `setEditorComponent` swaps the
      *  editor). Passing `undefined` clears any pending frame. */
     setShimmerRepaintHandler(handler: (() => void) | undefined): void;
+    /** Editing is available during bootstrap; atomic sends wait until submission is wired and enabled. */
+    protected get nativeSendable(): boolean;
     /** Viewing a subagent, the draft goes to it: the placeholder names it. */
     describePlaceholder: () => string;
     /** A shell-mode draft highlights as its language. */

package/dist/types/windows-input-mode.d.ts

@@ -16,10 +16,26 @@
  * terminal sends; chords legacy encoding loses (modified Enter/Tab/Escape,
  * Ctrl+Shift+letter, …) translate to kitty CSI-u, which key matching already
  * parses.
+ *
+ * A host terminal that writes VT instead of key records (any ConPTY host
+ * besides Windows Terminal's native path) reaches us as one `Vk = 0` text
+ * record per byte: Alt+Up arrives as `ESC`, `[`, `1`, `;`, `3`, `A`. Those
+ * bytes are reassembled into the escape sequence they spell; delivering them
+ * one at a time turns every such key into a bare Escape plus typed garbage.
+ */
+/**
+ * Stateful decoder: joins UTF-16 surrogate halves that arrive as separate
+ * records, and reassembles VT escape sequences relayed as text records.
  */
-/** Stateful decoder: joins UTF-16 surrogate halves that arrive as separate records. */
 export declare class Win32InputModeDecoder {
     #private;
+    /** Whether relayed VT text is held waiting for the rest of its sequence. */
+    get hasPendingSequence(): boolean;
+    /**
+     * Release held VT text as-is. The caller invokes this once no further bytes
+     * arrived in time, so a lone relayed ESC still acts as the Escape key.
+     */
+    flushPendingSequence(): string[];
     /**
      * Translate one stdin sequence. Returns `undefined` when `data` is not a
      * win32-input-mode record (pass it through unchanged), otherwise the key
@@ -42,7 +58,11 @@ export declare class Win32InputModeDecoder {
  */
 export declare class Win32PasteMarkerNormalizer {
     #private;
-    constructor(onInput: (data: string) => void);
+    /**
+     * `onExpired` runs after held records are released because their wait timed
+     * out, so a downstream holder can treat the same wait as already elapsed.
+     */
+    constructor(onInput: (data: string) => void, onExpired?: () => void);
     process(data: string): void;
     /** Release an incomplete marker as its original key records. */
     flush(): void;

package/package.json

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

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 ──────────────────────────────────────────────────────────────────
@@ -721,6 +726,7 @@ export class DiffPane {
 		this.scrollLeft = 0;
 		this.cursor = 0;
 		this.anchor = null;
+		if (mode === "hunk") this.selectedHunk = 0;
 	}
 
 	cycleMode(): void {
@@ -771,6 +777,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 +861,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 +878,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 +938,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 +958,7 @@ export class DiffPane {
 				this.anchor = null;
 			}
 			this.cursor = visual;
+			this.#syncHunkToCursor();
 			return { type: "handled" };
 		}
 		return null;

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`
@@ -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;

package/src/components/editor.ts

@@ -754,6 +754,11 @@ export class Editor implements Component, Focusable {
 	onLargePaste?: (text: string, lineCount: number, options: PasteOptions) => boolean;
 	onAutocompleteCancel?: () => void;
 	disableSubmit: boolean = false;
+	/** Base editors accept native edits, not atomic sends. Implementations that
+	 *  handle `send` override this readiness check for their submission path. */
+	protected get nativeSendable(): boolean {
+		return false;
+	}
 	/** Placeholder painted right-aligned on the cursor row while the editor is empty and no
 	 *  autocomplete is open; hidden when it can't keep {@link PLACEHOLDER_MIN_GAP} cells from the
 	 *  cursor. The host styles it (ANSI allowed). Re-evaluated on every render, so hosts can derive
@@ -1687,6 +1692,7 @@ export class Editor implements Component, Focusable {
 		const props: TspEditorProps = {
 			text,
 			cursor,
+			sendable: this.nativeSendable,
 			anchor: anchor ?? undefined,
 			decor: decor.decor,
 			ghost: ghost ? plainText(ghost) : undefined,

package/src/components/input.ts

@@ -583,6 +583,7 @@ export class Input implements Component, Focusable {
 		const props: TspInputProps = {
 			text: value,
 			cursor,
+			sendable: false,
 			prompt: prompt || undefined,
 			placeholder: this.placeholder,
 		};

package/src/native/apply.ts

@@ -1,8 +1,9 @@
 /**
  * Reference document applier: applies TSP frames to a node tree the way the
- * spec says the terminal does (§5.1). Ops are validated and applied one by
- * one; a rejected op is reported and skipped without affecting the rest of
- * the frame. `settle` is recorded as a hint and never restricts later ops.
+ * spec says the terminal does (Tern SDK, `protocol/documents.md`, frame ops).
+ * Ops are validated and applied one by one; a rejected op is reported and
+ * skipped without affecting the rest of the frame. `settle` is recorded as a
+ * hint and never restricts later ops.
  *
  * Used by tests, the debug server's `doc` op, and the TSP test harness.
  */

package/src/native/encode.ts

@@ -108,9 +108,10 @@ export function encodeTspJson(verb: TspVerb, value: unknown, params?: TspParams,
 
 /**
  * The `hello` query; callers follow it with a DA1 sentinel. `features: ["edit"]`
- * tells the terminal that omp applies its `edit` events (TSP §8.5), so it may keep a
- * native selection in omp's editors; without it, every key stays omp's. `"undo"`
- * says omp applies `undo` events, so the terminal may turn ⌃Z in a field into one.
+ * tells the terminal that omp applies its `edit` events (Tern SDK,
+ * `protocol/input.md`), so it may keep a native selection in omp's editors;
+ * without it, every key stays omp's. `"undo"` says omp applies `undo` events,
+ * so the terminal may turn ⌃Z in a field into one.
  * `"send"` accepts an explicit prompt for a live composer without simulating keys.
  */
 export function encodeTspHelloQuery(version?: string): string {

package/src/native/node.ts

@@ -11,7 +11,8 @@
  * `rows` fallback node rendered through `render(cx.cols)`.
  *
  * See `packages/wire/src/tsp.ts` for the wire vocabulary and
- * `crates/tern/SURFACE_PROTOCOL.md` (Stencil repository) for the spec.
+ * the Tern SDK's Surface Protocol reference (`docs/sdk/src/protocol` in the
+ * Stencil repository, https://docs.stencil.so/tern/protocol/) for the spec.
  */
 import type { TspEvent, TspKind, TspProps, TspScrollBy, TspSpan } from "@oh-my-pi/pi-wire";
 import type { Component } from "../tui";

package/src/native/settle.ts

@@ -1,8 +1,9 @@
 /**
  * Settling: the frame provider marks finalized transcript blocks so the
- * native reconciler stops keeping their description (spec §12 "Settling and
- * program memory"). A settled block stays editable: a later change is sent as
- * targeted ops by id, followed by a fresh `settle` hint.
+ * native reconciler stops keeping their description (Tern SDK,
+ * `protocol/operations.md`, "Settling"). A settled block stays editable: a
+ * later change is sent as targeted ops by id, followed by a fresh `settle`
+ * hint.
  */
 import type { Component } from "../tui";
 

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

@@ -34,8 +34,8 @@ import { bottomBorder, row, topBorder } from "../chrome/overlay-box";
 import { padToWidth } from "../render/utils";
 import { SplitPane } from "../components/layout/split-pane";
 import { clampSelection, contentRowWidth, padLinesToHeight, renderScrollableList } from "../chrome/selector-helpers";
-import type { TspSpan } from "@oh-my-pi/pi-wire";
-import type { NativeChild, NativeNode, NativeUiEvent } from "../native/node";
+import type { TspScrollBy, TspSpan } from "@oh-my-pi/pi-wire";
+import type { NativeChild, NativeNode, NativeScroll, NativeUiEvent } from "../native/node";
 import { col, md, node, span, text } from "../native/describe";
 import { actionHint, hintsRow, type NativeHint, statusHintsRow } from "../native/overlay";
 
@@ -50,6 +50,12 @@ interface BtwHistoryPanelOptions {
 	spaceHold?: (input: Input) => SpaceHoldHandler;
 	requestRender: () => void;
 	getHeight: () => number;
+	/**
+	 * Esc closes the panel even while the selected answer runs (it keeps
+	 * streaming in the background) and `x` cancels it, instead of Esc cancelling
+	 * first. For a host with no inline panel to fall back to (Tern).
+	 */
+	escapeHides?: boolean;
 }
 
 interface FollowUpComposer {
@@ -78,6 +84,7 @@ interface BtwHistoryNativeMemo {
 	followUpPending: boolean;
 	canFollowUp: boolean;
 	copied: boolean;
+	scroll: NativeScroll | undefined;
 	node: NativeNode;
 }
 
@@ -108,6 +115,8 @@ export class BtwHistoryPanel implements Component, Focusable {
 	#lastCopiedId: string | undefined;
 	#lastCopiedText: string | undefined;
 	#native: BtwHistoryNativeMemo | undefined;
+	/** The last answer-pane scroll key, forwarded natively (see {@link NativeNode.scroll}). */
+	#scroll: NativeScroll | undefined;
 	readonly #detail = new ScrollView([], {
 		height: 1,
 		scrollbar: "auto",
@@ -159,6 +168,7 @@ export class BtwHistoryPanel implements Component, Focusable {
 		this.#options = options;
 		this.#records = options.records;
 		this.#selectedId = options.records[0]?.id;
+		if (options.records.length === 1) this.#focus = "answer";
 	}
 
 	get focused(): boolean {
@@ -187,6 +197,8 @@ export class BtwHistoryPanel implements Component, Focusable {
 			this.#followLatest = false;
 			this.#detail.scrollToTop();
 		}
+		// One side question has nothing to pick: its answer keeps the arrow keys.
+		if (records.length === 1) this.#focus = "answer";
 		this.#options.requestRender();
 	}
 
@@ -247,6 +259,26 @@ export class BtwHistoryPanel implements Component, Focusable {
 		return true;
 	}
 
+	/** Select a record with its answer pane focused, read from the top (a just-asked /btw). */
+	showRecord(recordId: string): void {
+		const index = this.#records.findIndex(record => record.id === recordId);
+		if (index === -1) return;
+		this.#select(index);
+		this.#focus = "answer";
+		this.#options.requestRender();
+	}
+
+	/**
+	 * Jump the answer pane to its bottom once (opening or sending a follow-up):
+	 * text mode keeps following the newest row at render until a scroll key;
+	 * natively the sheet body scrolls to its end. Tern reports no wheel scroll,
+	 * so streamed updates never re-pin it there and a reader is never yanked.
+	 */
+	#jumpToEnd(): void {
+		this.#followLatest = true;
+		this.#scroll = { by: "end", n: (this.#scroll?.n ?? 0) + 1 };
+	}
+
 	#openComposer(record: BtwHistoryRecord): void {
 		const input = new Input();
 		input.prompt = theme.fg("accent", "Follow up: ");
@@ -261,6 +293,8 @@ export class BtwHistoryPanel implements Component, Focusable {
 		};
 		this.#composer = composer;
 		this.#focus = "answer";
+		// Following up reads from the newest turn, right above the composer.
+		this.#jumpToEnd();
 		this.#options.requestRender();
 	}
 
@@ -286,7 +320,7 @@ export class BtwHistoryPanel implements Component, Focusable {
 				this.#composer = undefined;
 				this.#selectedId = composer.recordId;
 				this.#focus = "answer";
-				this.#followLatest = true;
+				this.#jumpToEnd();
 			} else {
 				composer.notice = `Follow-up was not started. Your draft is kept; ${editorKey("tui.input.submit")} to retry.`;
 			}
@@ -314,11 +348,17 @@ export class BtwHistoryPanel implements Component, Focusable {
 			return;
 		}
 		const record = this.#selected();
+		const running = record !== undefined && getBtwLatestTurn(record).status === "running" ? record : undefined;
+		const hides = this.#options.escapeHides === true;
 		if (matchesSelectCancel(data) || matchesKey(data, "escape")) {
-			if (record && getBtwLatestTurn(record).status === "running") this.#options.onCancel(record);
+			if (running && !hides) this.#options.onCancel(running);
 			else this.#options.onClose();
 			return;
 		}
+		if (hides && matchesKey(data, "x")) {
+			if (running) this.#options.onCancel(running);
+			return;
+		}
 		if (matchesKey(data, "f") || matchesKey(data, "enter")) {
 			if (record) this.openFollowUp(record.id);
 			return;
@@ -335,11 +375,12 @@ export class BtwHistoryPanel implements Component, Focusable {
 			matchesKey(data, "ctrl+_") ||
 			data === String.fromCharCode(31)
 		) {
-			this.#focus = this.#focus === "list" ? "answer" : "list";
+			// One side question has nothing to pick: its answer keeps the arrow keys.
+			if (this.#records.length > 1) this.#focus = this.#focus === "list" ? "answer" : "list";
 		} else if (matchesKey(data, "right")) {
 			this.#focus = "answer";
 		} else if (matchesKey(data, "left")) {
-			this.#focus = "list";
+			if (this.#records.length > 1) this.#focus = "list";
 		} else if (this.#focus === "list") {
 			const index = this.#selectedIndex();
 			if (matchesSelectUp(data)) this.#select(index - 1);
@@ -350,11 +391,25 @@ export class BtwHistoryPanel implements Component, Focusable {
 			else if (matchesKey(data, "end")) this.#select(this.#records.length - 1);
 			else return;
 		} else {
-			if (matchesSelectUp(data)) this.#detail.scroll(-1);
-			else if (matchesSelectDown(data)) this.#detail.scroll(1);
-			else if (matchesSelectPageUp(data)) this.#detail.page(-1);
-			else if (matchesSelectPageDown(data)) this.#detail.page(1);
+			const by: TspScrollBy | undefined = matchesSelectUp(data)
+				? "line-up"
+				: matchesSelectDown(data)
+					? "line-down"
+					: matchesSelectPageUp(data)
+						? "page-up"
+						: matchesSelectPageDown(data)
+							? "page-down"
+							: matchesKey(data, "home")
+								? "start"
+								: matchesKey(data, "end")
+									? "end"
+									: undefined;
+			if (by === "line-up") this.#detail.scroll(-1);
+			else if (by === "line-down") this.#detail.scroll(1);
+			else if (by === "page-up") this.#detail.page(-1);
+			else if (by === "page-down") this.#detail.page(1);
 			else if (!this.#detail.handleScrollKey(data)) return;
+			if (by) this.#scroll = { by, n: (this.#scroll?.n ?? 0) + 1 };
 			this.#followLatest = matchesKey(data, "end");
 		}
 		this.#options.requestRender();
@@ -378,31 +433,39 @@ export class BtwHistoryPanel implements Component, Focusable {
 			memo.notice === composer?.notice &&
 			memo.followUpPending === this.#followUpPending &&
 			memo.canFollowUp === canFollowUp &&
-			memo.copied === copied
+			memo.copied === copied &&
+			memo.scroll === this.#scroll
 		) {
 			return memo.node;
 		}
-		const children: NativeChild[] = [
-			node(
-				"row",
-				{ gap: "md", align: "start" },
-				[
+		// Plain columns, not `section`s: Tern draws a section as a foldable `##` heading,
+		// and a flex item's min-content width (a long code line in the answer) would
+		// crush the list pane. The answer pane may shrink to nothing; the list may not.
+		// With one side question the list and the pane labels are noise: the answer alone.
+		const showList = this.#records.length > 1;
+		const detail = this.#describeDetail(record, copied);
+		const answerPane: NativeNode = {
+			...node(
+				"col",
+				{ gap: "sm", grow: 1, basis: 0, min: { w: 0 } },
+				showList ? [text(this.#describeFocusLabel("answer"), { truncate: "end", lines: 1 }), detail] : [detail],
+				"details",
+			),
+			// Natively the sheet body is the scroller; arrow/page keys on the answer pane move it.
+			scroll: this.#scroll,
+		};
+		const panes: NativeChild[] = showList
+			? [
 					node(
-						"section",
-						{ head: this.#describeFocusLabel("list"), basis: 0.42, max: { w: "46ch" } },
-						[this.#describeList()],
+						"col",
+						{ gap: "sm", shrink: 0, basis: 0.3, max: { w: "40ch" } },
+						[text(this.#describeFocusLabel("list"), { truncate: "end", lines: 1 }), this.#describeList()],
 						"history",
 					),
-					node(
-						"section",
-						{ head: this.#describeFocusLabel("answer"), grow: 1 },
-						[this.#describeDetail(record, copied)],
-						"details",
-					),
-				],
-				"body",
-			),
-		];
+					answerPane,
+				]
+			: [answerPane];
+		const children: NativeChild[] = [node("row", { gap: "lg", align: "start" }, panes, "body")];
 		if (composer) {
 			composer.input.focused = this.#focused;
 			const lines: NativeChild[] = [
@@ -427,6 +490,7 @@ export class BtwHistoryPanel implements Component, Focusable {
 			followUpPending: this.#followUpPending,
 			canFollowUp,
 			copied,
+			scroll: this.#scroll,
 			node: described,
 		};
 		return described;
@@ -492,10 +556,21 @@ export class BtwHistoryPanel implements Component, Focusable {
 		const answer = turn.answer.trim()
 			? md(sanitizeDisplayText(turn.answer), { stream: turn.status === "running" })
 			: text([span(turn.status === "running" ? "Waiting for response…" : "No answer text.", "dim")]);
+		// Plain labels, not `section`s (Tern draws those as foldable `##` headings);
+		// the question stays markdown so its inline code and links render.
 		const children: NativeChild[] = [
-			text([span(`${status.label} · ${this.#dateFormat.format(turn.createdAt)}`, status.color)], { wrap: "word" }),
-			node("section", { head: [span("Question", "accent strong")] }, [md(sanitizeDisplayText(turn.question))]),
-			node("section", { head: [span("Answer", "accent strong")] }, [answer]),
+			text(
+				[
+					span("Question", "accent strong"),
+					span(" · ", "dim"),
+					span(status.label, status.color),
+					span(` · ${this.#dateFormat.format(turn.createdAt)}`, "dim"),
+				],
+				{ wrap: "word" },
+			),
+			md(sanitizeDisplayText(turn.question)),
+			text([span("Answer", "accent strong")]),
+			answer,
 		];
 		if (turn.error) children.push(text([span(sanitizeErrorLine(turn.error), "error")], { wrap: "word" }));
 		if (turn.status === "interrupted") children.push(text([span("Not resumed in this view.", "muted")]));
@@ -510,9 +585,11 @@ export class BtwHistoryPanel implements Component, Focusable {
 			]);
 		}
 		const latest = record ? getBtwLatestTurn(record) : undefined;
+		const running = latest?.status === "running";
 		const hints: (NativeHint | undefined)[] = [
-			actionHint("tui.select.cancel", latest?.status === "running" ? "cancel" : "close"),
-			{ keys: ["tab", "ctrl+/"], label: "switch pane" },
+			actionHint("tui.select.cancel", running && !this.#options.escapeHides ? "cancel" : "close"),
+			running && this.#options.escapeHides ? { keys: ["x"], label: "cancel" } : undefined,
+			this.#records.length > 1 ? { keys: ["tab", "ctrl+/"], label: "switch pane" } : undefined,
 			actionHint(["tui.select.up", "tui.select.down"], this.#focus === "list" ? "select" : "scroll"),
 		];
 		if (canFollowUp) hints.push({ keys: ["f", "enter"], label: "follow up" });
@@ -689,14 +766,16 @@ export class BtwHistoryPanel implements Component, Focusable {
 		const record = this.#selected();
 		const composer = this.#composer;
 		const latest = record ? getBtwLatestTurn(record) : undefined;
+		const running = latest?.status === "running";
 		const actions = composer
 			? [
 					keyHint("tui.input.submit", this.#followUpPending ? "starting…" : "send"),
 					keyHint("tui.select.cancel", "cancel"),
 				]
 			: [
-					keyHint("tui.select.cancel", latest?.status === "running" ? "cancel" : "close"),
-					rawKeyHint(["tab", "ctrl+/"], "switch pane"),
+					keyHint("tui.select.cancel", running && !this.#options.escapeHides ? "cancel" : "close"),
+					...(running && this.#options.escapeHides ? [rawKeyHint("x", "cancel")] : []),
+					...(this.#records.length > 1 ? [rawKeyHint(["tab", "ctrl+/"], "switch pane")] : []),
 				];
 		if (!composer) {
 			if (record && this.#canFollowUp(record)) actions.push(rawKeyHint(["f", "enter"], "follow up"));

package/src/overlays/model-hub.ts

@@ -109,6 +109,11 @@ export interface ModelHubSource extends ModelBrowserSource {
 	getProjectModelRole(role: string): string | undefined;
 	getGlobalModelRole(role: string): string | undefined;
 	getModelRoleSource(role: string): "global" | "project" | "default";
+	/**
+	 * Saved model presets (in switch order) and the one the current role setup
+	 * matches, if any. Absent hosts have no presets to switch between.
+	 */
+	getModelPresets?(): { names: readonly string[]; active: string | undefined };
 }
 
 /** Catalog capabilities required by the model hub. */
@@ -157,6 +162,12 @@ export interface ModelHubCallbacks {
 	onLoginRequest?: (providerId: string) => void;
 	/** Save the current role assignments and default thinking level as a named model preset. */
 	onSavePreset?: (name: string) => void;
+	/**
+	 * Apply a saved model preset (ctrl+←/→ or p/⇧P in the Roles view) and report
+	 * the outcome itself. A switch that writes nothing (a refused preset) still
+	 * advances the hub's preset cursor, so the next press moves past it.
+	 */
+	onSwitchPreset?: (name: string) => void | Promise<void>;
 	/** Persist a new quick-switch cycle order (the ctrl+p role cycle). */
 	onCycleOrderChange?: (order: string[]) => void;
 	onCancel: () => void;
@@ -216,7 +227,18 @@ type StripState =
 	  };
 
 /** A Roles-view command; keys and the picker's action bar both run {@link ModelHubComponent}'s `#runRolesAction`. */
-type RolesAction = "pick" | "clear" | "fallback" | "cycle" | "earlier" | "later" | "new" | "thinking" | "save";
+type RolesAction =
+	| "pick"
+	| "clear"
+	| "fallback"
+	| "cycle"
+	| "earlier"
+	| "later"
+	| "new"
+	| "thinking"
+	| "save"
+	| "nextPreset"
+	| "prevPreset";
 
 /** Printable keys of the Roles view and the command each runs. */
 const ROLES_ACTION_KEYS: Record<string, RolesAction> = {
@@ -228,6 +250,9 @@ const ROLES_ACTION_KEYS: Record<string, RolesAction> = {
 	n: "new",
 	t: "thinking",
 	s: "save",
+	// Letter twins of ctrl+←/→, which macOS reserves for switching Spaces.
+	p: "nextPreset",
+	P: "prevPreset",
 };
 
 /** Picker fact columns of the Roles view. */
@@ -345,6 +370,12 @@ export class ModelHubComponent implements Component {
 	#assigning: AssignTarget | null = null;
 	#strip: StripState | null = null;
 	#assignmentPending = false;
+	/**
+	 * Last preset ctrl+←/→ tried in this hub, with the settings revision after the
+	 * attempt; steps from it while nothing matches the setup or nothing changed since.
+	 */
+	#presetCursor: { name: string; revision: number } | undefined;
+	#presetsMemo: { revision: number; names: readonly string[]; active: string | undefined } | undefined;
 	#disposed = false;
 	/** Per-provider fuzzy match counts while a query is active; null when not searching. */
 	#searchCounts: Map<string, number> | null = null;
@@ -1536,10 +1567,13 @@ export class ModelHubComponent implements Component {
 		}
 	}
 
-	/** Switch the body into assign mode for `role`: full catalog, cleared query, current model preselected. */
+	/**
+	 * Switch the body into assign mode for `role`: full catalog, cleared query, current model preselected.
+	 * Arrows land on the model rows (the next step of the flow); ← still reaches the provider scopes.
+	 */
 	#startAssign(role: string): void {
 		this.#assigning = { kind: "role", role };
-		this.#focus = "scope";
+		this.#focus = "list";
 		this.#browser.setShowProvider(true);
 		this.#setCandidateItems(this.#availableItems);
 		this.#browser.setQuery("");
@@ -1552,7 +1586,7 @@ export class ModelHubComponent implements Component {
 	/** Browse the catalog to fill a fallback-chain slot: `index` replaces an entry, `null` appends. */
 	#startAssignFallback(role: string, index: number | null): void {
 		this.#assigning = { kind: "fallback", role, index };
-		this.#focus = "scope";
+		this.#focus = "list";
 		this.#browser.setShowProvider(true);
 		this.#setCandidateItems(this.#availableItems);
 		this.#browser.setQuery("");
@@ -1570,7 +1604,7 @@ export class ModelHubComponent implements Component {
 	/** Browse the catalog for the primary model a brand-new fallback chain protects. */
 	#startAssignFallbackKey(): void {
 		this.#assigning = { kind: "fallbackKey" };
-		this.#focus = "scope";
+		this.#focus = "list";
 		this.#browser.setShowProvider(true);
 		this.#setCandidateItems(this.#availableItems);
 		this.#browser.setQuery("");
@@ -1752,6 +1786,52 @@ export class ModelHubComponent implements Component {
 		this.#buildRolesRows();
 	}
 
+	/** Saved presets and the one the setup matches; empty unless the host can both list and switch. */
+	#presets(): { names: readonly string[]; active: string | undefined } {
+		if (!this.#callbacks.onSwitchPreset || !this.#settings.getModelPresets) return { names: [], active: undefined };
+		const revision = this.#settings.revision;
+		if (this.#presetsMemo?.revision !== revision) {
+			const { names, active } = this.#settings.getModelPresets();
+			this.#presetsMemo = { revision, names, active };
+		}
+		return this.#presetsMemo;
+	}
+
+	/**
+	 * The preset ctrl+←/→ steps from: the last one tried here while settings are
+	 * unchanged since (a refused switch writes nothing, so the next press moves
+	 * past it) or nothing matches; otherwise the preset the setup matches.
+	 */
+	#presetBase(active: string | undefined): string | undefined {
+		const cursor = this.#presetCursor;
+		if (cursor && (active === undefined || cursor.revision === this.#settings.revision)) return cursor.name;
+		return active;
+	}
+
+	/** Apply the previous/next saved preset (wrapping), as `/modelpreset switch` does. */
+	#switchPreset(delta: -1 | 1): void {
+		const onSwitchPreset = this.#callbacks.onSwitchPreset;
+		const { names, active } = this.#presets();
+		if (!onSwitchPreset || names.length === 0) return;
+		const base = this.#presetBase(active);
+		const current = base === undefined ? -1 : names.indexOf(base);
+		const next = current < 0 ? (delta > 0 ? 0 : names.length - 1) : (current + delta + names.length) % names.length;
+		const name = names[next];
+		if (name === undefined) return;
+		const settle = () => {
+			this.#presetCursor = { name, revision: this.#settings.revision };
+			this.#refreshAfterMutation();
+		};
+		// Stepping onto the preset already in effect has nothing to apply.
+		if (name === active) {
+			settle();
+			return;
+		}
+		// The host reports refusals itself, so the cursor moves once the switch
+		// resolves, refused or not (`#presetBase` sees a refusal left the revision alone).
+		this.#finishAssignment(onSwitchPreset(name), settle);
+	}
+
 	handleInput(data: string): void {
 		this.#nativeVersion++;
 		if (this.#assignmentPending) {
@@ -1787,6 +1867,11 @@ export class ModelHubComponent implements Component {
 			}
 			return;
 		}
+		// Ctrl+←/→ in the Roles view steps through saved model presets, wrapping.
+		if (rolesView && (matchesKey(data, "ctrl+left") || matchesKey(data, "ctrl+right"))) {
+			this.#switchPreset(matchesKey(data, "ctrl+left") ? -1 : 1);
+			return;
+		}
 		// Alt+←/→ cycles whichever tab strip is on screen: role tabs in the
 		// Roles view, kind tabs in every browser view. Ctrl+←/→ is unusable on
 		// macOS (Spaces shortcut). macOS terminals (ghostty, Terminal.app,
@@ -2067,6 +2152,10 @@ export class ModelHubComponent implements Component {
 			case "save":
 				if (this.#callbacks.onSavePreset) this.#openNameStrip("preset");
 				return;
+			case "nextPreset":
+			case "prevPreset":
+				this.#switchPreset(action === "nextPreset" ? 1 : -1);
+				return;
 			case "thinking":
 				if (role) {
 					const target = this.#roleThinkingTarget(role);
@@ -2265,8 +2354,13 @@ export class ModelHubComponent implements Component {
 			ROLE_TABS.map(tab => ({ label: tab === "kind" ? "kinds" : tab })),
 			Math.max(0, active),
 		);
+		const { names, active: activePreset } = this.#presets();
+		const preset =
+			names.length > 0
+				? `   ${theme.fg("dim", "Preset:")} ${activePreset ? theme.fg("accent", activePreset) : theme.fg("muted", "custom")}  ${theme.fg("dim", `${formatKeyHints(["ctrl+left", "ctrl+right"])} · ${formatKeyHints(["p", "shift+p"])}`)}`
+				: "";
 		return truncateToWidth(
-			` ${theme.fg("dim", "Roles:")} ${track}  ${theme.fg("dim", formatKeyHints(["alt+left", "alt+right"]))}`,
+			` ${theme.fg("dim", "Roles:")} ${track}  ${theme.fg("dim", formatKeyHints(["alt+left", "alt+right"]))}${preset}`,
 			width,
 		);
 	}
@@ -2563,7 +2657,9 @@ export class ModelHubComponent implements Component {
 		const entry = this.#activeEntry();
 		if (entry.kind === "roles") {
 			if (this.#focus !== "list") {
-				return `${upDown} providers · ${enterRight} roles · ${altLeftRight} tabs · ${cancel} close`;
+				const presets =
+					this.#presets().names.length > 0 ? ` · ${formatKeyHints(["ctrl+left", "ctrl+right"])} preset` : "";
+				return `${upDown} providers · ${enterRight} roles · ${altLeftRight} tabs${presets} · ${cancel} close`;
 			}
 			const row = this.#rolesRows[this.#roleIndex];
 			if (row?.kind === "fallback") {
@@ -2585,7 +2681,8 @@ export class ModelHubComponent implements Component {
 			const editable = row?.kind === "role" && this.#roleThinkingTarget(row.role) !== undefined;
 			const thinking = editable ? ` · ${formatKeyHint("t")} thinking` : "";
 			const savePreset = this.#callbacks.onSavePreset ? ` · ${formatKeyHint("s")} save preset` : "";
-			return `${upDown} rows · ${enter} pick · ${formatKeyHint("f")} fallback · ${formatKeyHint("x")} clear${thinking} · ${formatKeyHint("c")} cycle · [/] reorder · ${formatKeyHint("n")} new${savePreset}`;
+			const switchPreset = this.#presets().names.length > 0 ? ` · ${formatKeyHints(["p", "shift+p"])} preset` : "";
+			return `${upDown} rows · ${enter} pick · ${formatKeyHint("f")} fallback · ${formatKeyHint("x")} clear${thinking} · ${formatKeyHint("c")} cycle · [/] reorder · ${formatKeyHint("n")} new${savePreset}${switchPreset}`;
 		}
 		if (entry.kind === "provider" && entry.locked) {
 			return entry.oauth
@@ -3143,6 +3240,17 @@ export class ModelHubComponent implements Component {
 		if (entry.kind === "provider" && entry.providerId && this.#refreshingProviders.has(entry.providerId)) {
 			return `${entry.label} · refreshing model list…`;
 		}
+		const presets = rolesView ? this.#presets() : undefined;
+		if (presets && presets.names.length > 0) {
+			return [
+				span("Preset ", "muted"),
+				presets.active ? span(presets.active, "strong") : span("custom", "muted"),
+				span(
+					this.#scopedModels.length > 0 ? " · --models scope" : " · Cleared roles fall back to auto-selection",
+					"muted",
+				),
+			];
+		}
 		if (this.#scopedModels.length > 0) return "--models scope";
 		if (rolesView) return "Cleared roles fall back to auto-selection";
 		return undefined;
@@ -3296,6 +3404,7 @@ export class ModelHubComponent implements Component {
 						roleAction("cycle", this.#cycleOrder().includes(row.role) ? "Leave cycle" : "Add to cycle", "c"),
 						roleAction("new", "New role", "n"),
 						this.#callbacks.onSavePreset ? roleAction("save", "Save preset", "s") : undefined,
+						this.#presets().names.length > 0 ? roleAction("nextPreset", "Next preset", "p") : undefined,
 					);
 					break;
 				}
@@ -3782,6 +3891,7 @@ export class ModelHubComponent implements Component {
 						: "assign";
 			return [keys(pick, "enter"), upDown("models"), keys("providers", "left"), search, kind, cancel("cancel")];
 		}
+		const presetHint = this.#presets().names.length > 0 ? keys("preset", "ctrl+left", "ctrl+right") : undefined;
 		const entry = this.#activeEntry();
 		if (entry.kind === "roles") {
 			if (this.#focus !== "list") {
@@ -3789,6 +3899,7 @@ export class ModelHubComponent implements Component {
 					upDown("providers"),
 					keys("roles", "enter", "right"),
 					keys("tabs", "alt+left", "alt+right"),
+					presetHint,
 					cancel("close"),
 				];
 			}
@@ -3828,6 +3939,7 @@ export class ModelHubComponent implements Component {
 				reorder,
 				keys("new", "n"),
 				this.#callbacks.onSavePreset ? keys("save preset", "s") : undefined,
+				this.#presets().names.length > 0 ? keys("preset", "ctrl+left", "ctrl+right", "p", "shift+p") : undefined,
 			];
 		}
 		if (entry.kind === "provider" && entry.locked) {

package/src/prompt/custom-editor.ts

@@ -1001,6 +1001,10 @@ export class CustomEditor extends Editor {
 		}, CustomEditor.SHIMMER_FRAME_MS);
 		this.#shimmerTimer.unref?.();
 	}
+	/** Editing is available during bootstrap; atomic sends wait until submission is wired and enabled. */
+	protected override get nativeSendable(): boolean {
+		return this.onSubmit !== undefined && !this.disableSubmit;
+	}
 	/** Viewing a subagent, the draft goes to it: the placeholder names it. */
 	override describePlaceholder = (): string => {
 		const agent = this.composerState().viewing?.at(-1);
@@ -1259,7 +1263,7 @@ export class CustomEditor extends Editor {
 		if (event.type === "send") {
 			// A send is its own prompt: never submit a stale draft for blank input,
 			// and retain a displaced draft (including its attachments) for recall.
-			if (!event.text.trim() || this.disableSubmit || !this.onSubmit) return;
+			if (!event.text.trim() || !this.nativeSendable) return;
 			if (this.#pasteInFlight > 0) {
 				this.#pendingInput.push(event);
 				return;

package/src/terminal.ts

@@ -38,6 +38,8 @@ const TERMINAL_PROGRESS_KEEPALIVE_MS = 1000;
 const TERMINAL_PROGRESS_ACTIVE_SEQUENCE = "\x1b]9;4;3\x07";
 const TERMINAL_PROGRESS_CLEAR_SEQUENCE = "\x1b]9;4;0;\x07";
 const WINDOWS_TERMINAL_OSC11_POLL_MS = 30_000;
+/** How long a relayed ESC record waits for the rest of its sequence before acting as Escape (matches StdinBuffer). */
+const WIN32_RELAYED_ESCAPE_TIMEOUT_MS = 75;
 
 /**
  * Terminal → program TSP messages through a Windows ConPTY: its input parser
@@ -759,6 +761,8 @@ export class ProcessTerminal implements Terminal {
 	// win32-input-mode sequences and are decoded before reaching the handler.
 	#win32InputDecoder?: Win32InputModeDecoder;
 	#win32PasteNormalizer?: Win32PasteMarkerNormalizer;
+	// Releases a relayed lone ESC the decoder held for a sequence tail that never came.
+	#win32PendingFlushTimer?: Timer;
 	#stdinBuffer?: StdinBuffer;
 	#stdinDataHandler?: (data: string) => void;
 	#disconnectHandler?: () => void;
@@ -1570,9 +1574,18 @@ export class ProcessTerminal implements Terminal {
 				return;
 			}
 			if (this.#inputHandler) {
-				const win32Keys = this.#win32InputDecoder?.decode(sequence);
-				if (win32Keys !== undefined) {
+				const decoder = this.#win32InputDecoder;
+				const win32Keys = decoder?.decode(sequence);
+				if (decoder && win32Keys !== undefined) {
+					clearTimeout(this.#win32PendingFlushTimer);
+					this.#win32PendingFlushTimer = undefined;
 					for (const key of win32Keys) this.#inputHandler(key);
+					if (decoder.hasPendingSequence) {
+						this.#win32PendingFlushTimer = setTimeout(
+							() => this.#releaseWin32PendingSequence(),
+							WIN32_RELAYED_ESCAPE_TIMEOUT_MS,
+						);
+					}
 					return;
 				}
 				// Windows console hosts drop AltGr text under kitty (AltGr+F → `CSI 102;3u`);
@@ -1868,7 +1881,12 @@ export class ProcessTerminal implements Terminal {
 			// and the mode splits arrow keys into Escape plus literal text (#14034).
 			this.#safeWrite("\x1b[?9001h");
 			this.#win32InputDecoder = new Win32InputModeDecoder();
-			this.#win32PasteNormalizer = new Win32PasteMarkerNormalizer(data => this.#stdinBuffer?.process(data));
+			// The normalizer's expiry already spent the ESC wait; release the decoder's hold
+			// at once instead of starting a second window.
+			this.#win32PasteNormalizer = new Win32PasteMarkerNormalizer(
+				data => this.#stdinBuffer?.process(data),
+				() => this.#releaseWin32PendingSequence(),
+			);
 			return;
 		}
 		// A remote terminal with no identifying env may not understand the request.
@@ -1877,10 +1895,20 @@ export class ProcessTerminal implements Terminal {
 		this.#modifyOtherKeysActive = true;
 	}
 
+	/** Deliver relayed VT text the decoder is holding (a lone ESC becomes Escape). */
+	#releaseWin32PendingSequence(): void {
+		clearTimeout(this.#win32PendingFlushTimer);
+		this.#win32PendingFlushTimer = undefined;
+		const pending = this.#win32InputDecoder?.flushPendingSequence() ?? [];
+		for (const key of pending) this.#inputHandler?.(key);
+	}
+
 	#disableWin32InputMode(): void {
 		if (!this.#win32InputDecoder) return;
 		this.#win32PasteNormalizer?.flush();
 		this.#win32PasteNormalizer = undefined;
+		// Held input still belongs to the user (e.g. Escape before a late kitty reply).
+		this.#releaseWin32PendingSequence();
 		this.#safeWrite("\x1b[?9001l");
 		this.#win32InputDecoder = undefined;
 	}

package/src/windows-input-mode.ts

@@ -16,6 +16,12 @@
  * terminal sends; chords legacy encoding loses (modified Enter/Tab/Escape,
  * Ctrl+Shift+letter, …) translate to kitty CSI-u, which key matching already
  * parses.
+ *
+ * A host terminal that writes VT instead of key records (any ConPTY host
+ * besides Windows Terminal's native path) reaches us as one `Vk = 0` text
+ * record per byte: Alt+Up arrives as `ESC`, `[`, `1`, `;`, `3`, `A`. Those
+ * bytes are reassembled into the escape sequence they spell; delivering them
+ * one at a time turns every such key into a bare Escape plus typed garbage.
  */
 
 const W32IM_PATTERN = /^\x1b\[([\d;]*)_$/;
@@ -111,6 +117,31 @@ function baseCodepointForVk(vk: number): number {
 	return 0;
 }
 
+/** `split`: the leading ESC is a standalone Escape and the rest starts a new sequence. */
+type VtState = "partial" | "complete" | "invalid" | "split";
+
+/** Classify relayed VT text that starts with ESC. */
+function vtState(text: string): VtState {
+	if (text.length === 1) return "partial";
+	const introducer = text[1]!;
+	if (introducer === "\x1b") {
+		if (text.length === 2) return "partial";
+		// Only meta-CSI/SS3 (legacy Alt+Up is `ESC ESC [ A`) stays grouped; `ESC ESC d`
+		// is Escape followed by Alt+d, matching StdinBuffer.
+		return text[2] === "[" || text[2] === "O" ? vtState(text.slice(1)) : "split";
+	}
+	if (introducer === "[") {
+		if (/^\x1b\[[0-?]*[ -/]*[@-~]$/.test(text)) return "complete";
+		return /^\x1b\[[0-?]*[ -/]*$/.test(text) ? "partial" : "invalid";
+	}
+	if (introducer === "O") return text.length === 2 ? "partial" : text.length === 3 ? "complete" : "invalid";
+	if (introducer === "]" || introducer === "P" || introducer === "_") {
+		return text.endsWith("\x07") || (text.length > 3 && text.endsWith("\x1b\\")) ? "complete" : "partial";
+	}
+	// ESC + one character: Alt+character.
+	return text.length === 2 ? "complete" : "invalid";
+}
+
 function encodeKey(record: KeyRecord): string | null {
 	const { vk, uc, state } = record;
 	const shift = (state & SHIFT_PRESSED) !== 0;
@@ -165,9 +196,30 @@ function encodeKey(record: KeyRecord): string | null {
 	return uc === 0 ? null : text;
 }
 
-/** Stateful decoder: joins UTF-16 surrogate halves that arrive as separate records. */
+/**
+ * Stateful decoder: joins UTF-16 surrogate halves that arrive as separate
+ * records, and reassembles VT escape sequences relayed as text records.
+ */
 export class Win32InputModeDecoder {
 	#pendingHighSurrogate = 0;
+	/** Relayed VT text that starts with ESC and has not completed a sequence yet. */
+	#pendingVt = "";
+
+	/** Whether relayed VT text is held waiting for the rest of its sequence. */
+	get hasPendingSequence(): boolean {
+		return this.#pendingVt.length > 0;
+	}
+
+	/**
+	 * Release held VT text as-is. The caller invokes this once no further bytes
+	 * arrived in time, so a lone relayed ESC still acts as the Escape key.
+	 */
+	flushPendingSequence(): string[] {
+		if (this.#pendingVt.length === 0) return [];
+		const pending = this.#pendingVt;
+		this.#pendingVt = "";
+		return [pending];
+	}
 
 	/**
 	 * Translate one stdin sequence. Returns `undefined` when `data` is not a
@@ -180,17 +232,42 @@ export class Win32InputModeDecoder {
 
 		if (!record.down) {
 			// Alt+Numpad composition delivers its character on the Alt release.
-			if (record.vk === VK_MENU && record.uc !== 0) return this.#emitText(record.uc);
+			if (record.vk === VK_MENU && record.uc !== 0) return this.#assembleVt(this.#emitText(record.uc));
 			return [];
 		}
 		if (MODIFIER_VKS.has(record.vk)) return [];
-		if (record.vk === 0 || record.vk === VK_PACKET) return this.#emitText(record.uc, record.repeat);
-		if (record.uc >= 0xd800 && record.uc <= 0xdfff) return this.#emitText(record.uc);
+		if (record.vk === 0 || record.vk === VK_PACKET) return this.#assembleVt(this.#emitText(record.uc, record.repeat));
+		if (record.uc >= 0xd800 && record.uc <= 0xdfff) return this.#assembleVt(this.#emitText(record.uc));
 
 		this.#pendingHighSurrogate = 0;
 		const encoded = encodeKey(record);
-		if (encoded === null) return [];
-		return Array.from({ length: record.repeat }, () => encoded);
+		// A real key ends whatever relayed text was still incomplete.
+		const flushed = this.flushPendingSequence();
+		if (encoded === null) return flushed;
+		for (let i = 0; i < record.repeat; i++) flushed.push(encoded);
+		return flushed;
+	}
+
+	/** Group relayed text into whole escape sequences; other text passes through per character. */
+	#assembleVt(texts: string[]): string[] {
+		const out: string[] = [];
+		for (const text of texts) {
+			if (this.#pendingVt.length === 0 && text !== "\x1b") {
+				out.push(text);
+				continue;
+			}
+			this.#pendingVt += text;
+			let state = vtState(this.#pendingVt);
+			while (state === "split") {
+				out.push("\x1b");
+				this.#pendingVt = this.#pendingVt.slice(1);
+				state = vtState(this.#pendingVt);
+			}
+			if (state === "partial") continue;
+			out.push(this.#pendingVt);
+			this.#pendingVt = "";
+		}
+		return out;
 	}
 
 	/**
@@ -245,9 +322,15 @@ export class Win32PasteMarkerNormalizer {
 	#marker = "";
 	#timer?: NodeJS.Timeout;
 	readonly #onInput: (data: string) => void;
+	readonly #onExpired?: () => void;
 
-	constructor(onInput: (data: string) => void) {
+	/**
+	 * `onExpired` runs after held records are released because their wait timed
+	 * out, so a downstream holder can treat the same wait as already elapsed.
+	 */
+	constructor(onInput: (data: string) => void, onExpired?: () => void) {
 		this.#onInput = onInput;
+		this.#onExpired = onExpired;
 	}
 
 	process(data: string): void {
@@ -324,7 +407,12 @@ export class Win32PasteMarkerNormalizer {
 		}
 
 		if (output) this.#onInput(output);
-		if (this.#candidate || this.#pending) this.#timer = setTimeout(() => this.flush(), 75);
+		if (this.#candidate || this.#pending) {
+			this.#timer = setTimeout(() => {
+				this.flush();
+				this.#onExpired?.();
+			}, 75);
+		}
 	}
 
 	/** Release an incomplete marker as its original key records. */