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

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [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

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/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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.6.0",
+	"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.6.0",
-		"@oh-my-pi/pi-agent-core": "18.6.0",
-		"@oh-my-pi/pi-ai": "18.6.0",
-		"@oh-my-pi/pi-catalog": "18.6.0",
-		"@oh-my-pi/pi-natives": "18.6.0",
-		"@oh-my-pi/pi-utils": "18.6.0",
-		"@oh-my-pi/pi-wire": "18.6.0",
-		"@oh-my-pi/snapcompact": "18.6.0"
+		"@oh-my-pi/omptype": "18.6.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/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"));