@narumitw/pi-btw 0.31.0 → 0.32.0

package/README.md

@@ -11,6 +11,7 @@ Use it when you want to ask a temporary question, inspect context, or get a shor
 - Adds a `/btw` side-thread command to Pi, with an optional initial question.
 - Answers side questions in a temporary, scrollable UI.
 - Supports follow-up questions in the same ephemeral side thread.
+- 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`.
 - Inherits Pi's current thinking level or uses a fixed level from `pi-btw.json`.
@@ -62,9 +63,33 @@ required.
 Previous side questions and answers remain available to the model and visible for that
 invocation. 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. Closing it, reloading Pi,
-or switching sessions discards it without adding any of its questions or answers to the main
-conversation.
+`Ctrl+C` to cancel an in-progress answer or leave the side thread.
+
+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
+thread before you choose. Bring the latest question and answer, everything from a chosen
+question onward, an exact text range, or the entire side thread. Question-suffix, exact-range,
+and entire-thread choices preview the exact editable context block before the side thread closes;
+`Escape` returns and `Ctrl+C` closes without bringing anything to main.
+
+The text-range selector supports both fast line selection and editor-style character selection.
+It reports whether anything is selected plus the selected line, message, and approximate token
+counts. Press `Space` to select the current raw source line, then use `Up`/`Down` to extend by
+whole lines; press `Space` again to clear it. Alternatively, use the arrow keys to move the cursor
+and `Shift`+arrow keys to extend a character-level selection. Starting a Shift selection replaces
+any active line selection. Selected lines include a visible `●` marker in addition to highlighting.
+Pi's configured keys control vertical navigation, bringing, and going back (`Up`/`Down`, `Enter`,
+and `Escape` by default), and the selector displays the active keys. Selection follows raw source
+text rather than terminal-wrapped visual rows.
+
+Bringing context to main closes the side thread and loads a deterministic, editable context block
+into Pi's main editor. It never sends the draft automatically. If the main editor already has a
+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.
 
 ## ⚙️ Model and thinking level
 
@@ -114,7 +139,10 @@ Normal assistant messages become part of the main Pi conversation and can distra
 extensions/pi-btw/
 ├── src/
 │   ├── index.ts
-│   └── btw.ts
+│   ├── btw.ts
+│   ├── bring-to-main.ts
+│   ├── side-thread.ts
+│   └── transcript-pager.ts
 ├── README.md
 ├── LICENSE
 ├── tsconfig.json

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-btw",
-	"version": "0.31.0",
+	"version": "0.32.0",
 	"description": "Pi extension that adds a /btw side-question command.",
 	"type": "module",
 	"license": "MIT",

package/src/bring-to-main.ts

@@ -0,0 +1,870 @@
+import type { KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import {
+	type Component,
+	Key,
+	matchesKey,
+	type TUI,
+	truncateToWidth,
+	visibleWidth,
+} from "@earendil-works/pi-tui";
+import type { SideThreadTurn } from "./side-thread.js";
+
+const RESERVED_APP_ROWS = 3;
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export interface BtwBringToMainSegment {
+	role: "user" | "assistant";
+	text: string;
+}
+
+export interface BtwBringToMainSummary {
+	lines: number;
+	messages: number;
+	tokens: number;
+}
+
+export interface BtwSelectionLine {
+	role: BtwBringToMainSegment["role"];
+	text: string;
+}
+
+export interface BtwTextPosition {
+	line: number;
+	column: number;
+}
+
+export interface BtwTextRangeSelectorState {
+	cursor: BtwTextPosition;
+	anchor?: BtwTextPosition;
+	lineAnchor?: number;
+	preferredColumn: number;
+	scrollOffset: number;
+	horizontalOffset: number;
+}
+
+export type BtwQuickBringToMainScope =
+	| { kind: "latest" }
+	| { kind: "from"; answeredTurnIndex: number }
+	| { kind: "entire" };
+
+export type BtwMenuSelectorAction =
+	| { kind: "select"; value: string }
+	| { kind: "back" }
+	| { kind: "close" };
+
+export type BtwTextRangeSelectorAction =
+	| { kind: "confirm"; segments: BtwBringToMainSegment[] }
+	| { kind: "back" }
+	| { kind: "close" };
+
+export function getAnsweredTurns(
+	turns: readonly SideThreadTurn[],
+): Array<Extract<SideThreadTurn, { kind: "answered" }>> {
+	return turns.filter(
+		(turn): turn is Extract<SideThreadTurn, { kind: "answered" }> => turn.kind === "answered",
+	);
+}
+
+export function buildQuickBringToMainSegments(
+	turns: readonly SideThreadTurn[],
+	scope: BtwQuickBringToMainScope,
+): BtwBringToMainSegment[] {
+	const answered = getAnsweredTurns(turns);
+	const selected =
+		scope.kind === "latest"
+			? answered.slice(-1)
+			: scope.kind === "from"
+				? answered.slice(Math.max(0, scope.answeredTurnIndex))
+				: answered;
+	return selected.flatMap((turn) => [
+		{ role: "user" as const, text: turn.question },
+		{ role: "assistant" as const, text: turn.answer },
+	]);
+}
+
+export function buildBtwSelectionLines(turns: readonly SideThreadTurn[]): BtwSelectionLine[] {
+	return buildQuickBringToMainSegments(turns, { kind: "entire" }).flatMap((segment) =>
+		segment.text.split("\n").map((text) => ({ role: segment.role, text })),
+	);
+}
+
+export function segmentsFromLineRange(
+	lines: readonly BtwSelectionLine[],
+	anchor: number,
+	cursor: number,
+): BtwBringToMainSegment[] {
+	if (lines.length === 0) return [];
+	const start = Math.max(0, Math.min(anchor, cursor, lines.length - 1));
+	const end = Math.max(0, Math.min(Math.max(anchor, cursor), lines.length - 1));
+	const segments: BtwBringToMainSegment[] = [];
+	for (const line of lines.slice(start, end + 1)) {
+		const previous = segments.at(-1);
+		if (previous?.role === line.role) {
+			previous.text += `\n${line.text}`;
+		} else {
+			segments.push({ role: line.role, text: line.text });
+		}
+	}
+	return segments;
+}
+
+export function segmentsFromTextRange(
+	lines: readonly BtwSelectionLine[],
+	anchor: BtwTextPosition,
+	cursor: BtwTextPosition,
+): BtwBringToMainSegment[] {
+	if (lines.length === 0) return [];
+	const first = clampTextPosition(lines, anchor);
+	const second = clampTextPosition(lines, cursor);
+	const [start, end] = compareTextPositions(first, second) <= 0 ? [first, second] : [second, first];
+	if (compareTextPositions(start, end) === 0) return [];
+
+	const segments: BtwBringToMainSegment[] = [];
+	for (let lineIndex = start.line; lineIndex <= end.line; lineIndex += 1) {
+		const line = lines[lineIndex];
+		if (!line) continue;
+		const characters = splitGraphemes(line.text);
+		const from = lineIndex === start.line ? start.column : 0;
+		const to = lineIndex === end.line ? end.column : characters.length;
+		const text = characters.slice(from, to).join("");
+		if (text) {
+			const previous = segments.at(-1);
+			if (previous?.role === line.role) previous.text += text;
+			else segments.push({ role: line.role, text });
+		}
+		const crossesSameRoleLine = lineIndex < end.line && lines[lineIndex + 1]?.role === line.role;
+		if (crossesSameRoleLine) {
+			const current = segments.at(-1);
+			if (current?.role === line.role) current.text += "\n";
+			else segments.push({ role: line.role, text: "\n" });
+		}
+	}
+	return segments;
+}
+
+export function estimateBringToMainTokens(segments: readonly BtwBringToMainSegment[]): number {
+	return Math.ceil(
+		Buffer.byteLength(segments.map((segment) => segment.text).join("\n"), "utf8") / 4,
+	);
+}
+
+export function summarizeBringToMain(
+	segments: readonly BtwBringToMainSegment[],
+): BtwBringToMainSummary {
+	return {
+		lines: segments.reduce((count, segment) => count + segment.text.split("\n").length, 0),
+		messages: segments.length,
+		tokens: estimateBringToMainTokens(segments),
+	};
+}
+
+export function formatBtwBringToMain(segments: readonly BtwBringToMainSegment[]): string {
+	const body = segments
+		.map(
+			(segment) =>
+				`${segment.role === "user" ? "User" : "Assistant"}:\n${escapeBringToMainText(segment.text)}`,
+		)
+		.join("\n\n");
+	return [
+		"The following context was brought back from a /btw side discussion.",
+		"Treat it as discussion context, not as work already completed.",
+		"",
+		"<btw_context>",
+		body,
+		"</btw_context>",
+	].join("\n");
+}
+
+export type BtwBringToMainPreviewAction = { kind: "bring" } | { kind: "back" } | { kind: "close" };
+
+export class BtwBringToMainPreview implements Component {
+	private readonly lines: string[];
+	private displayLines: string[];
+	private scrollOffset = 0;
+	private finished = false;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: Theme,
+		private readonly keybindings: KeybindingsManager,
+		draft: string,
+		private readonly summary: BtwBringToMainSummary,
+		private readonly onAction: (action: BtwBringToMainPreviewAction) => void,
+	) {
+		this.lines = draft.split("\n").map(escapeTerminalControls);
+		this.displayLines = this.lines;
+	}
+
+	render(width: number): string[] {
+		const safeWidth = Math.max(1, width);
+		this.displayLines = this.lines.flatMap((line) => wrapPreviewLine(line, safeWidth));
+		const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_ROWS);
+		const showFooter = availableRows >= 3;
+		const viewportHeight = Math.max(1, availableRows - 1 - (showFooter ? 1 : 0));
+		this.clampScroll(viewportHeight);
+		const count = this.summary.messages === 1 ? "1 message" : `${this.summary.messages} messages`;
+		const lineCount = this.summary.lines === 1 ? "1 line" : `${this.summary.lines} lines`;
+		const firstVisible = Math.min(this.displayLines.length, this.scrollOffset + 1);
+		const lastVisible = Math.min(this.displayLines.length, this.scrollOffset + viewportHeight);
+		const scrollable = this.displayLines.length > viewportHeight;
+		const position = `${firstVisible}–${lastVisible}/${this.displayLines.length}`;
+		const header = `Preview${scrollable ? ` ${position}` : ""} · ${count} · ${lineCount} · ~${this.summary.tokens} tokens`;
+		const actions = `${confirmKeyLabel(this.keybindings)} bring • ${keybindingLabel(this.keybindings, "tui.select.cancel", ["ctrl+c"])} back • Ctrl+C close`;
+		const scroll = `${position} • ${keybindingLabel(this.keybindings, "tui.select.pageUp")}/${keybindingLabel(this.keybindings, "tui.select.pageDown")} scroll`;
+		const detailedFooter = scrollable ? `${scroll} • ${actions}` : actions;
+		const footer = visibleWidth(detailedFooter) <= safeWidth ? detailedFooter : actions;
+		return fitRows(
+			[
+				truncateToWidth(this.theme.fg("accent", this.theme.bold(header)), safeWidth, ""),
+				...this.displayLines.slice(this.scrollOffset, this.scrollOffset + viewportHeight),
+				...(showFooter ? [truncateToWidth(this.theme.fg("muted", footer), safeWidth, "")] : []),
+			],
+			availableRows,
+		);
+	}
+
+	handleInput(data: string): void {
+		if (this.finished) return;
+		if (matchesKey(data, Key.ctrl("c"))) {
+			this.finish({ kind: "close" });
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.cancel")) {
+			this.finish({ kind: "back" });
+			return;
+		}
+		if (matchesConfirm(data, this.keybindings)) {
+			this.finish({ kind: "bring" });
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.pageUp")) {
+			this.scrollOffset -= Math.max(1, this.tui.terminal.rows - RESERVED_APP_ROWS - 2);
+			this.clampScroll(Math.max(0, this.tui.terminal.rows - RESERVED_APP_ROWS - 2));
+			this.tui.requestRender();
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.pageDown")) {
+			this.scrollOffset += Math.max(1, this.tui.terminal.rows - RESERVED_APP_ROWS - 2);
+			this.clampScroll(Math.max(0, this.tui.terminal.rows - RESERVED_APP_ROWS - 2));
+			this.tui.requestRender();
+		}
+	}
+
+	invalidate(): void {}
+
+	private clampScroll(viewportHeight: number): void {
+		this.scrollOffset = Math.max(
+			0,
+			Math.min(this.scrollOffset, Math.max(0, this.displayLines.length - viewportHeight)),
+		);
+	}
+
+	private finish(action: BtwBringToMainPreviewAction): void {
+		if (this.finished) return;
+		this.finished = true;
+		this.onAction(action);
+	}
+}
+
+export class BtwMenuSelector implements Component {
+	private cursor = 0;
+	private scrollOffset = 0;
+	private finished = false;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: Theme,
+		private readonly keybindings: KeybindingsManager,
+		private readonly title: string,
+		private readonly options: readonly string[],
+		private readonly onAction: (action: BtwMenuSelectorAction) => void,
+		initialValue?: string,
+	) {
+		const initialIndex = initialValue === undefined ? -1 : options.indexOf(initialValue);
+		if (initialIndex >= 0) this.cursor = initialIndex;
+	}
+
+	render(width: number): string[] {
+		const safeWidth = Math.max(1, width);
+		const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_ROWS);
+		const showFooter = availableRows >= 3;
+		const viewportHeight = Math.max(1, availableRows - 1 - (showFooter ? 1 : 0));
+		this.keepCursorVisible(viewportHeight);
+		const rows = this.options
+			.slice(this.scrollOffset, this.scrollOffset + viewportHeight)
+			.map((option, visibleIndex) => {
+				const index = this.scrollOffset + visibleIndex;
+				const raw = `${index === this.cursor ? ">" : " "} ${escapeTerminalControls(option)}`;
+				const toned = option.startsWith("⚠") ? this.theme.fg("warning", raw) : raw;
+				const styled =
+					index === this.cursor ? this.theme.bg("selectedBg", this.theme.fg("text", toned)) : toned;
+				return truncateToWidth(styled, safeWidth, "");
+			});
+		return fitRows(
+			[
+				truncateToWidth(
+					this.theme.fg("accent", this.theme.bold(escapeTerminalControls(this.title))),
+					safeWidth,
+					"",
+				),
+				...rows,
+				...(showFooter
+					? [
+							truncateToWidth(
+								this.theme.fg(
+									"muted",
+									`${confirmKeyLabel(this.keybindings)} confirm • ${keybindingLabel(this.keybindings, "tui.select.cancel", ["ctrl+c"])} back • Ctrl+C close`,
+								),
+								safeWidth,
+								"",
+							),
+						]
+					: []),
+			],
+			availableRows,
+		);
+	}
+
+	handleInput(data: string): void {
+		if (this.finished) return;
+		if (matchesKey(data, Key.ctrl("c"))) {
+			this.finish({ kind: "close" });
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.cancel")) {
+			this.finish({ kind: "back" });
+			return;
+		}
+		if (matchesConfirm(data, this.keybindings)) {
+			const value = this.options[this.cursor];
+			if (value !== undefined) this.finish({ kind: "select", value });
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.up")) {
+			this.cursor = Math.max(0, this.cursor - 1);
+			this.tui.requestRender();
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.down")) {
+			this.cursor = Math.min(Math.max(0, this.options.length - 1), this.cursor + 1);
+			this.tui.requestRender();
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.pageUp")) {
+			this.cursor = Math.max(0, this.cursor - 10);
+			this.tui.requestRender();
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.pageDown")) {
+			this.cursor = Math.min(Math.max(0, this.options.length - 1), this.cursor + 10);
+			this.tui.requestRender();
+			return;
+		}
+	}
+
+	invalidate(): void {}
+
+	private keepCursorVisible(height: number): void {
+		if (height <= 0) return;
+		if (this.cursor < this.scrollOffset) this.scrollOffset = this.cursor;
+		if (this.cursor >= this.scrollOffset + height) {
+			this.scrollOffset = this.cursor - height + 1;
+		}
+	}
+
+	private finish(action: BtwMenuSelectorAction): void {
+		if (this.finished) return;
+		this.finished = true;
+		this.onAction(action);
+	}
+}
+
+export class BtwTextRangeSelector implements Component {
+	private readonly lines: BtwSelectionLine[];
+	private cursor: BtwTextPosition = { line: 0, column: 0 };
+	private anchor: BtwTextPosition | undefined;
+	private lineAnchor: number | undefined;
+	private preferredColumn = 0;
+	private scrollOffset = 0;
+	private horizontalOffset = 0;
+	private warning: string | undefined;
+	private finished = false;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: Theme,
+		private readonly keybindings: KeybindingsManager,
+		turns: readonly SideThreadTurn[],
+		private readonly onAction: (action: BtwTextRangeSelectorAction) => void,
+		initialState?: BtwTextRangeSelectorState,
+	) {
+		this.lines = buildBtwSelectionLines(turns);
+		if (initialState) {
+			this.cursor = clampTextPosition(this.lines, initialState.cursor);
+			this.anchor = initialState.anchor
+				? clampTextPosition(this.lines, initialState.anchor)
+				: undefined;
+			this.lineAnchor =
+				initialState.lineAnchor === undefined
+					? undefined
+					: Math.max(0, Math.min(this.lines.length - 1, initialState.lineAnchor));
+			this.preferredColumn = Math.max(0, initialState.preferredColumn);
+			this.scrollOffset = Math.max(0, initialState.scrollOffset);
+			this.horizontalOffset = Math.max(0, initialState.horizontalOffset);
+		}
+	}
+
+	getState(): BtwTextRangeSelectorState {
+		return {
+			cursor: { ...this.cursor },
+			anchor: this.anchor ? { ...this.anchor } : undefined,
+			lineAnchor: this.lineAnchor,
+			preferredColumn: this.preferredColumn,
+			scrollOffset: this.scrollOffset,
+			horizontalOffset: this.horizontalOffset,
+		};
+	}
+
+	render(width: number): string[] {
+		const safeWidth = Math.max(1, width);
+		const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_ROWS);
+		const showStatus = availableRows >= 4;
+		const showFooter = availableRows >= 3;
+		const viewportHeight = Math.max(
+			1,
+			availableRows - 1 - (showStatus ? 1 : 0) - (showFooter ? 1 : 0),
+		);
+		this.keepCursorVisible(viewportHeight);
+		const textWidth = Math.max(1, safeWidth - visibleWidth("●> Assistant │ "));
+		this.keepCursorHorizontallyVisible(textWidth);
+		const range = this.getSelectionRange();
+		const lineRange = this.getLineSelectionRange();
+		const visible = this.lines.slice(this.scrollOffset, this.scrollOffset + viewportHeight);
+		const rows = visible.map((line, visibleIndex) => {
+			const lineIndex = this.scrollOffset + visibleIndex;
+			const role = line.role === "user" ? "User" : "Assistant";
+			const lineSelected = lineRange
+				? lineIndex >= lineRange.start && lineIndex <= lineRange.end
+				: false;
+			const prefix = `${lineSelected ? "●" : " "}${lineIndex === this.cursor.line ? ">" : " "} ${role.padEnd(9)} │ `;
+			const text = this.renderTextLine(line, lineIndex, range, lineSelected);
+			return truncateToWidth(
+				lineIndex === this.cursor.line ? this.theme.fg("accent", prefix) + text : prefix + text,
+				safeWidth,
+				"",
+			);
+		});
+		const selected = this.getSelectedSegments();
+		const summary = summarizeBringToMain(selected);
+		const status =
+			selected.length === 0
+				? "Selected: none"
+				: `Selected: ${summary.lines} ${summary.lines === 1 ? "line" : "lines"} · ${summary.messages} ${summary.messages === 1 ? "message" : "messages"} · ~${summary.tokens} ${summary.tokens === 1 ? "token" : "tokens"}`;
+		const confirm = confirmKeyLabel(this.keybindings);
+		const back = keybindingLabel(this.keybindings, "tui.select.cancel", ["ctrl+c"]);
+		const vertical = `${keybindingLabel(this.keybindings, "tui.select.up")}/${keybindingLabel(this.keybindings, "tui.select.down")}`;
+		const confirmUsesSpace = this.keybindings.matches(" ", "tui.select.confirm");
+		const detailedFooter = this.warning
+			? `${this.warning} • ${confirmUsesSpace ? "Shift+Arrows select" : "Space lines • Shift+Arrows text"} • ${back} back • Ctrl+C close`
+			: this.lineAnchor !== undefined
+				? `${confirmUsesSpace ? `${vertical} extend lines` : `Space clear • ${vertical} extend lines`} • Shift+Arrows text • ${confirm} bring • ${back} back • Ctrl+C close`
+				: `Shift+Arrows select • Arrows move${confirmUsesSpace ? "" : " • Space lines"} • ${confirm} bring • ${back} back • Ctrl+C close`;
+		const criticalFooter = `${confirm} bring • ${back} back • Ctrl+C close`;
+		const footer = visibleWidth(detailedFooter) <= safeWidth ? detailedFooter : criticalFooter;
+		return fitRows(
+			[
+				truncateToWidth(
+					this.theme.fg("accent", this.theme.bold("Select text to bring to main")),
+					safeWidth,
+					"",
+				),
+				...(showStatus ? [truncateToWidth(this.theme.fg("muted", status), safeWidth, "")] : []),
+				...rows,
+				...(showFooter
+					? [
+							truncateToWidth(
+								this.theme.fg(this.warning ? "warning" : "muted", footer),
+								safeWidth,
+								"",
+							),
+						]
+					: []),
+			],
+			availableRows,
+		);
+	}
+
+	handleInput(data: string): void {
+		if (this.finished) return;
+		if (matchesKey(data, Key.ctrl("c"))) {
+			this.finish({ kind: "close" });
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.cancel")) {
+			this.finish({ kind: "back" });
+			return;
+		}
+		if (matchesConfirm(data, this.keybindings)) {
+			if (this.lines.length > 0) {
+				const segments = this.getSelectedSegments();
+				if (segments.length === 0) {
+					this.warning = "Select text first";
+					this.tui.requestRender();
+				} else {
+					this.finish({ kind: "confirm", segments });
+				}
+			}
+			return;
+		}
+		if (matchesKey(data, Key.space)) {
+			this.anchor = undefined;
+			this.lineAnchor = this.lineAnchor === undefined ? this.cursor.line : undefined;
+			this.afterMove();
+			return;
+		}
+		if (matchesKey(data, Key.shift("left"))) {
+			this.moveHorizontal(-1, true);
+			return;
+		}
+		if (matchesKey(data, Key.shift("right"))) {
+			this.moveHorizontal(1, true);
+			return;
+		}
+		if (matchesKey(data, Key.shift("up"))) {
+			this.moveVertical(-1, true);
+			return;
+		}
+		if (matchesKey(data, Key.shift("down"))) {
+			this.moveVertical(1, true);
+			return;
+		}
+		if (matchesKey(data, Key.left)) {
+			this.moveHorizontal(-1, false);
+			return;
+		}
+		if (matchesKey(data, Key.right)) {
+			this.moveHorizontal(1, false);
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.up")) {
+			this.moveVertical(-1, false);
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.down")) {
+			this.moveVertical(1, false);
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.pageUp")) {
+			this.moveVertical(-10, false);
+			return;
+		}
+		if (this.keybindings.matches(data, "tui.select.pageDown")) {
+			this.moveVertical(10, false);
+			return;
+		}
+	}
+
+	invalidate(): void {}
+
+	private renderTextLine(
+		line: BtwSelectionLine,
+		lineIndex: number,
+		range: { start: BtwTextPosition; end: BtwTextPosition } | undefined,
+		lineSelected: boolean,
+	): string {
+		const characters = splitGraphemes(line.text);
+		let rendered = this.horizontalOffset > 0 ? this.theme.fg("muted", "…") : "";
+		let buffer = "";
+		let bufferSelected = false;
+		const flush = () => {
+			if (!buffer) return;
+			rendered += bufferSelected
+				? this.theme.bg("selectedBg", this.theme.fg("text", buffer))
+				: buffer;
+			buffer = "";
+		};
+		for (let column = this.horizontalOffset; column <= characters.length; column += 1) {
+			if (range && lineIndex === range.start.line && column === range.start.column) {
+				flush();
+				rendered += this.theme.fg("accent", "[");
+			}
+			if (lineIndex === this.cursor.line && column === this.cursor.column) {
+				flush();
+				rendered += this.theme.fg("accent", "│");
+			}
+			if (range && lineIndex === range.end.line && column === range.end.column) {
+				flush();
+				rendered += this.theme.fg("accent", "]");
+			}
+			const character = characters[column];
+			if (character === undefined) continue;
+			const selected =
+				lineSelected || (range ? positionFallsInside(lineIndex, column, range) : false);
+			if (buffer && selected !== bufferSelected) flush();
+			bufferSelected = selected;
+			buffer += escapeTerminalControls(character);
+		}
+		flush();
+		return rendered;
+	}
+
+	private getSelectionRange(): { start: BtwTextPosition; end: BtwTextPosition } | undefined {
+		if (!this.anchor || compareTextPositions(this.anchor, this.cursor) === 0) return undefined;
+		return compareTextPositions(this.anchor, this.cursor) < 0
+			? { start: this.anchor, end: this.cursor }
+			: { start: this.cursor, end: this.anchor };
+	}
+
+	private getLineSelectionRange(): { start: number; end: number } | undefined {
+		return this.lineAnchor === undefined
+			? undefined
+			: {
+					start: Math.min(this.lineAnchor, this.cursor.line),
+					end: Math.max(this.lineAnchor, this.cursor.line),
+				};
+	}
+
+	private getSelectedSegments(): BtwBringToMainSegment[] {
+		if (this.lineAnchor !== undefined) {
+			return segmentsFromLineRange(this.lines, this.lineAnchor, this.cursor.line);
+		}
+		return this.anchor ? segmentsFromTextRange(this.lines, this.anchor, this.cursor) : [];
+	}
+
+	private moveHorizontal(delta: -1 | 1, extend: boolean): void {
+		if (this.lines.length === 0) return;
+		if (!extend) this.lineAnchor = undefined;
+		if (!extend && this.anchor) {
+			const range = this.getSelectionRange();
+			if (range) this.cursor = delta < 0 ? range.start : range.end;
+			this.anchor = undefined;
+			this.preferredColumn = this.cursor.column;
+			this.afterMove();
+			return;
+		}
+		this.beginOrClearSelection(extend);
+		const line = this.lines[this.cursor.line];
+		const length = line ? splitGraphemes(line.text).length : 0;
+		if (delta < 0) {
+			if (this.cursor.column > 0) this.cursor = { ...this.cursor, column: this.cursor.column - 1 };
+			else if (this.cursor.line > 0) {
+				const previousLine = this.lines[this.cursor.line - 1];
+				this.cursor = {
+					line: this.cursor.line - 1,
+					column: previousLine ? splitGraphemes(previousLine.text).length : 0,
+				};
+			}
+		} else if (this.cursor.column < length) {
+			this.cursor = { ...this.cursor, column: this.cursor.column + 1 };
+		} else if (this.cursor.line < this.lines.length - 1) {
+			this.cursor = { line: this.cursor.line + 1, column: 0 };
+		}
+		this.preferredColumn = this.cursor.column;
+		this.afterMove();
+	}
+
+	private moveVertical(delta: number, extend: boolean): void {
+		if (this.lines.length === 0) return;
+		if (extend || this.lineAnchor === undefined) this.beginOrClearSelection(extend);
+		const line = Math.max(0, Math.min(this.lines.length - 1, this.cursor.line + delta));
+		const target = this.lines[line];
+		this.cursor = {
+			line,
+			column: Math.min(this.preferredColumn, target ? splitGraphemes(target.text).length : 0),
+		};
+		this.afterMove();
+	}
+
+	private beginOrClearSelection(extend: boolean): void {
+		if (extend) this.lineAnchor = undefined;
+		if (extend && !this.anchor) this.anchor = { ...this.cursor };
+		if (!extend) this.anchor = undefined;
+	}
+
+	private afterMove(): void {
+		this.warning = undefined;
+		this.tui.requestRender();
+	}
+
+	private keepCursorVisible(height: number): void {
+		if (height <= 0) return;
+		if (this.cursor.line < this.scrollOffset) this.scrollOffset = this.cursor.line;
+		if (this.cursor.line >= this.scrollOffset + height) {
+			this.scrollOffset = this.cursor.line - height + 1;
+		}
+	}
+
+	private keepCursorHorizontallyVisible(width: number): void {
+		const characters = splitGraphemes(this.lines[this.cursor.line]?.text ?? "");
+		const displayWidths = characters.map((character) =>
+			visibleWidth(escapeTerminalControls(character)),
+		);
+		const currentWidth = displayWidths[this.cursor.column] ?? 0;
+		let usedWidth = 1 + Math.min(currentWidth, Math.max(0, width - 1));
+		let offset = this.cursor.column;
+		for (let index = this.cursor.column - 1; index >= 0; index -= 1) {
+			const nextWidth = usedWidth + (displayWidths[index] ?? 0) + (index > 0 ? 1 : 0);
+			if (nextWidth > width) break;
+			usedWidth += displayWidths[index] ?? 0;
+			offset = index;
+		}
+		this.horizontalOffset = offset;
+	}
+
+	private finish(action: BtwTextRangeSelectorAction): void {
+		if (this.finished) return;
+		this.finished = true;
+		this.onAction(action);
+	}
+}
+
+function clampTextPosition(
+	lines: readonly BtwSelectionLine[],
+	position: BtwTextPosition,
+): BtwTextPosition {
+	const line = Math.max(0, Math.min(lines.length - 1, position.line));
+	const text = lines[line]?.text ?? "";
+	return {
+		line,
+		column: Math.max(0, Math.min(splitGraphemes(text).length, position.column)),
+	};
+}
+
+function confirmKeyLabel(keybindings: KeybindingsManager): string {
+	return keybindingLabel(keybindings, "tui.select.confirm", ["ctrl+c"], "enter");
+}
+
+function matchesConfirm(data: string, keybindings: KeybindingsManager): boolean {
+	if (matchesKey(data, Key.ctrl("c"))) return false;
+	const hasUsableBinding = keybindings
+		.getKeys("tui.select.confirm")
+		.map(String)
+		.some((key) => key.toLowerCase() !== "ctrl+c");
+	return (
+		keybindings.matches(data, "tui.select.confirm") ||
+		(!hasUsableBinding && matchesKey(data, Key.enter))
+	);
+}
+
+function keybindingLabel(
+	keybindings: KeybindingsManager,
+	keybinding:
+		| "tui.select.confirm"
+		| "tui.select.cancel"
+		| "tui.select.up"
+		| "tui.select.down"
+		| "tui.select.pageUp"
+		| "tui.select.pageDown",
+	excluded: readonly string[] = [],
+	fallback?: string,
+): string {
+	const key = keybindings
+		.getKeys(keybinding)
+		.map(String)
+		.find((candidate) => !excluded.includes(candidate.toLowerCase()));
+	return formatKeyLabel(key ?? fallback ?? keybinding);
+}
+
+function formatKeyLabel(key: string): string {
+	return key
+		.split("+")
+		.map((part) => {
+			const lower = part.toLowerCase();
+			if (lower === "ctrl") return "Ctrl";
+			if (lower === "alt") return "Alt";
+			if (lower === "shift") return "Shift";
+			if (lower === "escape" || lower === "esc") return "Esc";
+			if (lower === "enter" || lower === "return") return "Enter";
+			if (lower === "pageup") return "PgUp";
+			if (lower === "pagedown") return "PgDn";
+			return part.length === 1
+				? part.toUpperCase()
+				: `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`;
+		})
+		.join("+");
+}
+
+function splitGraphemes(text: string): string[] {
+	return [...GRAPHEME_SEGMENTER.segment(text)].map(({ segment }) => segment);
+}
+
+function wrapPreviewLine(text: string, width: number): string[] {
+	if (!text) return [""];
+	const rows: string[] = [];
+	let row = "";
+	let rowWidth = 0;
+	const append = (value: string, valueWidth: number) => {
+		if (row && rowWidth + valueWidth > width) {
+			rows.push(row);
+			row = "";
+			rowWidth = 0;
+		}
+		row += value;
+		rowWidth += valueWidth;
+	};
+	for (const character of splitGraphemes(text)) {
+		const characterWidth = visibleWidth(character);
+		if (characterWidth <= width) {
+			append(character, characterWidth);
+			continue;
+		}
+		const codePoints = [...character]
+			.map((value) => `\\u{${value.codePointAt(0)?.toString(16) ?? "0"}}`)
+			.join("");
+		for (const value of codePoints) append(value, 1);
+	}
+	rows.push(row);
+	return rows;
+}
+
+function compareTextPositions(first: BtwTextPosition, second: BtwTextPosition): number {
+	return first.line === second.line ? first.column - second.column : first.line - second.line;
+}
+
+function positionFallsInside(
+	line: number,
+	column: number,
+	range: { start: BtwTextPosition; end: BtwTextPosition },
+): boolean {
+	const position = { line, column };
+	return (
+		compareTextPositions(position, range.start) >= 0 &&
+		compareTextPositions(position, range.end) < 0
+	);
+}
+
+function fitRows(rows: string[], availableRows: number): string[] {
+	if (rows.length <= availableRows) return rows;
+	if (availableRows <= 1) return rows.slice(0, 1);
+	return [rows[0] ?? "", ...rows.slice(rows.length - availableRows + 1)];
+}
+
+function escapeBringToMainText(text: string): string {
+	return [...text]
+		.map((character) => {
+			if (character === "\n") return character;
+			if (character === "\t") return "    ";
+			const code = character.charCodeAt(0);
+			if (code <= 31 || (code >= 127 && code <= 159)) {
+				return `\\x${code.toString(16).padStart(2, "0")}`;
+			}
+			return character;
+		})
+		.join("")
+		.replace(/<btw_context(?=[ \t\r\n>])/g, "&lt;btw_context")
+		.replace(/<\/btw_context[ \t\r\n]*>/g, (terminator) =>
+			terminator.replace("<", "&lt;").replace(">", "&gt;"),
+		);
+}
+
+function escapeTerminalControls(text: string): string {
+	return [...text]
+		.map((character) => {
+			const code = character.charCodeAt(0);
+			if (code <= 31 || (code >= 127 && code <= 159)) {
+				return `\\x${code.toString(16).padStart(2, "0")}`;
+			}
+			return character;
+		})
+		.join("");
+}

package/src/btw.ts

@@ -6,7 +6,25 @@ import {
 	type ExtensionAPI,
 	type ExtensionCommandContext,
 	getAgentDir,
+	type KeybindingsManager,
+	type Theme,
 } from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import {
+	BtwBringToMainPreview,
+	type BtwBringToMainPreviewAction,
+	type BtwBringToMainSegment,
+	type BtwBringToMainSummary,
+	BtwMenuSelector,
+	type BtwMenuSelectorAction,
+	BtwTextRangeSelector,
+	type BtwTextRangeSelectorState,
+	buildQuickBringToMainSegments,
+	estimateBringToMainTokens,
+	formatBtwBringToMain,
+	getAnsweredTurns,
+	summarizeBringToMain,
+} from "./bring-to-main.js";
 import {
 	BTW_THINKING_LEVELS,
 	type BtwThinkingLevel,
@@ -285,8 +303,24 @@ async function resolveBtwModelWithLoader(
 interface RunBtwThreadDependencies {
 	ask?: typeof askThreadQuestion;
 	interact?: typeof showThreadComposer;
+	chooseBringToMain?: typeof chooseBringToMain;
+	deliverBringToMain?: typeof loadBringToMainDraft;
 }
 
+export type BtwThreadResult = { kind: "closed" };
+
+type BtwBringToMainChoice =
+	| BtwThreadResult
+	| {
+			kind: "bringToMain";
+			draft: string;
+			summary: BtwBringToMainSummary;
+			selectionState?: BtwTextRangeSelectorState;
+	  }
+	| { kind: "back" };
+
+type BtwBringToMainDelivery = "loaded" | "back" | "closed";
+
 interface RunBtwThreadOptions {
 	initialQuestion?: string;
 	selected: ResolvedBtwModel;
@@ -301,23 +335,39 @@ export async function runBtwThread({
 	thinkingLevel,
 	ctx,
 	dependencies = {},
-}: RunBtwThreadOptions): Promise<void> {
+}: RunBtwThreadOptions): Promise<BtwThreadResult> {
 	const ask = dependencies.ask ?? askThreadQuestion;
 	const interact = dependencies.interact ?? showThreadComposer;
+	const chooseBringToMainAction = dependencies.chooseBringToMain ?? chooseBringToMain;
+	const deliverBringToMainDraft = dependencies.deliverBringToMain ?? loadBringToMainDraft;
 	const thread = createSideThread(buildConversationContext(ctx.sessionManager.getBranch()));
 	let pendingQuestion = initialQuestion;
+	let composerDraft: string | undefined;
 
 	while (true) {
 		if (!pendingQuestion) {
-			const action = await interact(thread, thread.turns.length > 0, ctx);
-			if (action.kind === "close") return;
+			const action = await interact(thread, thread.turns.length > 0, ctx, composerDraft);
+			if (action.kind === "close") return { kind: "closed" };
+			if (action.kind === "bringToMain") {
+				const choice = await chooseBringToMainAction(thread, ctx);
+				if (choice.kind === "closed") return choice;
+				if (choice.kind === "back") {
+					composerDraft = action.questionDraft;
+					continue;
+				}
+				const delivery = await deliverBringToMainDraft(choice.draft, ctx, choice.summary);
+				if (delivery === "loaded" || delivery === "closed") return { kind: "closed" };
+				composerDraft = action.questionDraft;
+				continue;
+			}
+			composerDraft = undefined;
 			pendingQuestion = action.question;
 		}
 
 		const result = await ask(thread, pendingQuestion, selected, thinkingLevel, ctx);
 		if (result.kind === "aborted") {
 			ctx.ui.notify("Cancelled", "info");
-			return;
+			return { kind: "closed" };
 		}
 		if (result.kind === "error") {
 			thread.turns.push({
@@ -331,6 +381,236 @@ export async function runBtwThread({
 	}
 }
 
+type BtwCustomFactory<T> = (
+	tui: TUI,
+	theme: Theme,
+	keybindings: KeybindingsManager,
+	done: (result: T) => void,
+) => Component;
+
+async function showBtwCustomPreservingEditor<T>(
+	ctx: ExtensionCommandContext,
+	factory: BtwCustomFactory<T>,
+): Promise<T> {
+	let liveEditorText = ctx.ui.getEditorText();
+	const result = await ctx.ui.custom<T>((tui, theme, keybindings, done) =>
+		factory(tui, theme, keybindings, (value) => {
+			liveEditorText = ctx.ui.getEditorText();
+			done(value);
+		}),
+	);
+	if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
+	return result;
+}
+
+interface ChooseBringToMainDependencies {
+	showMenu?: typeof showBtwMenu;
+	showPreview?: typeof showBringToMainPreview;
+}
+
+export async function chooseBringToMain(
+	thread: SideThread,
+	ctx: ExtensionCommandContext,
+	dependencies: ChooseBringToMainDependencies = {},
+): Promise<BtwBringToMainChoice> {
+	const answered = getAnsweredTurns(thread.turns);
+	if (answered.length === 0) return { kind: "back" };
+	const showMenu = dependencies.showMenu ?? showBtwMenu;
+	const showPreview = dependencies.showPreview ?? showBringToMainPreview;
+	const makeChoice = (segments: readonly BtwBringToMainSegment[]) => ({
+		kind: "bringToMain" as const,
+		draft: formatBtwBringToMain(segments),
+		summary: summarizeBringToMain(segments),
+	});
+
+	const latestSegments = buildQuickBringToMainSegments(thread.turns, { kind: "latest" });
+	const entireSegments = buildQuickBringToMainSegments(thread.turns, { kind: "entire" });
+	const latestOption = `Latest question and answer  1 Q&A · ~${estimateBringToMainTokens(latestSegments)} tokens`;
+	const fromOption = "From a question onward…  Choose a starting question";
+	const exactOption = "Select exact text…  Lines or characters";
+	const entireOption = `Entire side thread  ${answered.length} Q&A · ~${estimateBringToMainTokens(entireSegments)} tokens`;
+	const cancelOption = "Cancel  Return to the side thread";
+	let selectedScope: string | undefined;
+
+	while (true) {
+		const scopeResult = await showMenu(
+			ctx,
+			"Bring what back to the main thread?",
+			[latestOption, fromOption, exactOption, entireOption, cancelOption],
+			selectedScope,
+		);
+		if (scopeResult.kind === "close") return { kind: "closed" };
+		if (scopeResult.kind === "back" || scopeResult.value === cancelOption) return { kind: "back" };
+		const scope = scopeResult.value;
+		selectedScope = scope;
+		if (scope === latestOption) return makeChoice(latestSegments);
+		if (scope === entireOption) {
+			const choice = makeChoice(entireSegments);
+			const preview = await showPreview(ctx, choice.draft, choice.summary);
+			if (preview.kind === "close") return { kind: "closed" };
+			if (preview.kind === "back") continue;
+			return choice;
+		}
+		if (scope === fromOption) {
+			const questions = answered.map(
+				(turn, index) => `${index + 1}. ${truncatePreview(sanitizeSingleLine(turn.question))}`,
+			);
+			let selectedQuestion: string | undefined;
+			while (true) {
+				const questionResult = await showMenu(
+					ctx,
+					"Start from which question?",
+					questions,
+					selectedQuestion,
+				);
+				if (questionResult.kind === "close") return { kind: "closed" };
+				if (questionResult.kind === "back") break;
+				const answeredTurnIndex = questions.indexOf(questionResult.value);
+				if (answeredTurnIndex < 0) continue;
+				selectedQuestion = questionResult.value;
+				const choice = makeChoice(
+					buildQuickBringToMainSegments(thread.turns, { kind: "from", answeredTurnIndex }),
+				);
+				const preview = await showPreview(ctx, choice.draft, choice.summary);
+				if (preview.kind === "close") return { kind: "closed" };
+				if (preview.kind === "back") continue;
+				return choice;
+			}
+			continue;
+		}
+
+		if (scope !== exactOption) continue;
+		let selectionState: BtwTextRangeSelectorState | undefined;
+		while (true) {
+			const selectedRange = await showBtwCustomPreservingEditor<BtwBringToMainChoice>(
+				ctx,
+				(tui, theme, keybindings, done) => {
+					let selector: BtwTextRangeSelector;
+					selector = new BtwTextRangeSelector(
+						tui,
+						theme,
+						keybindings,
+						thread.turns,
+						(action) => {
+							if (action.kind === "back") done({ kind: "back" });
+							else if (action.kind === "close") done({ kind: "closed" });
+							else done({ ...makeChoice(action.segments), selectionState: selector.getState() });
+						},
+						selectionState,
+					);
+					return selector;
+				},
+			);
+			if (selectedRange.kind === "closed") return selectedRange;
+			if (selectedRange.kind === "back") break;
+			const preview = await showPreview(ctx, selectedRange.draft, selectedRange.summary);
+			if (preview.kind === "close") return { kind: "closed" };
+			if (preview.kind === "back") {
+				selectionState = selectedRange.selectionState;
+				continue;
+			}
+			return {
+				kind: "bringToMain",
+				draft: selectedRange.draft,
+				summary: selectedRange.summary,
+			};
+		}
+	}
+}
+
+async function showBringToMainPreview(
+	ctx: ExtensionCommandContext,
+	draft: string,
+	summary: BtwBringToMainSummary,
+): Promise<BtwBringToMainPreviewAction> {
+	return showBtwCustomPreservingEditor<BtwBringToMainPreviewAction>(
+		ctx,
+		(tui, theme, keybindings, done) =>
+			new BtwBringToMainPreview(tui, theme, keybindings, draft, summary, done),
+	);
+}
+
+async function showBtwMenu(
+	ctx: ExtensionCommandContext,
+	title: string,
+	options: readonly string[],
+	initialValue?: string,
+): Promise<BtwMenuSelectorAction> {
+	return showBtwCustomPreservingEditor<BtwMenuSelectorAction>(
+		ctx,
+		(tui, theme, keybindings, done) =>
+			new BtwMenuSelector(tui, theme, keybindings, title, options, done, initialValue),
+	);
+}
+
+export async function loadBringToMainDraft(
+	draft: string,
+	ctx: ExtensionCommandContext,
+	summary: BtwBringToMainSummary,
+): Promise<BtwBringToMainDelivery> {
+	const describeContent = () =>
+		`${summary.messages} ${summary.messages === 1 ? "message" : "messages"} (~${summary.tokens} ${summary.tokens === 1 ? "token" : "tokens"})`;
+	const existing = ctx.ui.getEditorText();
+	if (!existing.trim()) {
+		ctx.ui.setEditorText(draft);
+		ctx.ui.notify(
+			`Brought ${describeContent()} to the main editor. Review and submit when ready.`,
+			"info",
+		);
+		return "loaded";
+	}
+
+	const appendOption = "Append after current draft  Recommended";
+	const replaceOption = "⚠ Replace current draft  Discards current editor text";
+	const cancelOption = "Cancel  Return to the side thread";
+	while (true) {
+		const action = await showBtwMenu(ctx, "The main editor already has a draft", [
+			appendOption,
+			replaceOption,
+			cancelOption,
+		]);
+		if (action.kind === "close") return "closed";
+		if (action.kind === "back" || action.value === cancelOption) return "back";
+		if (action.value === appendOption) {
+			ctx.ui.setEditorText(`${ctx.ui.getEditorText()}\n\n${draft}`);
+			ctx.ui.notify(
+				`Appended ${describeContent()} to the existing main-editor draft. Review and submit when ready.`,
+				"info",
+			);
+			return "loaded";
+		}
+		if (action.value !== replaceOption) continue;
+
+		const current = ctx.ui.getEditorText();
+		const characters = [...current].length;
+		const confirmed = await showBtwMenu(
+			ctx,
+			`Replace the current ${characters}-character editor draft?`,
+			["Back  Keep current editor text", "⚠ Replace current draft  Cannot be undone"],
+		);
+		if (confirmed.kind === "close") return "closed";
+		if (confirmed.kind === "back" || confirmed.value === "Back  Keep current editor text") continue;
+		if (confirmed.value !== "⚠ Replace current draft  Cannot be undone") continue;
+		if (ctx.ui.getEditorText() !== current) {
+			ctx.ui.notify(
+				"The main editor changed during confirmation. Review the updated draft and choose again.",
+				"warning",
+			);
+			continue;
+		}
+		ctx.ui.setEditorText(draft);
+		ctx.ui.notify(
+			`Replaced the main-editor draft with ${describeContent()}. Review and submit when ready.`,
+			"info",
+		);
+		return "loaded";
+	}
+}
+
+function truncatePreview(text: string): string {
+	return text.length <= 72 ? text : `${text.slice(0, 69)}…`;
+}
+
 async function askThreadQuestion(
 	thread: SideThread,
 	question: string,
@@ -368,10 +648,14 @@ async function showThreadComposer(
 	thread: SideThread,
 	startAtBottom: boolean,
 	ctx: ExtensionCommandContext,
+	initialQuestion?: string,
 ): Promise<TranscriptPagerAction> {
 	return ctx.ui.custom<TranscriptPagerAction>(
 		(tui, theme, _keybindings, done) =>
-			new BtwTranscriptPager(tui, theme, thread.turns, done, { startAtBottom }),
+			new BtwTranscriptPager(tui, theme, thread.turns, done, {
+				startAtBottom,
+				initialQuestion,
+			}),
 	);
 }
 

package/src/transcript-pager.ts

@@ -25,11 +25,15 @@ const OSC133_MARKERS = ["\u001b]133;A\u0007", "\u001b]133;B\u0007", "\u001b]133;
 // Pi renders a spacer above the custom component and a two-line built-in footer below it.
 const RESERVED_APP_LINES = 3;
 
-export type TranscriptPagerAction = { kind: "submit"; question: string } | { kind: "close" };
+export type TranscriptPagerAction =
+	| { kind: "submit"; question: string }
+	| { kind: "bringToMain"; questionDraft: string }
+	| { kind: "close" };
 
 export class BtwTranscriptPager implements Component {
 	private readonly transcriptComponents: Component[];
 	private readonly editor: Editor;
+	private readonly canBringToMain: boolean;
 	private scrollOffset = 0;
 	private lastContentLineCount = 0;
 	private lastViewportHeight = 1;
@@ -43,9 +47,10 @@ export class BtwTranscriptPager implements Component {
 		private readonly theme: Theme,
 		turns: readonly SideThreadTurn[],
 		private readonly onAction: (action: TranscriptPagerAction) => void,
-		options: { startAtBottom?: boolean } = {},
+		options: { startAtBottom?: boolean; initialQuestion?: string } = {},
 	) {
 		this.transcriptComponents = buildTranscriptComponents(turns, this.theme);
+		this.canBringToMain = turns.some((turn) => turn.kind === "answered");
 		this.followBottom = options.startAtBottom ?? false;
 		const editorTheme: EditorTheme = {
 			borderColor: (text) => this.theme.fg("accent", text),
@@ -58,6 +63,7 @@ export class BtwTranscriptPager implements Component {
 			},
 		};
 		this.editor = new Editor(this.tui, editorTheme);
+		if (options.initialQuestion) this.editor.setText(options.initialQuestion);
 		this.editor.onChange = () => {
 			this.warning = undefined;
 		};
@@ -111,6 +117,11 @@ export class BtwTranscriptPager implements Component {
 			this.onAction({ kind: "close" });
 			return;
 		}
+		if (this.canBringToMain && matchesKey(data, Key.ctrl("r"))) {
+			this.finished = true;
+			this.onAction({ kind: "bringToMain", questionDraft: this.editor.getExpandedText() });
+			return;
+		}
 		if (matchesKey(data, Key.pageUp)) {
 			const previousOffset = this.scrollOffset;
 			this.scrollBy(-this.lastViewportHeight);
@@ -139,18 +150,33 @@ export class BtwTranscriptPager implements Component {
 			return truncateToWidth(this.theme.fg("warning", warning), width);
 		}
 		const scrollable = this.getMaxScrollOffset() > 0;
-		const fullBase = "btw • Enter send • Ctrl+C exit";
-		const compactBase = "btw • Enter • Ctrl+C";
-		let hints = visibleWidth(fullBase) <= width ? fullBase : compactBase;
+		const fullBase = this.canBringToMain
+			? "btw • Enter send • Ctrl+R bring to main • Ctrl+C exit"
+			: "btw • Enter send • Ctrl+C exit";
+		const fallbackBase = "btw • Enter • Ctrl+C";
+		const compactBase = this.canBringToMain ? "btw • Enter • Ctrl+R • Ctrl+C" : fallbackBase;
+		let hints =
+			visibleWidth(fullBase) <= width
+				? fullBase
+				: visibleWidth(compactBase) <= width
+					? compactBase
+					: fallbackBase;
 		if (scrollable) {
 			const history = ` • ${this.scrollOffset > 0 ? "↑ older" : "↓ newer"} • PgUp/PgDn history`;
 			const compactHistory = " • PgUp/PgDn";
+			const compactScrollable = this.canBringToMain
+				? "Enter • Ctrl+R • Ctrl+C • PgUp/PgDn"
+				: `${fallbackBase}${compactHistory}`;
 			if (visibleWidth(`${hints}${history}`) <= width) {
 				hints += history;
+			} else if (visibleWidth(`${compactBase}${history}`) <= width) {
+				hints = `${compactBase}${history}`;
 			} else if (visibleWidth(`${hints}${compactHistory}`) <= width) {
 				hints += compactHistory;
 			} else if (visibleWidth(`${compactBase}${compactHistory}`) <= width) {
 				hints = `${compactBase}${compactHistory}`;
+			} else if (visibleWidth(compactScrollable) <= width) {
+				hints = compactScrollable;
 			}
 		}
 		return truncateToWidth(this.theme.fg("muted", hints), width);