@narumitw/pi-btw 0.49.6 → 0.50.0

package/README.md

@@ -8,10 +8,13 @@ Use it when you want to ask a temporary question, inspect context, or get a shor
 
 ## ✨ Features
 
-- Adds a `/btw` menu for starting a side thread or changing pi-btw settings.
-- Keeps `/btw <question>` as a direct fast path.
-- Answers side questions in a temporary, scrollable UI.
+- Adds a `/btw` menu for starting or resuming an in-memory side thread or changing pi-btw settings.
+- Keeps `/btw <question>` as a direct fast path that always starts a fresh side thread.
+- Answers side questions in a dedicated, scrollable full-screen UI.
+- Keeps mouse-drag copying stable while the main agent continues running in the background.
 - Supports follow-up questions in the same ephemeral side thread.
+- Resumes any non-empty side thread retained by the current Pi session, listed by its first question.
+- Queues Pi-style `Steering` questions while an answer is running and processes them one at a time.
 - Optionally brings the latest answer, a question-to-end suffix, an exact line range, or the entire side thread into the main editor.
 - Uses the current session branch as context.
 - Uses Pi's current model or an independent model selected in `pi-btw.json`.
@@ -55,11 +58,20 @@ Examples:
 /btw is this API name idiomatic?
 ```
 
-Running `/btw` alone opens a two-row menu. **Start side thread** is selected first, so pressing
-`Enter` opens an empty ephemeral side thread; **Settings** changes the starting thinking level
-and whether shortcut changes are remembered. `/btw <question>` bypasses this menu, and its answer
-opens above the side-thread editor. A compact `btw · side thread` header stays fixed above the
-content so the ephemeral workspace remains recognizable while scrolling. Messages use Pi's normal
+Running `/btw` alone opens a menu with **Start side thread** selected first. When the current Pi
+session has non-empty side threads in memory, **Resume side thread** opens a bounded choice list;
+**Settings** changes the starting thinking level and whether shortcut changes are remembered.
+Each Resume row keeps the first question as its fixed title, shows its question count, and the list
+is ordered by the newest recorded answer or visible error. Opening and closing a thread without a
+new result does not reorder it. `/btw <question>` bypasses this menu and always starts a fresh side
+thread. Its answer opens above the side-thread editor. The side thread uses a dedicated full-screen
+terminal view.
+The main agent continues running in the background, but its screen rendering stays suspended until
+`/btw` closes, so new main-thread output cannot move a mouse selection inside the side thread.
+Drag the primary mouse button across side-thread text to select and copy it through Pi's terminal
+clipboard support. Returning from `/btw` redraws the main view with everything produced while it
+was hidden. A compact `btw · side thread` header stays fixed above the content so the ephemeral
+workspace remains recognizable while scrolling. Messages use Pi's normal
 user and assistant presentation without numbered turns or role labels. Type each question and press
 `Enter`; no follow-up shortcut is required.
 Previous side questions and answers remain available to the model and visible for that
@@ -68,10 +80,17 @@ invocation. The side-thread header shows its current thinking level. Press Pi's
 supported by the side-thread model; every later question uses the displayed level until it is
 changed again. By default, each shortcut change is also written to `pi-btw.json` for the next
 invocation. Turn **Remember thinking level changes** off in Settings to keep changes local to the
-current side thread. Neither path changes the main session's thinking level. While a response is
-running, the transcript stays visible above a compact `Answering…` status.
-The footer shows `PgUp`/`PgDn` only when history can scroll; press `Ctrl+C` to cancel an
-in-progress answer or leave the side thread.
+current side thread. Neither path changes the main session's thinking level.
+While a response is running, the transcript and composer remain visible above an `Answering…`
+status.
+Type another question and press `Enter` to queue it as `Steering`; queued questions are shown in
+submission order and answered one at a time after the active response completes.
+A queued question uses the side thread's thinking level when its turn begins.
+A failed active response is shown in the transcript and does not discard later steering questions.
+The footer shows `PgUp`/`PgDn` only when history can scroll; press `Ctrl+C` to cancel the active
+response and discard the ephemeral side-thread draft and steering queue. Completed questions,
+answers, and visible errors remain available through Resume until the current extension instance
+ends. Steering remains entirely inside pi-btw and never appends to the main conversation or editor.
 
 After at least one successful answer, press `Ctrl+R` to bring selected context to the main
 editor. The scope menu shows the size of the latest question and answer and the entire side
@@ -95,9 +114,11 @@ into Pi's main editor. It never sends the draft automatically. If the main edito
 draft, append is the recommended default. Replace is labeled as destructive and requires a second
 confirmation; Cancel returns to the side thread without changing either draft. Concurrent editor
 updates made while these menus are open are preserved. A success message reports whether context
-was loaded, appended, or replaced and its approximate size. Without an explicit bring-to-main
-action, closing `/btw`, reloading Pi, or switching sessions still discards the side thread without
-adding it to the main conversation.
+was loaded, appended, or replaced and its approximate size.
+Without an explicit bring-to-main action, closing `/btw` never adds the side thread to the main
+conversation. Non-empty threads remain only in memory for Resume within the current Pi session.
+`/new`, Pi `/resume`, `/reload`, extension replacement, and process restart discard every retained
+thread. Unsent drafts, steering queues, interrupted answers, and model credentials are never retained.
 
 ## ⚙️ Model and thinking level
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-btw",
-	"version": "0.49.6",
+	"version": "0.50.0",
 	"description": "Pi extension that adds a /btw side-question command.",
 	"type": "module",
 	"license": "MIT",
@@ -32,9 +32,9 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.7",
-		"@earendil-works/pi-ai": "0.84.0",
-		"@earendil-works/pi-coding-agent": "0.84.0",
-		"@earendil-works/pi-tui": "0.84.0",
+		"@earendil-works/pi-ai": "0.84.1",
+		"@earendil-works/pi-coding-agent": "0.84.1",
+		"@earendil-works/pi-tui": "0.84.1",
 		"typescript": "7.0.2"
 	},
 	"repository": {

package/src/btw.ts

@@ -25,8 +25,10 @@ import {
 	getAnsweredTurns,
 	summarizeBringToMain,
 } from "./bring-to-main.js";
+import { type RunBtwFullscreen, runBtwFullscreen } from "./fullscreen-ui.js";
 import {
 	type BtwCommandMenuResult,
+	type BtwResumeThreadSummary,
 	runBtwMenuPreservingEditor,
 	showBtwCommandMenu,
 } from "./menu.js";
@@ -106,6 +108,15 @@ export interface ResolvedBtwModel {
 	auth: SideQuestionAuth;
 }
 
+export interface BtwThreadState {
+	id: string;
+	title?: string;
+	thread: SideThread;
+	thinkingLevel: BtwThinkingLevel;
+	createdAt: number;
+	updatedAt: number;
+}
+
 export async function resolveBtwModel({
 	settings,
 	currentModel,
@@ -209,10 +220,12 @@ export interface BtwExtensionDependencies {
 	showCommandMenu?: (
 		pi: ExtensionAPI,
 		ctx: ExtensionCommandContext,
+		resumeThreads: readonly BtwResumeThreadSummary[],
 	) => Promise<BtwCommandMenuResult>;
 	loadSettings?: typeof loadSettingsForCommand;
 	resolveModel?: typeof resolveBtwModelWithLoader;
 	runThread?: typeof runBtwThread;
+	runFullscreen?: RunBtwFullscreen;
 }
 
 export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependencies = {}) {
@@ -220,6 +233,22 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 	const loadSettings = dependencies.loadSettings ?? loadSettingsForCommand;
 	const resolveModel = dependencies.resolveModel ?? resolveBtwModelWithLoader;
 	const runThread = dependencies.runThread ?? runBtwThread;
+	const runFullscreen = dependencies.runFullscreen ?? runBtwFullscreen;
+	// Pi creates a fresh extension instance after session replacement or reload.
+	const resumableThreads = new Map<string, BtwThreadState>();
+	let nextThreadNumber = 1;
+	const listResumeThreads = (): BtwResumeThreadSummary[] =>
+		[...resumableThreads.values()]
+			.reverse()
+			.filter((state) => state.thread.turns.length > 0 && state.title)
+			.sort(
+				(first, second) => second.updatedAt - first.updatedAt || second.createdAt - first.createdAt,
+			)
+			.map((state) => ({
+				id: state.id,
+				title: state.title ?? "Untitled side thread",
+				questionCount: state.thread.turns.length,
+			}));
 	pi.registerCommand("btw", {
 		description: "Ask a quick side question without adding it to the main conversation",
 		handler: async (args, ctx) => {
@@ -228,7 +257,12 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 				ctx.ui.notify("/btw requires interactive TUI mode", "error");
 				return;
 			}
-			if (!question && (await showCommandMenu(pi, ctx)) !== "start") return;
+
+			let menuResult: BtwCommandMenuResult = "start";
+			if (!question) {
+				menuResult = await showCommandMenu(pi, ctx, listResumeThreads());
+				if (menuResult === "closed") return;
+			}
 
 			const settings = await loadSettings(ctx);
 			const resolution = await resolveModel(settings, ctx);
@@ -241,13 +275,46 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 				return;
 			}
 
-			await runThread({
-				initialQuestion: question || undefined,
-				selected: resolution.selected,
-				thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
-				rememberThinkingLevelChanges: effectiveRememberThinkingLevelChanges(settings),
-				ctx,
-			});
+			let state =
+				typeof menuResult === "object" ? resumableThreads.get(menuResult.threadId) : undefined;
+			if (typeof menuResult === "object" && !state) {
+				notifySafely(ctx, "The selected /btw side thread is no longer available", "warning");
+				return;
+			}
+			const startingTurnCount = state?.thread.turns.length ?? 0;
+
+			try {
+				await runFullscreen(ctx, (fullscreenCtx) => {
+					if (!state) {
+						const createdAt = Date.now();
+						state = {
+							id: `btw-${nextThreadNumber}`,
+							thread: createSideThread(
+								buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
+							),
+							thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
+							createdAt,
+							updatedAt: createdAt,
+						};
+						nextThreadNumber += 1;
+					}
+					return runThread({
+						initialQuestion: question || undefined,
+						selected: resolution.selected,
+						thinkingLevel: state.thinkingLevel,
+						rememberThinkingLevelChanges: effectiveRememberThinkingLevelChanges(settings),
+						state,
+						ctx: fullscreenCtx,
+					});
+				});
+			} finally {
+				if (state?.title && state.thread.turns.length > 0) {
+					if (state.thread.turns.length > startingTurnCount) {
+						resumableThreads.delete(state.id);
+					}
+					resumableThreads.set(state.id, state);
+				}
+			}
 		},
 	});
 }
@@ -255,6 +322,7 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 async function showCommandMenuForBtw(
 	pi: ExtensionAPI,
 	ctx: ExtensionCommandContext,
+	resumeThreads: readonly BtwResumeThreadSummary[],
 ): Promise<BtwCommandMenuResult> {
 	const currentModel = ctx.model;
 	const availableModels = ctx.modelRegistry.getAll();
@@ -271,6 +339,7 @@ async function showCommandMenuForBtw(
 	return showBtwCommandMenu(ctx, {
 		currentThinkingLevel,
 		availableThinkingLevels: model ? getSupportedThinkingLevels(model) : BTW_THINKING_LEVELS,
+		resumeThreads,
 	});
 }
 
@@ -330,12 +399,19 @@ interface RunBtwThreadDependencies {
 	chooseBringToMain?: typeof chooseBringToMain;
 	deliverBringToMain?: typeof loadBringToMainDraft;
 	persistThinkingLevel?: (level: BtwThinkingLevel) => Promise<unknown>;
+	now?: () => number;
 }
 
 export type BtwThreadResult = { kind: "closed" };
 
 type BtwThreadThinkingControl = Omit<BtwThinkingControl, "keybindings">;
 
+interface BtwThreadSteeringControl {
+	questions: readonly string[];
+	submit: (question: string) => void;
+	thinking: BtwThreadThinkingControl;
+}
+
 type BtwBringToMainChoice =
 	| BtwThreadResult
 	| {
@@ -354,6 +430,7 @@ interface RunBtwThreadOptions {
 	thinkingLevel: BtwThinkingLevel;
 	rememberThinkingLevelChanges?: boolean;
 	settingsPath?: string;
+	state?: BtwThreadState;
 	ctx: ExtensionCommandContext;
 	dependencies?: RunBtwThreadDependencies;
 }
@@ -364,6 +441,7 @@ export async function runBtwThread({
 	thinkingLevel,
 	rememberThinkingLevelChanges = false,
 	settingsPath,
+	state,
 	ctx,
 	dependencies = {},
 }: RunBtwThreadOptions): Promise<BtwThreadResult> {
@@ -374,44 +452,52 @@ export async function runBtwThread({
 	const persistThinkingLevel =
 		dependencies.persistThinkingLevel ??
 		((level: BtwThinkingLevel) => updateBtwSettings({ thinkingLevel: level }, { settingsPath }));
-	const thread = createSideThread(buildConversationContext(ctx.sessionManager.getBranch()));
+	const now = dependencies.now ?? Date.now;
+	const thread =
+		state?.thread ?? createSideThread(buildConversationContext(ctx.sessionManager.getBranch()));
 	const thinkingLevels = getSupportedThinkingLevels(selected.model);
 	const pendingWrites = new Set<Promise<void>>();
-	let activeThinkingLevel = clampThinkingLevel(selected.model, thinkingLevel);
+	const steeringQuestions: string[] = [];
+	let activeThinkingLevel = clampThinkingLevel(
+		selected.model,
+		state?.thinkingLevel ?? thinkingLevel,
+	);
+	if (state) state.thinkingLevel = activeThinkingLevel;
 	let pendingQuestion = initialQuestion;
 	let composerDraft: string | undefined;
+	const createThinkingControl = (): BtwThreadThinkingControl => ({
+		level: activeThinkingLevel,
+		levels: thinkingLevels,
+		onChange: (level) => {
+			if (!thinkingLevels.includes(level)) return;
+			activeThinkingLevel = level;
+			if (state) state.thinkingLevel = level;
+			if (!rememberThinkingLevelChanges) return;
+			let write!: Promise<void>;
+			write = Promise.resolve()
+				.then(() => persistThinkingLevel(level))
+				.then(() => undefined)
+				.catch((error: unknown) => {
+					notifySafely(
+						ctx,
+						`Thinking level changed to ${level}, but could not be remembered in pi-btw.json: ${formatError(error)}`,
+						"warning",
+					);
+				})
+				.finally(() => pendingWrites.delete(write));
+			pendingWrites.add(write);
+		},
+	});
 
 	try {
 		while (true) {
 			if (!pendingQuestion) {
-				const thinking: BtwThreadThinkingControl = {
-					level: activeThinkingLevel,
-					levels: thinkingLevels,
-					onChange: (level) => {
-						if (!thinkingLevels.includes(level)) return;
-						activeThinkingLevel = level;
-						if (!rememberThinkingLevelChanges) return;
-						let write!: Promise<void>;
-						write = Promise.resolve()
-							.then(() => persistThinkingLevel(level))
-							.then(() => undefined)
-							.catch((error: unknown) => {
-								notifySafely(
-									ctx,
-									`Thinking level changed to ${level}, but could not be remembered in pi-btw.json: ${formatError(error)}`,
-									"warning",
-								);
-							})
-							.finally(() => pendingWrites.delete(write));
-						pendingWrites.add(write);
-					},
-				};
 				const action = await interact(
 					thread,
 					thread.turns.length > 0,
 					ctx,
 					composerDraft,
-					thinking,
+					createThinkingControl(),
 				);
 				if (action.kind === "close") return { kind: "closed" };
 				if (action.kind === "bringToMain") {
@@ -430,7 +516,11 @@ export async function runBtwThread({
 				pendingQuestion = action.question;
 			}
 
-			const result = await ask(thread, pendingQuestion, selected, activeThinkingLevel, ctx);
+			const result = await ask(thread, pendingQuestion, selected, activeThinkingLevel, ctx, {
+				questions: steeringQuestions,
+				submit: (question) => steeringQuestions.push(question),
+				thinking: createThinkingControl(),
+			});
 			if (result.kind === "aborted") {
 				notifySafely(ctx, "Cancelled", "info");
 				return { kind: "closed" };
@@ -442,8 +532,12 @@ export async function runBtwThread({
 					answer: result.message,
 				});
 			}
+			if (state) {
+				state.title ||= sanitizeSingleLine(pendingQuestion) || "Untitled side thread";
+				state.updatedAt = now();
+			}
 
-			pendingQuestion = undefined;
+			pendingQuestion = steeringQuestions.shift();
 		}
 	} finally {
 		await Promise.allSettled([...pendingWrites]);
@@ -766,9 +860,10 @@ async function askThreadQuestion(
 	selected: ResolvedBtwModel,
 	thinkingLevel: BtwThinkingLevel,
 	ctx: ExtensionCommandContext,
+	steering: BtwThreadSteeringControl,
 ) {
 	return ctx.ui.custom<Awaited<ReturnType<typeof completeSideThreadTurn>>>(
-		(tui, theme, _keybindings, done) => {
+		(tui, theme, keybindings, done) => {
 			let settled = false;
 			const view = new BtwAnsweringView(
 				tui,
@@ -781,6 +876,13 @@ async function askThreadQuestion(
 					done({ kind: "aborted" });
 				},
 				thinkingLevel,
+				{
+					steering: {
+						questions: steering.questions,
+						onSubmit: steering.submit,
+						thinking: { ...steering.thinking, keybindings },
+					},
+				},
 			);
 			completeSideThreadTurn({
 				thread,

package/src/fullscreen-ui.ts

@@ -0,0 +1,339 @@
+import { spawn } from "node:child_process";
+import type {
+	ExtensionCommandContext,
+	KeybindingsManager,
+	Theme,
+} from "@earendil-works/pi-coding-agent";
+import {
+	type Component,
+	type OverlayHandle,
+	type TUI,
+	TuiAltScreen,
+	truncateToWidth,
+} from "@earendil-works/pi-tui";
+import { sanitizeSingleLine } from "./text.js";
+
+type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
+type BtwCustomFactory<T> = (
+	tui: TUI,
+	theme: Theme,
+	keybindings: KeybindingsManager,
+	done: (result: T) => void,
+) => (Component & { dispose?(): void }) | Promise<Component & { dispose?(): void }>;
+
+type BtwFullscreenTui = TUI & { flash?: (message: string, durationMs?: number) => void };
+
+export type BtwFullscreenTuiFactory = (parent: TUI) => BtwFullscreenTui;
+
+export interface BtwFullscreenDependencies {
+	createTui?: BtwFullscreenTuiFactory;
+	openUrl?: (url: string) => void;
+}
+
+export type RunBtwFullscreen = <T>(
+	ctx: ExtensionCommandContext,
+	run: (ctx: ExtensionCommandContext) => Promise<T>,
+) => Promise<T>;
+
+type FullscreenOutcome<T> = { kind: "completed"; value: T } | { kind: "failed"; error: unknown };
+
+class FullscreenUiDisposedError extends Error {
+	constructor() {
+		super("The dedicated pi-btw UI was disposed.");
+		this.name = "FullscreenUiDisposedError";
+	}
+}
+
+export async function runBtwFullscreen<T>(
+	ctx: ExtensionCommandContext,
+	run: (ctx: ExtensionCommandContext) => Promise<T>,
+	dependencies: BtwFullscreenDependencies = {},
+): Promise<T> {
+	const createTui =
+		dependencies.createTui ??
+		((parent: TUI) => createBtwFullscreenTui(parent, dependencies.openUrl ?? openUrlInBrowser));
+	let liveEditorText = ctx.ui.getEditorText();
+	let restoreEditor = false;
+	const outcome = await ctx.ui.custom<FullscreenOutcome<T>>(
+		(parent, theme, keybindings, done) =>
+			new BtwFullscreenHost(
+				parent,
+				theme,
+				keybindings,
+				ctx,
+				run,
+				(value) => {
+					try {
+						liveEditorText = ctx.ui.getEditorText();
+						restoreEditor = true;
+					} catch {
+						// A replaced session owns a different editor and must not receive stale text.
+					}
+					done(value);
+				},
+				createTui,
+			),
+	);
+	if (restoreEditor) {
+		try {
+			if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
+		} catch {
+			// A replaced session owns a different editor and must not receive stale restoration.
+		}
+	}
+	if (outcome.kind === "failed") throw outcome.error;
+	return outcome.value;
+}
+
+function createBtwFullscreenTui(parent: TUI, openUrl: (url: string) => void): BtwFullscreenTui {
+	return new TuiAltScreen(parent.terminal, parent.getShowHardwareCursor(), undefined, {
+		mouse: true,
+		openUrl,
+	});
+}
+
+// Pi does not export its browser opener, so mirror its shell-free launcher for this isolated TUI.
+function openUrlInBrowser(target: string): void {
+	const [command, args] =
+		process.platform === "darwin"
+			? ["open", [target]]
+			: process.platform === "win32"
+				? ["rundll32", ["url.dll,FileProtocolHandler", target]]
+				: ["xdg-open", [target]];
+	spawn(command, args, { stdio: "ignore", detached: true })
+		.on("error", () => {})
+		.unref();
+}
+
+class BtwFullscreenHost<T> implements Component {
+	private fullscreen: BtwFullscreenTui | undefined;
+	private cancelActiveCustom: (() => void) | undefined;
+	private started = false;
+	private disposed = false;
+	private finished = false;
+
+	constructor(
+		private readonly parent: TUI,
+		private readonly theme: Theme,
+		private readonly keybindings: KeybindingsManager,
+		private readonly ctx: ExtensionCommandContext,
+		private readonly run: (ctx: ExtensionCommandContext) => Promise<T>,
+		private readonly done: (outcome: FullscreenOutcome<T>) => void,
+		private readonly createTui: BtwFullscreenTuiFactory,
+	) {
+		queueMicrotask(() => void this.start());
+	}
+
+	render(width: number): string[] {
+		return [truncateToWidth(this.theme.fg("muted", "Opening btw side thread…"), width)];
+	}
+
+	invalidate(): void {}
+
+	dispose(): void {
+		if (this.disposed || this.finished) return;
+		this.disposed = true;
+		this.cancelActiveCustom?.();
+	}
+
+	private async start(): Promise<void> {
+		if (this.started || this.finished) return;
+		this.started = true;
+		let outcome: FullscreenOutcome<T>;
+		let parentStopped = false;
+		let fullscreenCreated = false;
+		try {
+			if (this.disposed) throw new FullscreenUiDisposedError();
+			this.parent.stop({ preserveScreen: true });
+			parentStopped = true;
+			if (this.disposed) throw new FullscreenUiDisposedError();
+			this.fullscreen = this.createTui(this.parent);
+			fullscreenCreated = true;
+			this.fullscreen.start();
+			outcome = { kind: "completed", value: await this.run(this.createContext()) };
+		} catch (error) {
+			outcome = { kind: "failed", error };
+		}
+
+		let cleanupError: unknown;
+		try {
+			this.cancelActiveCustom?.();
+		} catch (error) {
+			cleanupError = error;
+		}
+		if (fullscreenCreated) {
+			try {
+				this.fullscreen?.stop({ preserveScreen: true });
+			} catch (error) {
+				cleanupError ??= error;
+			}
+		}
+		if (parentStopped) {
+			try {
+				this.parent.start();
+				this.parent.renderNow(false);
+			} catch (error) {
+				cleanupError ??= error;
+			}
+		}
+		if (cleanupError !== undefined) outcome = { kind: "failed", error: cleanupError };
+		this.finished = true;
+		this.done(outcome);
+	}
+
+	private createContext(): ExtensionCommandContext {
+		const ui = new Proxy(this.ctx.ui, {
+			get: (target, property) => {
+				if (property === "custom") {
+					return <Value>(factory: BtwCustomFactory<Value>, options?: BtwCustomOptions) =>
+						this.showCustom(factory, options);
+				}
+				if (property === "notify") {
+					return (
+						message: string,
+						level?: Parameters<ExtensionCommandContext["ui"]["notify"]>[1],
+					) => {
+						target.notify(message, level);
+						const display = sanitizeSingleLine(message);
+						if (display) this.fullscreen?.flash?.(display);
+					};
+				}
+				const value = Reflect.get(target, property, target) as unknown;
+				return typeof value === "function" ? value.bind(target) : value;
+			},
+		});
+		return new Proxy(this.ctx, {
+			get: (target, property) => (property === "ui" ? ui : Reflect.get(target, property, target)),
+		});
+	}
+
+	private showCustom<Value>(
+		factory: BtwCustomFactory<Value>,
+		options?: BtwCustomOptions,
+	): Promise<Value> {
+		const fullscreen = this.fullscreen;
+		if (!fullscreen || this.disposed || this.finished) {
+			return Promise.reject(new FullscreenUiDisposedError());
+		}
+		if (this.cancelActiveCustom) {
+			return Promise.reject(new Error("pi-btw attempted to open overlapping custom UI."));
+		}
+
+		return new Promise<Value>((resolve, reject) => {
+			let component: (Component & { dispose?(): void }) | undefined;
+			let overlay: OverlayHandle | undefined;
+			let mounted = false;
+			let factorySettled = false;
+			let closed = false;
+			let promiseSettled = false;
+			let componentDisposed = false;
+			let pendingValue: Value | undefined;
+			let hasPendingValue = false;
+
+			const disposeComponent = () => {
+				if (!component || componentDisposed) return;
+				componentDisposed = true;
+				try {
+					component.dispose?.();
+				} catch {
+					// Cleanup must continue so terminal ownership is restored.
+				}
+			};
+			const unmount = () => {
+				let cleanupError: unknown;
+				try {
+					if (overlay) overlay.hide();
+					else if (mounted && component) fullscreen.removeChild(component);
+				} catch (error) {
+					cleanupError = error;
+				}
+				if (overlay || mounted) {
+					try {
+						fullscreen.setFocus(null);
+						fullscreen.requestRender();
+					} catch (error) {
+						cleanupError ??= error;
+					}
+				}
+				disposeComponent();
+				if (cleanupError !== undefined) throw cleanupError;
+			};
+			const complete = () => {
+				if (promiseSettled || !hasPendingValue) return;
+				promiseSettled = true;
+				this.cancelActiveCustom = undefined;
+				if (!factorySettled) {
+					resolve(pendingValue as Value);
+					return;
+				}
+				try {
+					unmount();
+					resolve(pendingValue as Value);
+				} catch (error) {
+					reject(error);
+				}
+			};
+			const close = (value: Value) => {
+				if (closed || promiseSettled) return;
+				closed = true;
+				pendingValue = value;
+				hasPendingValue = true;
+				complete();
+			};
+			const fail = (error: unknown) => {
+				if (promiseSettled) return;
+				closed = true;
+				promiseSettled = true;
+				this.cancelActiveCustom = undefined;
+				try {
+					unmount();
+					reject(error);
+				} catch (cleanupError) {
+					reject(cleanupError);
+				}
+			};
+			this.cancelActiveCustom = () => {
+				if (promiseSettled) return;
+				disposeComponent();
+				if (!promiseSettled) fail(new FullscreenUiDisposedError());
+			};
+
+			let created: ReturnType<BtwCustomFactory<Value>>;
+			try {
+				created = factory(fullscreen, this.theme, this.keybindings, close);
+			} catch (error) {
+				factorySettled = true;
+				fail(error);
+				return;
+			}
+			Promise.resolve(created)
+				.then((value) => {
+					component = value;
+					factorySettled = true;
+					if (promiseSettled) {
+						disposeComponent();
+						return;
+					}
+					if (closed) {
+						complete();
+						return;
+					}
+					if (options?.overlay) {
+						const overlayOptions =
+							typeof options.overlayOptions === "function"
+								? options.overlayOptions()
+								: options.overlayOptions;
+						overlay = fullscreen.showOverlay(component, overlayOptions);
+						options.onHandle?.(overlay);
+					} else {
+						fullscreen.clear();
+						fullscreen.addChild(component);
+						mounted = true;
+						fullscreen.setFocus(component);
+						fullscreen.requestRender();
+					}
+				})
+				.catch(fail);
+		});
+	}
+}

package/src/menu.ts

@@ -22,9 +22,16 @@ interface BtwMenuState {
 	reason?: string;
 }
 
+export interface BtwResumeThreadSummary {
+	id: string;
+	title: string;
+	questionCount: number;
+}
+
 export interface ShowBtwCommandMenuOptions {
 	currentThinkingLevel: BtwThinkingLevel;
 	availableThinkingLevels: readonly BtwThinkingLevel[];
+	resumeThreads?: readonly BtwResumeThreadSummary[];
 	settingsPath?: string;
 	readSettings?: typeof readBtwSettings;
 	updateSettings?: (
@@ -33,10 +40,10 @@ export interface ShowBtwCommandMenuOptions {
 	) => Promise<BtwSettings>;
 }
 
-export type BtwCommandMenuResult = "start" | "closed";
+export type BtwCommandMenuResult = "start" | "closed" | { kind: "resume"; threadId: string };
 
-type BtwMenuScreen = "main" | "settings" | "invalid";
-type BtwMenuAction = "start" | "set-thinking" | "set-remember";
+type BtwMenuScreen = "main" | "resume" | "settings" | "invalid";
+type BtwMenuAction = "start" | "resume" | "set-thinking" | "set-remember";
 type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
 
 type BtwCustomFactory<T> = (
@@ -61,7 +68,9 @@ export async function showBtwCommandMenu(
 			? [...options.availableThinkingLevels]
 			: (["off"] satisfies BtwThinkingLevel[]);
 	const displaySettingsPath = sanitizeSingleLine(settingsPath);
+	const resumeThreads = options.resumeThreads ?? [];
 	let startSelected = false;
+	let resumedThreadId: string | undefined;
 
 	const loadState = async (): Promise<BtwMenuState> => {
 		const loaded = await readSettings(settingsPath);
@@ -89,6 +98,16 @@ export async function showBtwCommandMenu(
 						description: "Open an empty side thread",
 						action: "start",
 					},
+					...(resumeThreads.length > 0
+						? [
+								{
+									id: "resume" as const,
+									label: "Resume side thread",
+									description: "Continue an in-memory side thread",
+									to: "resume" as const,
+								},
+							]
+						: []),
 					{
 						id: "settings",
 						label: "Settings",
@@ -98,6 +117,18 @@ export async function showBtwCommandMenu(
 				],
 				hint: "close",
 			}),
+			resume: () => ({
+				kind: "choice",
+				title: "Resume BTW side thread",
+				items: resumeThreads.map((thread) => ({
+					id: thread.id,
+					label: thread.title,
+					description: `${thread.questionCount} ${thread.questionCount === 1 ? "question" : "questions"}`,
+				})),
+				action: "resume",
+				viewportSize: 10,
+				hint: "back",
+			}),
 			settings: ({ state }) => ({
 				kind: "settings",
 				title: "Pi BTW Settings",
@@ -136,6 +167,13 @@ export async function showBtwCommandMenu(
 				startSelected = true;
 				return { kind: "close" };
 			},
+			resume: async ({ itemId }: { itemId: string }) => {
+				if (!resumeThreads.some((thread) => thread.id === itemId)) {
+					return { kind: "rejected" } as const;
+				}
+				resumedThreadId = itemId;
+				return { kind: "close" } as const;
+			},
 			"set-thinking": async ({ value, signal }) => {
 				if (!value || !levels.includes(value as BtwThinkingLevel)) return { kind: "rejected" };
 				try {
@@ -172,9 +210,9 @@ export async function showBtwCommandMenu(
 	const result = await runBtwMenuPreservingEditor(ctx, (menuContext) =>
 		runMenu(menuContext, menu, { getState: loadState }),
 	);
-	return startSelected && result.kind === "closed" && result.reason === "close"
-		? "start"
-		: "closed";
+	if (result.kind !== "closed" || result.reason !== "close") return "closed";
+	if (resumedThreadId) return { kind: "resume", threadId: resumedThreadId };
+	return startSelected ? "start" : "closed";
 }
 
 export async function runBtwMenuPreservingEditor(

package/src/side-thread.ts

@@ -103,26 +103,30 @@ export async function completeSideThreadTurn({
 	completeSimple,
 }: CompleteSideThreadTurnOptions): Promise<CompleteSideThreadTurnResult> {
 	if (signal?.aborted) return { kind: "aborted" };
-	let response: AssistantMessage;
 	try {
-		response = await completeSimple(
+		const response = await completeSimple(
 			model,
 			{ systemPrompt: SYSTEM_PROMPT, messages: buildSideThreadMessages(thread, question) },
 			buildStreamOptions(auth, thinkingLevel, signal),
 		);
+		if (signal?.aborted || response?.stopReason === "aborted") return { kind: "aborted" };
+		if (!isAssistantMessage(response)) {
+			return { kind: "error", message: "The side model returned a malformed response." };
+		}
+		if (response.stopReason === "error") {
+			return {
+				kind: "error",
+				message: response.errorMessage ?? "The side model returned an error.",
+			};
+		}
+
+		const answer = extractAssistantText(response) || "No response received.";
+		thread.turns.push({ kind: "answered", question, answer, response });
+		return { kind: "answered", response, answer };
 	} catch (error: unknown) {
 		if (signal?.aborted) return { kind: "aborted" };
 		return { kind: "error", message: formatError(error) };
 	}
-
-	if (signal?.aborted || response.stopReason === "aborted") return { kind: "aborted" };
-	if (response.stopReason === "error") {
-		return { kind: "error", message: response.errorMessage ?? "The side model returned an error." };
-	}
-
-	const answer = extractAssistantText(response) || "No response received.";
-	thread.turns.push({ kind: "answered", question, answer, response });
-	return { kind: "answered", response, answer };
 }
 
 export interface CompleteSideQuestionOptions {
@@ -156,12 +160,28 @@ export async function completeSideQuestion({
 
 export function extractAssistantText(response: AssistantMessage): string {
 	return response.content
-		.filter((content): content is { type: "text"; text: string } => content.type === "text")
+		.filter(
+			(content): content is { type: "text"; text: string } =>
+				content !== null &&
+				typeof content === "object" &&
+				content.type === "text" &&
+				typeof content.text === "string",
+		)
 		.map((content) => content.text)
 		.join("\n")
 		.trim();
 }
 
+function isAssistantMessage(value: unknown): value is AssistantMessage {
+	if (value === null || typeof value !== "object") return false;
+	const candidate = value as Partial<AssistantMessage>;
+	return (
+		candidate.role === "assistant" &&
+		Array.isArray(candidate.content) &&
+		typeof candidate.stopReason === "string"
+	);
+}
+
 export function buildUserPrompt(question: string, conversationContext: string): string {
 	return [
 		"Answer this side question without modifying the main conversation.",

package/src/transcript-pager.ts

@@ -11,6 +11,7 @@ import {
 	CURSOR_MARKER,
 	Editor,
 	type EditorTheme,
+	type Focusable,
 	Key,
 	Loader,
 	Markdown,
@@ -23,6 +24,7 @@ import type { BtwThinkingLevel, SideThreadTurn } from "./side-thread.js";
 import { sanitizeSingleLine } from "./text.js";
 
 const TRANSCRIPT_CHROME_LINES = 2;
+const MAX_STEERING_DISPLAY_LINES = 3;
 const OSC133_MARKERS = ["\u001b]133;A\u0007", "\u001b]133;B\u0007", "\u001b]133;C\u0007"];
 // Pi renders a spacer above the custom component and a two-line built-in footer below it.
 const RESERVED_APP_LINES = 3;
@@ -39,7 +41,15 @@ export interface BtwThinkingControl {
 	onChange: (level: BtwThinkingLevel) => void;
 }
 
-export class BtwTranscriptPager implements Component {
+export interface BtwAnsweringViewOptions {
+	steering?: {
+		questions: readonly string[];
+		onSubmit: (question: string) => void;
+		thinking?: BtwThinkingControl;
+	};
+}
+
+export class BtwTranscriptPager implements Component, Focusable {
 	private readonly transcriptComponents: Component[];
 	private readonly editor: Editor;
 	private readonly canBringToMain: boolean;
@@ -242,15 +252,19 @@ export class BtwTranscriptPager implements Component {
 	}
 }
 
-export class BtwAnsweringView implements Component {
+export class BtwAnsweringView implements Component, Focusable {
 	private readonly transcriptComponents: Component[];
 	private readonly loader: Loader;
+	private readonly editor: Editor | undefined;
 	private readonly controller = new AbortController();
 	private scrollOffset = 0;
 	private lastContentLineCount = 0;
 	private lastViewportHeight = 1;
 	private followBottom = true;
+	private warning: string | undefined;
 	private finished = false;
+	private isFocused = false;
+	private thinkingLevel: BtwThinkingLevel | undefined;
 
 	constructor(
 		private readonly tui: TUI,
@@ -258,15 +272,51 @@ export class BtwAnsweringView implements Component {
 		turns: readonly SideThreadTurn[],
 		pendingQuestion: string,
 		private readonly onCancel: () => void,
-		private readonly thinkingLevel?: BtwThinkingLevel,
+		thinkingLevel?: BtwThinkingLevel,
+		private readonly options: BtwAnsweringViewOptions = {},
 	) {
 		this.transcriptComponents = buildTranscriptComponents(turns, this.theme, pendingQuestion);
+		this.thinkingLevel = options.steering?.thinking?.level ?? thinkingLevel;
 		this.loader = new Loader(
 			this.tui,
 			(text) => this.theme.fg("accent", text),
 			(text) => this.theme.fg("muted", text),
 			"Answering…",
 		);
+		if (options.steering) {
+			const editorTheme: EditorTheme = {
+				borderColor: (text) => this.theme.fg("accent", text),
+				selectList: {
+					selectedPrefix: (text) => this.theme.fg("accent", text),
+					selectedText: (text) => this.theme.fg("accent", text),
+					description: (text) => this.theme.fg("muted", text),
+					scrollInfo: (text) => this.theme.fg("dim", text),
+					noMatch: (text) => this.theme.fg("warning", text),
+				},
+			};
+			this.editor = new Editor(this.tui, editorTheme);
+			this.editor.onChange = () => {
+				this.warning = undefined;
+			};
+			this.editor.onSubmit = (text) => {
+				const question = text.trim();
+				if (!question) {
+					this.warning = "Question cannot be empty";
+					return;
+				}
+				options.steering?.onSubmit(question);
+				this.warning = undefined;
+			};
+		}
+	}
+
+	get focused(): boolean {
+		return this.isFocused;
+	}
+
+	set focused(value: boolean) {
+		this.isFocused = value;
+		if (this.editor) this.editor.focused = value;
 	}
 
 	get signal(): AbortSignal {
@@ -276,21 +326,35 @@ export class BtwAnsweringView implements Component {
 	render(width: number): string[] {
 		const safeWidth = Math.max(1, width);
 		const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_LINES);
-		const viewportHeight = Math.max(0, availableRows - TRANSCRIPT_CHROME_LINES);
+		const editorLines = this.editor?.render(safeWidth) ?? [];
+		const steeringCapacity = Math.max(
+			0,
+			availableRows - editorLines.length - TRANSCRIPT_CHROME_LINES,
+		);
+		const steeringLines = renderSteeringLines(
+			this.options.steering?.questions ?? [],
+			safeWidth,
+			this.theme,
+			Math.min(MAX_STEERING_DISPLAY_LINES, steeringCapacity),
+		);
+		const viewportHeight = Math.max(
+			0,
+			availableRows - editorLines.length - TRANSCRIPT_CHROME_LINES - steeringLines.length,
+		);
 		const contentLines = renderTranscriptLines(this.transcriptComponents, safeWidth);
 		this.lastContentLineCount = contentLines.length;
 		this.lastViewportHeight = viewportHeight;
 		if (this.followBottom) this.scrollOffset = this.getMaxScrollOffset();
 		this.clampScrollOffset();
-		const cancelHint = safeWidth < 28 ? "Ctrl+C" : "Ctrl+C cancel";
-		const loaderWidth = Math.max(1, safeWidth - visibleWidth(cancelHint) - 3);
-		const loaderLine = this.loader.render(loaderWidth).at(-1) ?? "Answering…";
-		const lines = [
+
+		return fitComposerLayout(
 			renderSideThreadHeader(safeWidth, this.theme, this.thinkingLevel),
-			...contentLines.slice(this.scrollOffset, this.scrollOffset + viewportHeight),
-			truncateToWidth(`${loaderLine} • ${this.theme.fg("muted", cancelHint)}`, safeWidth),
-		];
-		return fitWithFixedHeader(lines, availableRows);
+			contentLines.slice(this.scrollOffset, this.scrollOffset + viewportHeight),
+			this.renderFooter(safeWidth),
+			editorLines,
+			availableRows,
+			steeringLines,
+		);
 	}
 
 	handleInput(data: string): void {
@@ -302,21 +366,43 @@ export class BtwAnsweringView implements Component {
 			this.onCancel();
 			return;
 		}
+		const thinking = this.options.steering?.thinking;
+		if (
+			thinking &&
+			thinking.levels.length > 1 &&
+			thinking.keybindings.matches(data, "app.thinking.cycle")
+		) {
+			const currentIndex = thinking.levels.indexOf(this.thinkingLevel ?? thinking.level);
+			const nextLevel = thinking.levels[(currentIndex + 1) % thinking.levels.length];
+			if (nextLevel) {
+				this.thinkingLevel = nextLevel;
+				thinking.onChange(nextLevel);
+				this.warning = undefined;
+				this.tui.requestRender();
+			}
+			return;
+		}
 		if (matchesKey(data, Key.pageUp)) {
 			const previousOffset = this.scrollOffset;
 			this.scrollBy(-this.lastViewportHeight);
 			if (this.scrollOffset < previousOffset) this.followBottom = false;
 			this.tui.requestRender();
-		} else if (matchesKey(data, Key.pageDown)) {
+			return;
+		}
+		if (matchesKey(data, Key.pageDown)) {
 			this.scrollBy(this.lastViewportHeight);
 			this.followBottom = this.scrollOffset >= this.getMaxScrollOffset();
 			this.tui.requestRender();
+			return;
 		}
+		this.editor?.handleInput(data);
+		this.tui.requestRender();
 	}
 
 	invalidate(): void {
 		for (const component of this.transcriptComponents) component.invalidate();
 		this.loader.invalidate();
+		this.editor?.invalidate();
 	}
 
 	finish(): void {
@@ -336,6 +422,26 @@ export class BtwAnsweringView implements Component {
 		this.onCancel();
 	}
 
+	private renderFooter(width: number): string {
+		if (this.warning) {
+			const warning = width < 32 ? "Empty • Ctrl+C" : `${this.warning} • Ctrl+C cancel`;
+			return truncateToWidth(this.theme.fg("warning", warning), width);
+		}
+		const baseHint = this.editor ? "Enter steer • Ctrl+C cancel" : "Ctrl+C cancel";
+		const thinking = this.options.steering?.thinking;
+		const cycleHint =
+			thinking && thinking.levels.length > 1 && this.thinkingLevel
+				? ` • thinking ${this.thinkingLevel} • ${thinkingKeyLabel(thinking.keybindings)} cycle`
+				: "";
+		const scrollHint = this.getMaxScrollOffset() > 0 ? " • PgUp/PgDn history" : "";
+		const hints = `${baseHint}${cycleHint}${scrollHint}`;
+		const compactHints = this.editor ? "Enter • Ctrl+C" : "Ctrl+C";
+		const selectedHints = visibleWidth(hints) <= width ? hints : compactHints;
+		const loaderWidth = Math.max(1, width - visibleWidth(selectedHints) - 3);
+		const loaderLine = this.loader.render(loaderWidth).at(-1) ?? "Answering…";
+		return truncateToWidth(`${loaderLine} • ${this.theme.fg("muted", selectedHints)}`, width);
+	}
+
 	private scrollBy(delta: number): void {
 		this.scrollOffset += delta;
 		this.clampScrollOffset();
@@ -439,8 +545,9 @@ function fitComposerLayout(
 	footer: string,
 	editorLines: string[],
 	availableRows: number,
+	statusLines: string[] = [],
 ): string[] {
-	const lines = [header, ...contentLines, footer, ...editorLines];
+	const lines = [header, ...contentLines, ...statusLines, footer, ...editorLines];
 	if (lines.length <= availableRows) return lines;
 	if (availableRows <= 1) return [header];
 	const editorBudget = Math.max(0, availableRows - 2);
@@ -456,10 +563,42 @@ function fitEditorLines(editorLines: string[], budget: number): string[] {
 	return editorLines.slice(start, start + budget);
 }
 
-function fitWithFixedHeader(lines: string[], availableRows: number): string[] {
-	if (lines.length <= availableRows) return lines;
-	if (availableRows <= 1) return lines.slice(0, 1);
-	return [lines[0] ?? "", ...lines.slice(lines.length - availableRows + 1)];
+function renderSteeringLines(
+	questions: readonly string[],
+	width: number,
+	theme: Theme,
+	maxLines: number,
+): string[] {
+	if (questions.length === 0 || maxLines <= 0) return [];
+	const formatQuestion = (question: string) =>
+		sanitizeSingleLine(question) || "(non-printing message)";
+	if (maxLines === 1 && questions.length > 1) {
+		return [
+			truncateToWidth(
+				theme.fg(
+					"dim",
+					`Steering (+${questions.length - 1} more): ${formatQuestion(questions[0] ?? "")}`,
+				),
+				width,
+			),
+		];
+	}
+	const hasOverflow = questions.length > maxLines;
+	const questionLimit = hasOverflow ? Math.max(1, maxLines - 1) : maxLines;
+	const lines = questions
+		.slice(0, questionLimit)
+		.map((question) =>
+			truncateToWidth(theme.fg("dim", `Steering: ${formatQuestion(question)}`), width),
+		);
+	if (hasOverflow) {
+		lines.push(
+			truncateToWidth(
+				theme.fg("dim", `Steering: … +${questions.length - questionLimit} more`),
+				width,
+			),
+		);
+	}
+	return lines;
 }
 
 function stripShellIntegrationMarkers(line: string): string {