one-code-extension 0.3.1 → 0.4.0

package/extensions/bash/index.ts

@@ -6,39 +6,24 @@
  * is how pi's official sandbox example does it too. The foreground path
  * delegates to pi's real executor (`createBashToolDefinition`) so upstream
  * bash behavior — timeout handling, truncation, PI_* env, spawn hooks — stays
- * exactly pi's; this file only adds the background branch.
- *
- * A background run spawns detached, returns a task id immediately, spools
- * output to `<sessionDir>/bash/<taskId>/output.log`, registers on the shared
- * background registry (task_output/task_stop just work — they are
- * kind-agnostic), and announces completion as a steered system notification
- * (lib/notifications.ts). The permission gate and auto-mode classifier run before
- * execute like any bash call — a background command is NOT auto-allowed, and
- * the gate fires before anything detaches.
+ * exactly pi's; the shared body in lib/shell-tool.ts adds the background
+ * branch (spool to `<sessionDir>/bash/<taskId>/output.log`, the shared
+ * background registry, a steered completion notification), and this file only
+ * supplies what is bash's: pi's definition, the bash the session resolved
+ * (lib/shell-spawn.ts — Git Bash on Windows, `CLAUDE_CODE_GIT_BASH_PATH`
+ * honoured), the CC-shaped description and the bash guards. The permission
+ * gate and auto-mode classifier run before execute like any bash call — a
+ * background command is NOT auto-allowed, and the gate fires before anything
+ * detaches.
  */
 
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createBashToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { generateTaskId, TASK_REGISTER_CHANNEL } from "../background/registry.ts";
-import { type BashFinishSummary, runBackgroundBashBlocking, startBackgroundBash, tailCap } from "./background.ts";
-import { bashGuardReason } from "./guards.ts";
-import { commandToEvaluate, trackOriginalCommands } from "../lib/original-command.ts";
-import { createTaskNotifier, oneShotNote, sessionOutlivesTurn, systemNotification } from "../lib/notifications.ts";
-import { persistIfLarge, sessionResultsDir } from "../lib/persisted-output.ts";
 import { perCwd } from "../lib/per-cwd.ts";
-import { ccWrapBuiltinRenderers, linesComponent, resultLines } from "../lib/tui-render.ts";
-
-// The completion notification carries status + exit code + where the output is,
-// plus only a short tail: a finished build used to push 30 KB (~8k tokens) into
-// context unasked (review T7). The full tail stays behind task_output / the log.
-const NOTIFY_OUTPUT_CAP = 2_000;
-/** One-shot modes return the whole output in the result; past this it is persisted (file + preview), never cut. */
-const ONE_SHOT_OUTPUT_CAP = 30_000;
-/** Claude Code's Bash cap; the tool's `timeout` is milliseconds, as CC's is. */
-const MAX_TIMEOUT_MS = 600_000;
+import { bashSpawn } from "../lib/shell-spawn.ts";
+import { registerShellTool } from "../lib/shell-tool.ts";
+import { bashGuardReason } from "./guards.ts";
 
 const BashParams = Type.Object({
 	command: Type.String({ description: "Bash command to execute" }),
@@ -46,7 +31,7 @@ const BashParams = Type.Object({
 	run_in_background: Type.Optional(
 		Type.Boolean({
 			description:
-				"Run detached and return a task id immediately instead of waiting. Completion arrives as a system notification; inspect with task_output, stop with task_stop. Use this instead of nohup/'&' — those leave an unmanaged orphan process",
+				"Run detached and return a task id immediately instead of waiting. Completion arrives as a task notification; inspect with task_output, stop with task_stop. Use this instead of nohup/'&' — those leave an unmanaged orphan process",
 		}),
 	),
 	description: Type.Optional(
@@ -55,11 +40,23 @@ const BashParams = Type.Object({
 });
 
 export default function bashExtension(pi: ExtensionAPI) {
+	// The session's bash, resolved once (lib/shell-spawn.ts). An ignored
+	// CLAUDE_CODE_GIT_BASH_PATH is reported once, at the first session start.
+	const bash = bashSpawn();
+	const shellPath = bash.spawn?.commandTransport === "stdin" ? undefined : bash.spawn?.shell;
+	let warned = false;
+	pi.on("session_start", (_event, ctx) => {
+		if (warned || !bash.warning) return;
+		warned = true;
+		if (ctx.hasUI) ctx.ui.notify(bash.warning, "warning");
+		else process.stderr.write(`${bash.warning}\n`);
+	});
+
 	// pi's definition supplies the description and TUI renderers; the executor
 	// is re-created per working directory because it closes over cwd (worktree
-	// switches change ctx.cwd mid-session).
-	const base = createBashToolDefinition(process.cwd());
-	const foreground = perCwd(createBashToolDefinition);
+	// switches change ctx.cwd mid-session). The same bash drives pi's foreground
+	// executor, so the override applies there too.
+	const base = createBashToolDefinition(process.cwd(), { shellPath });
 	// pi's base sentence is "Optionally provide a timeout in seconds." — but the
 	// `timeout` parameter and the execute path both use milliseconds (Claude
 	// Code's Bash unit; the executor divides by 1000). The two must not
@@ -71,141 +68,14 @@ export default function bashExtension(pi: ExtensionAPI) {
 		"`timeout` is in milliseconds: default 120000, max 600000.",
 	);
 
-	const notifyTask = createTaskNotifier(pi);
-	// A worktree session cd-wraps input.command; the pre-wrapper original arrives
-	// over the bus keyed by toolCallId (never read from params — model-writable).
-	const originalCommands = trackOriginalCommands(pi);
-	const notify = (text: string, details: Record<string, unknown>) => notifyTask("task-notification", text, details);
-
-	const taskLogPath = (ctx: ExtensionContext, taskId: string): string | undefined => {
-		try {
-			const dir = join(ctx.sessionManager.getSessionDir(), "bash", taskId);
-			mkdirSync(dir, { recursive: true });
-			return join(dir, "output.log");
-		} catch {
-			return undefined;
-		}
-	};
-
-	const finishLine = (summary: BashFinishSummary, timeoutSeconds?: number): string => {
-		if (summary.stopped) return "stopped";
-		if (summary.timedOut) return `failed (timed out after ${timeoutSeconds}s)`;
-		if (summary.exitCode === 0) return "completed";
-		return `failed (${summary.exitCode !== null ? `exit code ${summary.exitCode}` : `terminated by ${summary.signal ?? "unknown signal"}`})`;
-	};
-
-	pi.registerTool({
+	registerShellTool(pi, {
 		name: "bash",
-		label: base.label,
-		description: `${baseDescription} Pass run_in_background: true for long-running commands (builds, servers, watches): it returns a task id immediately so you can keep working, completion arrives as a system notification, and the output is retrievable with task_output / stoppable with task_stop (both deferred — load them with tool_search; in a one-shot print/json session the call runs to completion and returns the output directly). Foreground \`sleep\` is blocked; to wait on a condition use the monitor tool (deferred — load it with tool_search select:monitor) with an until-loop.`,
-		promptSnippet: base.promptSnippet,
-		promptGuidelines: base.promptGuidelines,
-		executionMode: base.executionMode,
-		...(() => {
-			// `● Bash(cmd)` / elbow-indented output, like every other One Code tool.
-			// Not passing base.renderCall also drops its timer state, so the
-			// misleading "Took Ns" that counted permission-prompt wait disappears.
-			const wrapped = ccWrapBuiltinRenderers<{ command?: string }>("Bash", base, { title: (a) => a?.command });
-			return {
-				renderShell: wrapped.renderShell,
-				renderCall: wrapped.renderCall as ToolDefinition<typeof BashParams>["renderCall"],
-				renderResult: ((result, options, theme, context) => {
-					// A background start returns a model-facing instruction paragraph;
-					// the transcript needs one line (Claude Code: "Running in the background").
-					const details = result.details as { taskId?: string; logPath?: string } | undefined;
-					if (details?.taskId && !context.isError) {
-						const line = options.expanded
-							? `Running in the background (task ${details.taskId}${details.logPath ? ` · log: ${details.logPath}` : ""})`
-							: "Running in the background (↓ to manage)";
-						return linesComponent(() => resultLines(theme as any, line, options.expanded, false));
-					}
-					return wrapped.renderResult(result, options, theme, context);
-				}) as ToolDefinition<typeof BashParams>["renderResult"],
-			};
-		})(),
+		ccLabel: "Bash",
+		description: `${baseDescription} Pass run_in_background: true for long-running commands (builds, servers, watches): it returns a task id immediately so you can keep working, completion arrives as a task notification, and the output is retrievable with task_output / stoppable with task_stop (both deferred — load them with tool_search; in a one-shot print/json session the call runs to completion and returns the output directly). Foreground \`sleep\` is blocked; to wait on a condition use the monitor tool (deferred — load it with tool_search select:monitor) with an until-loop.`,
 		parameters: BashParams,
-		async execute(toolCallId, params, signal, onUpdate, ctx) {
-			// Guards check the model's original command — a worktree session rewrites
-			// input.command to `cd '<wt>' && (…)`, which would hide the real lead.
-			const originalCommand = commandToEvaluate(originalCommands, toolCallId, params.command);
-			const guardReason = bashGuardReason(originalCommand, { background: params.run_in_background === true });
-			if (guardReason) return { content: [{ type: "text" as const, text: guardReason }], isError: true, details: {} };
-			const timeoutSeconds =
-				params.timeout !== undefined && Number.isFinite(params.timeout) && params.timeout > 0
-					? Math.min(params.timeout, MAX_TIMEOUT_MS) / 1000
-					: undefined;
-
-			if (!params.run_in_background) {
-				// pi's executor takes seconds; the model-facing unit is milliseconds
-				// (Claude Code's Bash), so a habitual `timeout: 120000` is 2 minutes,
-				// not 33 hours (review T11).
-				return foreground(ctx.cwd).execute(
-					toolCallId,
-					{ command: params.command, timeout: timeoutSeconds },
-					signal,
-					onUpdate,
-					ctx,
-				);
-			}
-
-			const id = generateTaskId();
-			const logPath = taskLogPath(ctx, id);
-			const description = params.description || params.command.slice(0, 80);
-
-			// One-shot modes (`-p` / `--mode json`) exit when the turn settles: a
-			// detached task would be orphaned, and its completion callback would
-			// call sendMessage on the disposed session and crash pi (measured,
-			// STEERING-REVIEW-2026-09-05 H3). Run blocking there — the same rule the
-			// Agent tool applies — and return the output in the result.
-			if (!sessionOutlivesTurn(ctx.mode)) {
-				const summary = await runBackgroundBashBlocking(
-					{ id, command: params.command, description, cwd: ctx.cwd, timeoutSeconds, logPath },
-					signal,
-				);
-				const output = persistIfLarge(summary.output, { dir: sessionResultsDir(ctx), id: `bash-${id}`, maxBytes: ONE_SHOT_OUTPUT_CAP });
-				return {
-					content: [
-						{
-							type: "text",
-							text: `Bash task ${id} (${description}) ${finishLine(summary, timeoutSeconds)}. ${oneShotNote("command")}${logPath ? ` Log: ${logPath}.` : ""}\n\n${output}`,
-						},
-					],
-					// No taskId: nothing was registered behind task_output/task_stop, and
-					// its presence is what renderResult reads as "running in the background".
-					details: { logPath },
-					isError: summary.exitCode !== 0 && !summary.stopped,
-				};
-			}
-
-			const task = startBackgroundBash({
-				id,
-				command: params.command,
-				description,
-				cwd: ctx.cwd,
-				timeoutSeconds,
-				logPath,
-				onFinished: (finishedTask, summary) => {
-					const tail = tailCap(summary.output, NOTIFY_OUTPUT_CAP).trim();
-					const where = `Full output: task_output ${id}${logPath ? ` (or read ${logPath})` : ""}.`;
-					notify(
-						systemNotification(
-							`Background bash ${id} (${description}) ${finishLine(summary, timeoutSeconds)}. ${where}${tail ? `\n\nLast output:\n${tail}` : ""}`,
-						),
-						{ taskId: id, status: finishedTask.status, exitCode: summary.exitCode, logPath },
-					);
-				},
-			});
-			pi.events.emit(TASK_REGISTER_CHANNEL, task);
-
-			return {
-				content: [
-					{
-						type: "text",
-						text: `⏳ Bash task ${id} running in background (${description}).\n\nCompletion (with output) will arrive as a system notification on its own — you do not need to wait for it or poll; keep working.${logPath ? ` To check interim output, read ${logPath}.` : ""} If your next step cannot proceed without the result, task_output with block=true waits for it. Stop with task_stop.`,
-					},
-				],
-				details: { taskId: id, logPath },
-			};
-		},
+		base,
+		foreground: perCwd((cwd: string) => createBashToolDefinition(cwd, { shellPath })),
+		guard: bashGuardReason,
+		backgroundShell: () => bash.spawn,
 	});
 }

package/extensions/branding/index.ts

@@ -14,9 +14,10 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
+import { modeCycleKey } from "../lib/keys.ts";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getAgentDir, SettingsManager, VERSION as PI_VERSION } from "@earendil-works/pi-coding-agent";
 import { piVersionWarning } from "../lib/pi-version.ts";
@@ -91,8 +92,9 @@ const HINTS: [key: string, what: string][] = [
 	// it as Claude Code's "effort" so the key and /effort agree on the name.
 	["shift+tab", "effort"],
 	// Claude Code cycles permission modes on shift+tab; pi owns that key, and
-	// ctrl+q is the one ctrl+letter both pi and terminals leave free.
-	["ctrl+q", "permissions"],
+	// ctrl+q is the one ctrl+letter both pi and terminals leave free — except
+	// on Windows and WSL, where pi takes ctrl+q and the key is alt+m.
+	[modeCycleKey(), "permissions"],
 	["ctrl+t", "thinking"],
 	["ctrl+o", "expand output"],
 	["/", "commands"],
@@ -280,7 +282,37 @@ export default function brandingExtension(pi: ExtensionAPI) {
 	}
 	// The label and prompt marker apply in every session; CC_NO_BANNER only
 	// disables the header.
+	// The terminal title. pi writes "π - [<session name> - ]<cwd>" at the end of
+	// its startup, on every session replacement and whenever the name changes —
+	// each AFTER our session_start handler ran, so a title set there alone lost
+	// (seen live 2026-09-19: "π - proj"). Re-assert it once the current task
+	// has drained (setTimeout 0, past pi's synchronous tail) and on every
+	// agent_start, and follow the name like pi does, brand first.
+	let lastTitle: string | undefined;
+	// A ctx captured for the deferred write is stale once the runtime is replaced
+	// (a second /clear inside the 0 ms window); pi's stale-ctx guard throws, and a
+	// throw inside a timer is uncaught — so the write is inert after shutdown.
+	let live = false;
+	const retitle = (ctx: { hasUI: boolean; cwd: string; ui: { setTitle(title: string): void } }) => {
+		if (!live || !ctx.hasUI) return;
+		const name = pi.getSessionName?.()?.trim();
+		const title = name ? `${NAME} - ${name} - ${basename(ctx.cwd)}` : NAME;
+		if (title === lastTitle) return; // agent_start fires every turn; write only on change
+		lastTitle = title;
+		ctx.ui.setTitle(title);
+	};
+	pi.on("session_info_changed", (_event, ctx) => retitle(ctx));
+	pi.on("agent_start", (_event, ctx) => retitle(ctx));
+	pi.on("session_shutdown", () => {
+		live = false;
+	});
+
 	pi.on("session_start", (_event, ctx) => {
+		// pi's own write lands after this handler, so only the deferred write
+		// sticks; a new session may carry a name (resume), so forget the last.
+		lastTitle = undefined;
+		live = true;
+		setTimeout(() => retitle(ctx), 0).unref?.();
 		ctx.ui.setHiddenThinkingLabel(THINKING_LABEL);
 		installPromptMarker(ctx as unknown as { hasUI: boolean; mode: string; ui: BrandingEditorUI });
 		// Soft drift guard: warn once at startup when the hosting pi is outside
@@ -337,7 +369,6 @@ export default function brandingExtension(pi: ExtensionAPI) {
 			? collectStartupSections(ctx.cwd, home, join(dirname(fileURLToPath(import.meta.url)), "..", "..", "themes"), agentDir)
 			: undefined;
 
-		ctx.ui.setTitle(NAME);
 		ctx.ui.setHeader((tui: unknown, theme: unknown) => {
 			const paint = safeThemePaint(theme);
 			// Width-memoized (pi-tui renders every mounted component every frame);

package/extensions/btw/index.ts

@@ -0,0 +1,207 @@
+/**
+ * btw extension — Claude Code's `/btw` ("by the way") side question.
+ *
+ * `/btw <question>` asks a one-off question that is answered from the current
+ * conversation's context while the main agent keeps working. CC frames the
+ * answering model as a separate, lightweight, tool-less instance (the verbatim
+ * reminder in prompt.ts, captured from CC 2.1.278) and shows the answer in a
+ * focused overlay panel, not in the transcript — so the exchange never enters
+ * the main agent's context and cannot steer its work.
+ *
+ * The call reuses recap's machinery: the exact messages the session last put on
+ * the wire (captured from the `context` event), name-only tool stubs so a
+ * history carrying tool_use blocks stays valid on strict providers, and
+ * withReasoningFallback for models that cannot disable thinking. Unlike recap it
+ * uses the SESSION model (not an economical one) — a side question deserves the
+ * same quality as the main conversation — and sends the full captured history,
+ * not just the recent window.
+ *
+ * Deviations from CC, logged in docs/decisions/btw.md: the exchange is stateless
+ * (each `/btw` sees only the shared main context, never a prior `/btw` — CC
+ * keeps a side-session; the "one-off, no follow-up" framing holds either way);
+ * `f to fork` is omitted (pi's `ctx.fork` branches from a session entry, not
+ * from an injected side exchange); and the call runs with an empty system prompt
+ * (the `context` event carries no system prompt to reuse), relying on the shared
+ * history plus the reminder.
+ */
+
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import { convertToLlm, copyToClipboard, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { withReasoningFallback } from "../lib/model-policy.ts";
+import { answerText, stripImageBlocks, toolStubs, trimToTurnBoundary } from "../lib/side-call.ts";
+import { boundedDockHeight, truncateLine } from "../lib/tui-render.ts";
+import { recordUsage } from "../lib/usage-bus.ts";
+import { applyBtwKey, type BtwBody, BTW_MAX_HEIGHT, decodeBtwKey, initialBtwState, renderBtwPanel } from "./panel.ts";
+import { sideQuestionMessage } from "./prompt.ts";
+
+const BTW_MAX_TOKENS = 8192;
+const BTW_TIMEOUT_MS = 120_000;
+/** Description on the name-only tool stubs sent with the side question. */
+const STUB_REASON = "Unavailable during this side question; answer in text.";
+
+export default function btwExtension(pi: ExtensionAPI) {
+	// The exact request messages the session last sent (after every extension's
+	// mutations), captured like recap and the compaction extension do.
+	let capturedMessages: AgentMessage[] | undefined;
+	pi.on("context", (event) => {
+		capturedMessages = event.messages;
+	});
+
+	// The controller for an open panel's in-flight call. Aborted when the session
+	// is replaced or torn down, so a late resolve cannot repaint a disposed `tui`
+	// or record usage on a stale `pi` (the crash the subagents panel once hit —
+	// docs/decisions/tools.md lifecycle review).
+	let inFlight: AbortController | undefined;
+
+	// A new session (including after /clear) shares no context with the old one,
+	// and any in-flight side question is abandoned.
+	pi.on("session_start", () => {
+		capturedMessages = undefined;
+		inFlight?.abort();
+		inFlight = undefined;
+	});
+	pi.on("session_shutdown", () => {
+		inFlight?.abort();
+		inFlight = undefined;
+	});
+
+	/** Run the side question against the session model; returns the answer text. */
+	async function ask(ctx: ExtensionCommandContext, question: string, signal: AbortSignal): Promise<string> {
+		const model = ctx.model;
+		if (!model) throw new Error("No model is configured for this session.");
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (!auth.ok) throw new Error("No API key is available for the current model.");
+		const baseUrl = (auth as { baseUrl?: string }).baseUrl;
+
+		const tools = toolStubs(pi.getActiveTools(), STUB_REASON);
+		const context = trimToTurnBoundary(capturedMessages ?? []);
+		// btw runs on a cheap, possibly text-only reader and answers a text question,
+		// so images the conversation carried are stripped before the call
+		// (docs/decisions/model-policy.md).
+		const messages = [...stripImageBlocks(convertToLlm(context)), { role: "user" as const, content: sideQuestionMessage(question), timestamp: Date.now() }];
+
+		const result = await withReasoningFallback(
+			model as Model<Api>,
+			(reasoning) => {
+				const timeout = AbortSignal.timeout(BTW_TIMEOUT_MS);
+				return completeSimple(
+					baseUrl ? ({ ...model, baseUrl } as Model<Api>) : (model as Model<Api>),
+					{ systemPrompt: "", messages, tools },
+					{
+						apiKey: auth.apiKey,
+						headers: auth.headers,
+						env: auth.env,
+						signal: AbortSignal.any([signal, timeout]),
+						maxTokens: BTW_MAX_TOKENS,
+						...(reasoning ? { reasoning } : {}),
+					},
+				);
+			},
+			undefined,
+			(usage) => recordUsage(pi, "btw", usage),
+		);
+		return answerText(result.content);
+	}
+
+	pi.registerCommand("btw", {
+		description: "Ask a one-off side question, answered from the current context while the main agent keeps working",
+		handler: async (args, ctx) => {
+			const question = args.trim();
+			if (!question) {
+				ctx.ui.notify("Ask a side question: /btw <question>", "info");
+				return;
+			}
+
+			// Headless (-p / --mode json): no panel — answer and print it. The
+			// handler blocks to completion, so the process does not exit early.
+			if (!ctx.hasUI) {
+				try {
+					const answer = await ask(ctx, question, new AbortController().signal);
+					ctx.ui.notify(answer || "(no answer)", "info");
+				} catch (error) {
+					ctx.ui.notify(`Side question failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+				}
+				return;
+			}
+
+			// Show the panel at once with a loading line; run the call concurrently
+			// and repaint when it lands. Closing the panel — or a session
+			// replacement/shutdown — aborts an in-flight call.
+			inFlight?.abort();
+			const controller = new AbortController();
+			inFlight = controller;
+			const view: { answer?: string; error?: string } = {};
+			const bodyState = (): BtwBody =>
+				view.error !== undefined ? { kind: "error", message: view.error } : view.answer !== undefined ? { kind: "answer", text: view.answer } : { kind: "loading" };
+
+			await ctx.ui.custom<null>((tui, theme, _keybindings, done) => {
+				const state = initialBtwState();
+				let cache: { width: number; lines: string[] } | undefined;
+				const repaint = () => {
+					cache = undefined;
+					// A repaint can be requested from an async callback that raced a
+					// session teardown; a stale `tui` throws, so never let it propagate.
+					try {
+						tui.requestRender();
+					} catch {}
+				};
+
+				// Kick off the model call once, at mount, so `repaint` is bound.
+				void (async () => {
+					try {
+						const answer = await ask(ctx, question, controller.signal);
+						if (controller.signal.aborted) return;
+						view.answer = answer;
+					} catch (error) {
+						if (controller.signal.aborted) return;
+						view.error = error instanceof Error ? error.message : String(error);
+					}
+					repaint();
+				})();
+
+				return {
+					render: (width: number) => {
+						if (cache?.width === width) return cache.lines;
+						const termRows = (tui as { terminal: { rows: number } }).terminal.rows;
+						const height = boundedDockHeight(termRows, BTW_MAX_HEIGHT);
+						// Belt-and-suspenders truncate on top of renderBtwPanel's own,
+						// matching every sibling dock panel: pi-tui crashes the app on
+						// a line wider than the terminal.
+						const lines = renderBtwPanel({ state, question, body: bodyState(), width, height }, theme).map((line) => truncateLine(line, width));
+						cache = { width, lines };
+						return lines;
+					},
+					handleInput: (data: string) => {
+						const key = decodeBtwKey(data);
+						if (!key) return;
+						const effect = applyBtwKey(state, key);
+						switch (effect?.kind) {
+							case "close":
+								done(null);
+								return;
+							case "copy":
+								// Only offer copy once there is a non-empty answer.
+								if (view.answer) {
+									void copyToClipboard(view.answer).then(() => {
+										state.copied = true;
+										repaint();
+									});
+								}
+								return;
+							default:
+								repaint();
+						}
+					},
+					invalidate: () => {
+						cache = undefined;
+					},
+				};
+			});
+
+			controller.abort();
+			if (inFlight === controller) inFlight = undefined;
+		},
+	});
+}