@narumitw/pi-btw 0.52.0 → 0.54.0

package/README.md

@@ -8,7 +8,8 @@ Use it when you want to ask a temporary question, inspect context, or get a shor
 
 ## ✨ Features
 
-- Adds a `/btw` menu for starting or resuming an in-memory side thread or changing pi-btw settings.
+- Adds a `/btw` menu for starting or resuming an in-memory side thread, choosing context from the main session tree, or changing pi-btw settings.
+- Starts a fresh side thread from any persisted main-session branch without switching the main branch.
 - 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.
@@ -59,6 +60,11 @@ Examples:
 ```
 
 Running `/btw` alone opens a menu with **Start side thread** selected first.
+**Start from main thread tree…** opens Pi's native session tree and uses the root-to-selected-entry path, including the selected entry, as the new side thread's context.
+Selecting context does not navigate, fork, append to, or switch the main conversation, and it preserves the main editor draft.
+The selector is a snapshot of entries persisted when it opens, while the resulting side thread keeps an immutable context snapshot even if the main conversation later changes.
+Press `Escape` to return to the `/btw` menu or `Ctrl+C` to close the flow.
+The native tree controls remain available: copying reports success or failure, and an explicit `Shift+L` label edit persists through Pi as the only main-session mutation available from this selector.
 When the current Pi session has non-empty side threads in memory, **Resume side thread** opens a bounded searchable choice list.
 Search matches the displayed first question and question count while returning the thread's raw in-memory ID.
 **Settings** changes the starting thinking level and whether shortcut changes for fixed levels are remembered.
@@ -90,10 +96,12 @@ Type another question and press `Enter` to queue it as `Steering`; queued questi
 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.
+Use the mouse wheel or trackpad to scroll transcript history like Pi's main thread.
+Keyboard `PgUp`/`PgDn` history navigation remains available.
+It appears in the footer only when the transcript 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
@@ -188,6 +196,7 @@ packages/pi-btw/
 │   ├── index.ts
 │   ├── btw.ts
 │   ├── bring-to-main.ts
+│   ├── main-tree-picker.ts
 │   ├── menu.ts
 │   ├── settings.ts
 │   ├── side-thread.ts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-btw",
-	"version": "0.52.0",
+	"version": "0.54.0",
 	"description": "Pi extension that adds a /btw side-question command.",
 	"type": "module",
 	"license": "MIT",
@@ -43,7 +43,7 @@
 		"directory": "packages/pi-btw"
 	},
 	"dependencies": {
-		"@narumitw/pi-tui-kit": "^0.54.0"
+		"@narumitw/pi-tui-kit": "^0.55.0"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",

package/src/btw.ts

@@ -9,10 +9,7 @@ import {
 	BorderedLoader,
 	type ExtensionAPI,
 	type ExtensionCommandContext,
-	type KeybindingsManager,
-	type Theme,
 } from "@earendil-works/pi-coding-agent";
-import type { Component, TUI } from "@earendil-works/pi-tui";
 import type { MenuContext, RunMenuResult } from "@narumitw/pi-tui-kit";
 import {
 	type BtwBringToMainSegment,
@@ -26,11 +23,13 @@ import {
 	summarizeBringToMain,
 } from "./bring-to-main.js";
 import { type RunBtwFullscreen, runBtwFullscreen } from "./fullscreen-ui.js";
+import { pickMainEntry } from "./main-tree-picker.js";
 import {
 	type BtwCommandMenuResult,
 	type BtwResumeThreadSummary,
 	runBtwMenuPreservingEditor,
 	showBtwCommandMenu,
+	showBtwCustomPreservingEditor,
 } from "./menu.js";
 import {
 	type BtwSettings,
@@ -222,6 +221,7 @@ export interface BtwExtensionDependencies {
 		ctx: ExtensionCommandContext,
 		resumeThreads: readonly BtwResumeThreadSummary[],
 	) => Promise<BtwCommandMenuResult>;
+	pickMainEntry?: typeof pickMainEntry;
 	loadSettings?: typeof loadSettingsForCommand;
 	resolveModel?: typeof resolveBtwModelWithLoader;
 	runThread?: typeof runBtwThread;
@@ -230,6 +230,7 @@ export interface BtwExtensionDependencies {
 
 export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependencies = {}) {
 	const showCommandMenu = dependencies.showCommandMenu ?? showCommandMenuForBtw;
+	const pickEntry = dependencies.pickMainEntry ?? pickMainEntry;
 	const loadSettings = dependencies.loadSettings ?? loadSettingsForCommand;
 	const resolveModel = dependencies.resolveModel ?? resolveBtwModelWithLoader;
 	const runThread = dependencies.runThread ?? runBtwThread;
@@ -259,9 +260,37 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 			}
 
 			let menuResult: BtwCommandMenuResult = "start";
+			let selectedConversationContext: string | undefined;
 			if (!question) {
-				menuResult = await showCommandMenu(pi, ctx, listResumeThreads());
-				if (menuResult === "closed") return;
+				while (true) {
+					menuResult = await showCommandMenu(pi, ctx, listResumeThreads());
+					if (menuResult === "closed") return;
+					if (menuResult !== "tree") break;
+
+					const treeResult = await pickEntry(pi, ctx);
+					if (treeResult.kind === "closed") return;
+					if (treeResult.kind === "back") continue;
+					try {
+						if (!ctx.sessionManager.getEntry(treeResult.entryId)) {
+							notifySafely(ctx, "The selected main-thread entry is no longer available", "warning");
+							continue;
+						}
+						const branch = ctx.sessionManager.getBranch(treeResult.entryId);
+						if (branch.at(-1)?.id !== treeResult.entryId) {
+							notifySafely(
+								ctx,
+								"The selected main-thread branch is no longer available",
+								"warning",
+							);
+							continue;
+						}
+						selectedConversationContext = buildConversationContext(branch);
+						menuResult = "start";
+						break;
+					} catch {
+						return;
+					}
+				}
 			}
 
 			const settings = await loadSettings(ctx);
@@ -291,7 +320,8 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 						state = {
 							id: `btw-${nextThreadNumber}`,
 							thread: createSideThread(
-								buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
+								selectedConversationContext ??
+									buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
 							),
 							thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
 							createdAt,
@@ -546,40 +576,6 @@ 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 | undefined> {
-	let liveEditorText = ctx.ui.getEditorText();
-	let completed = false;
-	const result = await ctx.ui.custom<T>((tui, theme, keybindings, done) =>
-		factory(tui, theme, keybindings, (value) => {
-			try {
-				liveEditorText = ctx.ui.getEditorText();
-			} catch {
-				// Keep completion finite if session replacement invalidates the editor context.
-			}
-			completed = true;
-			done(value);
-		}),
-	);
-	if (completed) {
-		try {
-			if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
-		} catch {
-			// A replaced context owns a different editor and must not receive stale restoration.
-		}
-	}
-	return result;
-}
-
 interface ChooseBringToMainDependencies {
 	showMenu?: typeof showBtwMenu;
 	showPreview?: typeof showBringToMainPreview;

package/src/fullscreen-ui.ts

@@ -21,7 +21,14 @@ type BtwCustomFactory<T> = (
 	done: (result: T) => void,
 ) => (Component & { dispose?(): void }) | Promise<Component & { dispose?(): void }>;
 
-type BtwFullscreenTui = TUI & { flash?: (message: string, durationMs?: number) => void };
+type BtwFullscreenTui = TUI & {
+	flash?: (message: string, durationMs?: number) => void;
+	setLayoutRoot(component: Component | undefined): void;
+};
+
+export interface BtwFullscreenLayoutComponent extends Component {
+	getFullscreenLayout(): Component;
+}
 
 export type BtwFullscreenTuiFactory = (parent: TUI) => BtwFullscreenTui;
 
@@ -223,6 +230,7 @@ class BtwFullscreenHost<T> implements Component {
 			let component: (Component & { dispose?(): void }) | undefined;
 			let overlay: OverlayHandle | undefined;
 			let mounted = false;
+			let layoutMounted = false;
 			let factorySettled = false;
 			let closed = false;
 			let promiseSettled = false;
@@ -243,6 +251,7 @@ class BtwFullscreenHost<T> implements Component {
 				let cleanupError: unknown;
 				try {
 					if (overlay) overlay.hide();
+					else if (mounted && layoutMounted) fullscreen.setLayoutRoot(undefined);
 					else if (mounted && component) fullscreen.removeChild(component);
 				} catch (error) {
 					cleanupError = error;
@@ -327,8 +336,13 @@ class BtwFullscreenHost<T> implements Component {
 						options.onHandle?.(overlay);
 					} else {
 						fullscreen.clear();
-						fullscreen.addChild(component);
 						mounted = true;
+						if (isFullscreenLayoutComponent(component)) {
+							layoutMounted = true;
+							fullscreen.setLayoutRoot(component.getFullscreenLayout());
+						} else {
+							fullscreen.addChild(component);
+						}
 						fullscreen.setFocus(component);
 						fullscreen.requestRender();
 					}
@@ -337,3 +351,9 @@ class BtwFullscreenHost<T> implements Component {
 		});
 	}
 }
+
+function isFullscreenLayoutComponent(
+	component: Component,
+): component is BtwFullscreenLayoutComponent {
+	return "getFullscreenLayout" in component && typeof component.getFullscreenLayout === "function";
+}

package/src/main-tree-picker.ts

@@ -0,0 +1,390 @@
+import {
+	copyToClipboard,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+	type SessionEntry,
+	type SessionTreeNode,
+	TreeSelectorComponent,
+} from "@earendil-works/pi-coding-agent";
+import { type Component, type Focusable, Key, matchesKey } from "@earendil-works/pi-tui";
+import { showBtwCustomPreservingEditor } from "./menu.js";
+import { sanitizeSingleLine } from "./text.js";
+
+export type MainEntryPickResult =
+	| { kind: "selected"; entryId: string }
+	| { kind: "back" }
+	| { kind: "closed" };
+
+export interface MainThreadTreeSelector extends Component, Focusable {
+	onCopy?: (text: string | undefined) => void;
+	setViewLabel?(entryId: string, label: string | undefined, labelTimestamp?: string): void;
+	dispose?(): void;
+}
+
+export interface MainThreadTreeSelectorOptions {
+	tree: SessionTreeNode[];
+	currentLeafId: string | null;
+	terminalRows: number;
+	onSelect: (entryId: string) => void;
+	onCancel: () => void;
+	onCopy: (entryId: string | undefined, displayText: string | undefined) => void;
+	onLabelChange: (entryId: string, label: string | undefined) => void;
+}
+
+export interface MainThreadTreePickerDependencies {
+	createSelector?: (options: MainThreadTreeSelectorOptions) => MainThreadTreeSelector;
+	copyToClipboard?: (text: string, signal: AbortSignal) => Promise<void>;
+}
+
+class MainThreadTreePickerComponent implements Component, Focusable {
+	constructor(
+		private readonly selector: MainThreadTreeSelector,
+		private readonly onClose: () => void,
+	) {}
+
+	get focused(): boolean {
+		return this.selector.focused;
+	}
+
+	set focused(value: boolean) {
+		this.selector.focused = value;
+	}
+
+	get wantsKeyRelease(): boolean | undefined {
+		return this.selector.wantsKeyRelease;
+	}
+
+	render(width: number): string[] {
+		return this.selector.render(width);
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.ctrl("c"))) {
+			this.onClose();
+			return;
+		}
+		this.selector.handleInput?.(data);
+	}
+
+	invalidate(): void {
+		this.selector.invalidate();
+	}
+
+	dispose(): void {
+		this.selector.dispose?.();
+		this.onClose();
+	}
+}
+
+export async function pickMainEntry(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	dependencies: MainThreadTreePickerDependencies = {},
+): Promise<MainEntryPickResult> {
+	let rawTree: SessionTreeNode[];
+	let currentLeafId: string | null;
+	try {
+		rawTree = ctx.sessionManager.getTree();
+		currentLeafId = ctx.sessionManager.getLeafId();
+	} catch {
+		return { kind: "closed" };
+	}
+
+	if (rawTree.length === 0) {
+		notifySafely(ctx, "No main-thread entries are available", "warning");
+		return { kind: "back" };
+	}
+
+	const tree = sanitizeTreeForDisplay(rawTree);
+	const rawCopyText = collectRawCopyText(rawTree);
+	const savedLabels = collectSavedLabels(rawTree);
+	const createSelector = dependencies.createSelector ?? createNativeTreeSelector;
+	const copy = dependencies.copyToClipboard ?? copyText;
+	const copyControllers = new Set<AbortController>();
+	const copyTasks = new Set<Promise<void>>();
+	const abortCopies = () => {
+		for (const controller of copyControllers) {
+			controller.abort(new Error("The main-thread tree picker closed"));
+		}
+	};
+	const result = await showBtwCustomPreservingEditor<MainEntryPickResult>(
+		ctx,
+		(tui, _theme, _keybindings, done) => {
+			let settled = false;
+			let selector: MainThreadTreeSelector | undefined;
+			const finish = (value: MainEntryPickResult) => {
+				if (settled) return;
+				settled = true;
+				abortCopies();
+				done(value);
+			};
+			const onCopy = (entryId: string | undefined, displayText: string | undefined) => {
+				if (settled) return;
+				const text = entryId ? rawCopyText.get(entryId) : displayText;
+				if (!text) {
+					notifySafely(ctx, "Selected entry has no text to copy", "warning");
+					return;
+				}
+				const controller = new AbortController();
+				copyControllers.add(controller);
+				let operation: Promise<void>;
+				try {
+					operation = copy(text, controller.signal);
+				} catch (error: unknown) {
+					operation = Promise.reject(error);
+				}
+				let task!: Promise<void>;
+				task = operation
+					.then(() => {
+						if (!settled) notifySafely(ctx, "Copied selected message", "info");
+					})
+					.catch((error: unknown) => {
+						if (!settled && !controller.signal.aborted) {
+							notifySafely(ctx, `Could not copy selected message: ${formatError(error)}`, "error");
+						}
+					})
+					.finally(() => {
+						copyControllers.delete(controller);
+						copyTasks.delete(task);
+					});
+				copyTasks.add(task);
+			};
+			const restoreLabel = (entryId: string) => {
+				const previous = savedLabels.get(entryId);
+				selector?.setViewLabel?.(entryId, previous?.label, previous?.labelTimestamp);
+				tui.requestRender();
+			};
+			const onLabelChange = (entryId: string, label: string | undefined) => {
+				if (settled) return;
+				try {
+					if (!ctx.sessionManager.getEntry(entryId)) {
+						restoreLabel(entryId);
+						notifySafely(ctx, "The selected main-thread entry is no longer available", "warning");
+						return;
+					}
+					const persistedLabel = label === undefined ? undefined : sanitizeSingleLine(label);
+					pi.setLabel(entryId, persistedLabel);
+					savedLabels.set(entryId, { label: persistedLabel });
+					selector?.setViewLabel?.(entryId, persistedLabel);
+					tui.requestRender();
+				} catch (error: unknown) {
+					restoreLabel(entryId);
+					notifySafely(ctx, `Could not update tree label: ${formatError(error)}`, "error");
+				}
+			};
+			selector = createSelector({
+				tree,
+				currentLeafId,
+				terminalRows: tui.terminal.rows,
+				onSelect: (entryId) => finish({ kind: "selected", entryId }),
+				onCancel: () => finish({ kind: "back" }),
+				onCopy,
+				onLabelChange,
+			});
+			return new MainThreadTreePickerComponent(selector, () => finish({ kind: "closed" }));
+		},
+	);
+	abortCopies();
+	await Promise.allSettled([...copyTasks]);
+
+	return result ?? { kind: "closed" };
+}
+
+function createNativeTreeSelector(options: MainThreadTreeSelectorOptions): MainThreadTreeSelector {
+	const selector = new TreeSelectorComponent(
+		options.tree,
+		options.currentLeafId,
+		options.terminalRows,
+		options.onSelect,
+		options.onCancel,
+		options.onLabelChange,
+	);
+	selector.onCopy = (displayText) =>
+		options.onCopy(selector.getTreeList().getSelectedNode()?.entry.id, displayText);
+	const result = selector as MainThreadTreeSelector;
+	result.setViewLabel = (entryId, label, labelTimestamp) =>
+		selector.getTreeList().updateNodeLabel(entryId, label, labelTimestamp);
+	return result;
+}
+
+function sanitizeTreeForDisplay(tree: readonly SessionTreeNode[]): SessionTreeNode[] {
+	return tree.map((node) => {
+		const result: SessionTreeNode = {
+			entry: sanitizeEntryForDisplay(node.entry),
+			children: sanitizeTreeForDisplay(node.children),
+		};
+		if (node.label !== undefined) result.label = sanitizeSingleLine(node.label);
+		if (node.labelTimestamp !== undefined) {
+			result.labelTimestamp = sanitizeSingleLine(node.labelTimestamp);
+		}
+		return result;
+	});
+}
+
+function sanitizeEntryForDisplay(entry: SessionEntry): SessionEntry {
+	switch (entry.type) {
+		case "message": {
+			const message = { ...entry.message } as Record<string, unknown>;
+			if ("content" in entry.message)
+				message.content = sanitizeDisplayContent(entry.message.content);
+			for (const key of ["role", "errorMessage", "command", "toolName"] as const) {
+				const value = message[key];
+				if (typeof value === "string") message[key] = sanitizeSingleLine(value);
+			}
+			return { ...entry, message } as unknown as SessionEntry;
+		}
+		case "custom_message":
+			return {
+				...entry,
+				customType: sanitizeSingleLine(entry.customType),
+				content: sanitizeDisplayContent(entry.content) as typeof entry.content,
+			};
+		case "compaction":
+			return { ...entry, summary: sanitizeSingleLine(entry.summary) };
+		case "branch_summary":
+			return { ...entry, summary: sanitizeSingleLine(entry.summary) };
+		case "model_change":
+			return {
+				...entry,
+				provider: sanitizeSingleLine(entry.provider),
+				modelId: sanitizeSingleLine(entry.modelId),
+			};
+		case "thinking_level_change":
+			return { ...entry, thinkingLevel: sanitizeSingleLine(entry.thinkingLevel) };
+		case "custom":
+			return { ...entry, customType: sanitizeSingleLine(entry.customType) };
+		case "label":
+			return {
+				...entry,
+				label: entry.label === undefined ? undefined : sanitizeSingleLine(entry.label),
+			};
+		case "session_info":
+			return {
+				...entry,
+				name: entry.name === undefined ? undefined : sanitizeSingleLine(entry.name),
+			};
+	}
+}
+
+function sanitizeDisplayContent(content: unknown): unknown {
+	if (typeof content === "string") return sanitizeSingleLine(content);
+	if (!Array.isArray(content)) return content;
+	return content.map((block) => {
+		if (block === null || typeof block !== "object" || !("type" in block)) return block;
+		if (block.type === "text" && "text" in block && typeof block.text === "string") {
+			return { ...block, text: sanitizeSingleLine(block.text) };
+		}
+		if (block.type === "toolCall") {
+			const copy = { ...block } as Record<string, unknown>;
+			if (typeof copy.name === "string") copy.name = sanitizeSingleLine(copy.name);
+			copy.arguments = sanitizeToolArguments(copy.arguments, new WeakMap());
+			return copy;
+		}
+		return block;
+	});
+}
+
+function sanitizeToolArguments(value: unknown, seen: WeakMap<object, unknown>): unknown {
+	if (typeof value === "string") return sanitizeSingleLine(value);
+	if (value === null || typeof value !== "object") return value;
+	const existing = seen.get(value);
+	if (existing !== undefined) return existing;
+	if (Array.isArray(value)) {
+		const result: unknown[] = [];
+		seen.set(value, result);
+		for (const item of value) result.push(sanitizeToolArguments(item, seen));
+		return result;
+	}
+	const result: Record<string, unknown> = {};
+	seen.set(value, result);
+	for (const [key, item] of Object.entries(value)) {
+		result[key] = sanitizeToolArguments(item, seen);
+	}
+	return result;
+}
+
+function collectRawCopyText(tree: readonly SessionTreeNode[]): Map<string, string> {
+	const result = new Map<string, string>();
+	const visit = (nodes: readonly SessionTreeNode[]) => {
+		for (const node of nodes) {
+			const text = getRawCopyText(node.entry);
+			if (text !== undefined) result.set(node.entry.id, text);
+			visit(node.children);
+		}
+	};
+	visit(tree);
+	return result;
+}
+
+function getRawCopyText(entry: SessionEntry): string | undefined {
+	let text: string | undefined;
+	if (entry.type === "message") {
+		if (entry.message.role === "bashExecution") text = entry.message.command;
+		else if ("content" in entry.message) {
+			text = extractRawText(entry.message.content);
+			if (!text && entry.message.role === "assistant") text = entry.message.errorMessage;
+		}
+	} else if (entry.type === "custom_message") text = extractRawText(entry.content);
+	else if (entry.type === "compaction" || entry.type === "branch_summary") text = entry.summary;
+	return text?.trim() ? text : undefined;
+}
+
+function extractRawText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter(
+			(block): block is { type: "text"; text: string } =>
+				block !== null &&
+				typeof block === "object" &&
+				"type" in block &&
+				block.type === "text" &&
+				"text" in block &&
+				typeof block.text === "string",
+		)
+		.map((block) => block.text)
+		.join("");
+}
+
+interface SavedLabel {
+	label: string | undefined;
+	labelTimestamp?: string;
+}
+
+function collectSavedLabels(tree: readonly SessionTreeNode[]): Map<string, SavedLabel> {
+	const result = new Map<string, SavedLabel>();
+	const visit = (nodes: readonly SessionTreeNode[]) => {
+		for (const node of nodes) {
+			result.set(node.entry.id, {
+				label: node.label === undefined ? undefined : sanitizeSingleLine(node.label),
+				labelTimestamp:
+					node.labelTimestamp === undefined ? undefined : sanitizeSingleLine(node.labelTimestamp),
+			});
+			visit(node.children);
+		}
+	};
+	visit(tree);
+	return result;
+}
+
+async function copyText(text: string, signal: AbortSignal): Promise<void> {
+	signal.throwIfAborted();
+	await copyToClipboard(text);
+	signal.throwIfAborted();
+}
+
+function notifySafely(
+	ctx: ExtensionCommandContext,
+	message: string,
+	level: Parameters<ExtensionCommandContext["ui"]["notify"]>[1],
+): void {
+	try {
+		ctx.ui.notify(sanitizeSingleLine(message), level);
+	} catch {
+		// The command context may have been replaced while the selector was open.
+	}
+}
+
+function formatError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/menu.ts

@@ -41,10 +41,14 @@ export interface ShowBtwCommandMenuOptions {
 	) => Promise<BtwSettings>;
 }
 
-export type BtwCommandMenuResult = "start" | "closed" | { kind: "resume"; threadId: string };
+export type BtwCommandMenuResult =
+	| "start"
+	| "tree"
+	| "closed"
+	| { kind: "resume"; threadId: string };
 
 type BtwMenuScreen = "main" | "resume" | "settings" | "invalid";
-type BtwMenuAction = "start" | "resume" | "set-thinking" | "set-remember";
+type BtwMenuAction = "start" | "start-tree" | "resume" | "set-thinking" | "set-remember";
 const SAME_AS_MAIN_THREAD = "Same as main thread";
 type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
 
@@ -72,6 +76,7 @@ export async function showBtwCommandMenu(
 	const displaySettingsPath = sanitizeSingleLine(settingsPath);
 	const resumeThreads = options.resumeThreads ?? [];
 	let startSelected = false;
+	let treeSelected = false;
 	let resumedThreadId: string | undefined;
 
 	const loadState = async (): Promise<BtwMenuState> => {
@@ -114,6 +119,12 @@ export async function showBtwCommandMenu(
 						description: "Open an empty side thread",
 						action: "start",
 					},
+					{
+						id: "start-tree",
+						label: "Start from main thread tree…",
+						description: "Choose context without switching the main branch",
+						action: "start-tree",
+					},
 					...(resumeThreads.length > 0
 						? [
 								{
@@ -184,6 +195,10 @@ export async function showBtwCommandMenu(
 				startSelected = true;
 				return { kind: "close" };
 			},
+			"start-tree": async () => {
+				treeSelected = true;
+				return { kind: "close" };
+			},
 			resume: async ({ itemId }: { itemId: string }) => {
 				if (!resumeThreads.some((thread) => thread.id === itemId)) {
 					return { kind: "rejected" } as const;
@@ -233,9 +248,37 @@ export async function showBtwCommandMenu(
 	);
 	if (result.kind !== "closed" || result.reason !== "close") return "closed";
 	if (resumedThreadId) return { kind: "resume", threadId: resumedThreadId };
+	if (treeSelected) return "tree";
 	return startSelected ? "start" : "closed";
 }
 
+export async function showBtwCustomPreservingEditor<T>(
+	ctx: ExtensionCommandContext,
+	factory: BtwCustomFactory<T>,
+): Promise<T | undefined> {
+	let liveEditorText = ctx.ui.getEditorText();
+	let completed = false;
+	const result = await ctx.ui.custom<T>((tui, theme, keybindings, done) =>
+		factory(tui, theme, keybindings, (value) => {
+			try {
+				liveEditorText = ctx.ui.getEditorText();
+			} catch {
+				// Keep completion finite if session replacement invalidates the editor context.
+			}
+			completed = true;
+			done(value);
+		}),
+	);
+	if (completed) {
+		try {
+			if (ctx.ui.getEditorText() !== liveEditorText) ctx.ui.setEditorText(liveEditorText);
+		} catch {
+			// A replaced context owns a different editor and must not receive stale restoration.
+		}
+	}
+	return result;
+}
+
 export async function runBtwMenuPreservingEditor(
 	ctx: ExtensionCommandContext,
 	run: (menuContext: MenuContext) => Promise<RunMenuResult>,

package/src/transcript-pager.ts

@@ -16,10 +16,13 @@ import {
 	Loader,
 	Markdown,
 	matchesKey,
+	ScrollView,
 	type TUI,
 	truncateToWidth,
+	VStack,
 	visibleWidth,
 } from "@earendil-works/pi-tui";
+import type { BtwFullscreenLayoutComponent } from "./fullscreen-ui.js";
 import type { BtwThinkingLevel, SideThreadTurn } from "./side-thread.js";
 import { sanitizeSingleLine } from "./text.js";
 
@@ -29,6 +32,21 @@ 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;
 
+// A temporary fit after manual scrolling must not silently resume following new output.
+class PreservingScrollView extends ScrollView {
+	override updateLayout(
+		contentHeight: number,
+		viewportHeight: number,
+		requestRender: () => void,
+	): void {
+		const preserveManualPosition = !this.isFollowingEnd;
+		super.updateLayout(contentHeight, viewportHeight, requestRender);
+		if (preserveManualPosition && this.isFollowingEnd) {
+			this.scrollTo(this.scrollTop, { disableFollow: true });
+		}
+	}
+}
+
 export type TranscriptPagerAction =
 	| { kind: "submit"; question: string }
 	| { kind: "bringToMain"; questionDraft: string }
@@ -49,14 +67,13 @@ export interface BtwAnsweringViewOptions {
 	};
 }
 
-export class BtwTranscriptPager implements Component, Focusable {
+export class BtwTranscriptPager implements BtwFullscreenLayoutComponent, Focusable {
 	private readonly transcriptComponents: Component[];
 	private readonly editor: Editor;
 	private readonly canBringToMain: boolean;
-	private scrollOffset = 0;
+	private readonly scrollView: ScrollView;
+	private readonly layoutRoot: VStack;
 	private lastContentLineCount = 0;
-	private lastViewportHeight = 1;
-	private followBottom: boolean;
 	private warning: string | undefined;
 	private finished = false;
 	private isFocused = false;
@@ -75,7 +92,6 @@ export class BtwTranscriptPager implements Component, Focusable {
 	) {
 		this.transcriptComponents = buildTranscriptComponents(turns, this.theme);
 		this.canBringToMain = turns.some((turn) => turn.kind === "answered");
-		this.followBottom = options.startAtBottom ?? false;
 		this.thinkingLevel = options.thinking?.level;
 		const editorTheme: EditorTheme = {
 			borderColor: (text) => this.theme.fg("accent", text),
@@ -101,6 +117,17 @@ export class BtwTranscriptPager implements Component, Focusable {
 			this.finished = true;
 			this.onAction({ kind: "submit", question });
 		};
+		const transcript = this.createTranscriptComponent();
+		this.scrollView = new PreservingScrollView(transcript, {
+			follow: options.startAtBottom ? "end" : "none",
+			primary: true,
+		});
+		this.layoutRoot = new VStack([
+			{ component: this.createHeaderComponent(), basis: 1, shrink: 0, minSize: 1 },
+			{ component: this.scrollView, basis: 0, grow: 1, minSize: 0 },
+			{ component: this.createFooterComponent(), basis: 1, shrink: 0, minSize: 1 },
+			{ component: this.editor, basis: "auto", shrink: 1, minSize: 0 },
+		]);
 	}
 
 	get focused(): boolean {
@@ -112,6 +139,10 @@ export class BtwTranscriptPager implements Component, Focusable {
 		this.editor.focused = value;
 	}
 
+	getFullscreenLayout(): Component {
+		return this.layoutRoot;
+	}
+
 	render(width: number): string[] {
 		const safeWidth = Math.max(1, width);
 		const editorLines = this.editor.render(safeWidth);
@@ -122,13 +153,13 @@ export class BtwTranscriptPager implements Component, Focusable {
 		);
 		const contentLines = renderTranscriptLines(this.transcriptComponents, safeWidth);
 		this.lastContentLineCount = contentLines.length;
-		this.lastViewportHeight = viewportHeight;
-		if (this.followBottom) this.scrollOffset = this.getMaxScrollOffset();
-		this.clampScrollOffset();
+		this.scrollView.updateLayout(contentLines.length, viewportHeight, () =>
+			this.tui.requestRender(),
+		);
 
 		return fitComposerLayout(
 			renderSideThreadHeader(safeWidth, this.theme, this.thinkingLevel),
-			contentLines.slice(this.scrollOffset, this.scrollOffset + viewportHeight),
+			contentLines.slice(this.scrollView.scrollTop, this.scrollView.scrollTop + viewportHeight),
 			this.renderFooter(safeWidth),
 			editorLines,
 			availableRows,
@@ -164,15 +195,12 @@ export class BtwTranscriptPager implements Component, Focusable {
 			return;
 		}
 		if (matchesKey(data, Key.pageUp)) {
-			const previousOffset = this.scrollOffset;
-			this.scrollBy(-this.lastViewportHeight);
-			if (this.scrollOffset < previousOffset) this.followBottom = false;
+			this.scrollView.scrollBy(-Math.max(1, this.scrollView.viewportHeight));
 			this.tui.requestRender();
 			return;
 		}
 		if (matchesKey(data, Key.pageDown)) {
-			this.scrollBy(this.lastViewportHeight);
-			this.followBottom = this.scrollOffset >= this.getMaxScrollOffset();
+			this.scrollView.scrollBy(Math.max(1, this.scrollView.viewportHeight));
 			this.tui.requestRender();
 			return;
 		}
@@ -181,8 +209,7 @@ export class BtwTranscriptPager implements Component, Focusable {
 	}
 
 	invalidate(): void {
-		for (const component of this.transcriptComponents) component.invalidate();
-		this.editor.invalidate();
+		this.layoutRoot.invalidate();
 	}
 
 	dispose(): void {
@@ -218,7 +245,7 @@ export class BtwTranscriptPager implements Component, Focusable {
 						? compactBase
 						: fallbackBase;
 		if (scrollable) {
-			const history = ` • ${this.scrollOffset > 0 ? "↑ older" : "↓ newer"} • PgUp/PgDn history`;
+			const history = ` • ${this.scrollView.scrollTop > 0 ? "↑ older" : "↓ newer"} • PgUp/PgDn history`;
 			const compactHistory = " • PgUp/PgDn";
 			const compactScrollable = this.canBringToMain
 				? "Enter • Ctrl+R • Ctrl+C • PgUp/PgDn"
@@ -238,29 +265,46 @@ export class BtwTranscriptPager implements Component, Focusable {
 		return truncateToWidth(this.theme.fg("muted", hints), width);
 	}
 
-	private scrollBy(delta: number): void {
-		this.scrollOffset += delta;
-		this.clampScrollOffset();
+	private createHeaderComponent(): Component {
+		return {
+			render: (width) => [renderSideThreadHeader(width, this.theme, this.thinkingLevel)],
+			invalidate() {},
+		};
 	}
 
-	private clampScrollOffset(): void {
-		this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, this.getMaxScrollOffset()));
+	private createTranscriptComponent(): Component {
+		return {
+			render: (width) => {
+				const lines = renderTranscriptLines(this.transcriptComponents, width);
+				this.lastContentLineCount = lines.length;
+				return lines;
+			},
+			invalidate: () => {
+				for (const component of this.transcriptComponents) component.invalidate();
+			},
+		};
+	}
+
+	private createFooterComponent(): Component {
+		return {
+			render: (width) => [this.renderFooter(width)],
+			invalidate() {},
+		};
 	}
 
 	private getMaxScrollOffset(): number {
-		return Math.max(0, this.lastContentLineCount - this.lastViewportHeight);
+		return Math.max(0, this.lastContentLineCount - this.scrollView.viewportHeight);
 	}
 }
 
-export class BtwAnsweringView implements Component, Focusable {
+export class BtwAnsweringView implements BtwFullscreenLayoutComponent, Focusable {
 	private readonly transcriptComponents: Component[];
 	private readonly loader: Loader;
 	private readonly editor: Editor | undefined;
 	private readonly controller = new AbortController();
-	private scrollOffset = 0;
+	private readonly scrollView: ScrollView;
+	private readonly layoutRoot: VStack;
 	private lastContentLineCount = 0;
-	private lastViewportHeight = 1;
-	private followBottom = true;
 	private warning: string | undefined;
 	private finished = false;
 	private isFocused = false;
@@ -308,6 +352,23 @@ export class BtwAnsweringView implements Component, Focusable {
 				this.warning = undefined;
 			};
 		}
+		const transcript = this.createTranscriptComponent();
+		this.scrollView = new PreservingScrollView(transcript, { follow: "end", primary: true });
+		this.layoutRoot = new VStack([
+			{ component: this.createHeaderComponent(), basis: 1, shrink: 0, minSize: 1 },
+			{ component: this.scrollView, basis: 0, grow: 1, minSize: 0 },
+			{
+				component: this.createSteeringComponent(),
+				basis: "auto",
+				shrink: 1,
+				minSize: 0,
+				maxSize: MAX_STEERING_DISPLAY_LINES,
+			},
+			{ component: this.createFooterComponent(), basis: 1, shrink: 0, minSize: 1 },
+			...(this.editor
+				? [{ component: this.editor, basis: "auto" as const, shrink: 1, minSize: 0 }]
+				: []),
+		]);
 	}
 
 	get focused(): boolean {
@@ -323,6 +384,10 @@ export class BtwAnsweringView implements Component, Focusable {
 		return this.controller.signal;
 	}
 
+	getFullscreenLayout(): Component {
+		return this.layoutRoot;
+	}
+
 	render(width: number): string[] {
 		const safeWidth = Math.max(1, width);
 		const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_LINES);
@@ -343,13 +408,13 @@ export class BtwAnsweringView implements Component, Focusable {
 		);
 		const contentLines = renderTranscriptLines(this.transcriptComponents, safeWidth);
 		this.lastContentLineCount = contentLines.length;
-		this.lastViewportHeight = viewportHeight;
-		if (this.followBottom) this.scrollOffset = this.getMaxScrollOffset();
-		this.clampScrollOffset();
+		this.scrollView.updateLayout(contentLines.length, viewportHeight, () =>
+			this.tui.requestRender(),
+		);
 
 		return fitComposerLayout(
 			renderSideThreadHeader(safeWidth, this.theme, this.thinkingLevel),
-			contentLines.slice(this.scrollOffset, this.scrollOffset + viewportHeight),
+			contentLines.slice(this.scrollView.scrollTop, this.scrollView.scrollTop + viewportHeight),
 			this.renderFooter(safeWidth),
 			editorLines,
 			availableRows,
@@ -383,15 +448,12 @@ export class BtwAnsweringView implements Component, Focusable {
 			return;
 		}
 		if (matchesKey(data, Key.pageUp)) {
-			const previousOffset = this.scrollOffset;
-			this.scrollBy(-this.lastViewportHeight);
-			if (this.scrollOffset < previousOffset) this.followBottom = false;
+			this.scrollView.scrollBy(-Math.max(1, this.scrollView.viewportHeight));
 			this.tui.requestRender();
 			return;
 		}
 		if (matchesKey(data, Key.pageDown)) {
-			this.scrollBy(this.lastViewportHeight);
-			this.followBottom = this.scrollOffset >= this.getMaxScrollOffset();
+			this.scrollView.scrollBy(Math.max(1, this.scrollView.viewportHeight));
 			this.tui.requestRender();
 			return;
 		}
@@ -400,9 +462,7 @@ export class BtwAnsweringView implements Component, Focusable {
 	}
 
 	invalidate(): void {
-		for (const component of this.transcriptComponents) component.invalidate();
-		this.loader.invalidate();
-		this.editor?.invalidate();
+		this.layoutRoot.invalidate();
 	}
 
 	finish(): void {
@@ -442,17 +502,48 @@ export class BtwAnsweringView implements Component, Focusable {
 		return truncateToWidth(`${loaderLine} • ${this.theme.fg("muted", selectedHints)}`, width);
 	}
 
-	private scrollBy(delta: number): void {
-		this.scrollOffset += delta;
-		this.clampScrollOffset();
+	private createHeaderComponent(): Component {
+		return {
+			render: (width) => [renderSideThreadHeader(width, this.theme, this.thinkingLevel)],
+			invalidate() {},
+		};
+	}
+
+	private createTranscriptComponent(): Component {
+		return {
+			render: (width) => {
+				const lines = renderTranscriptLines(this.transcriptComponents, width);
+				this.lastContentLineCount = lines.length;
+				return lines;
+			},
+			invalidate: () => {
+				for (const component of this.transcriptComponents) component.invalidate();
+			},
+		};
+	}
+
+	private createSteeringComponent(): Component {
+		return {
+			render: (width) =>
+				renderSteeringLines(
+					this.options.steering?.questions ?? [],
+					width,
+					this.theme,
+					MAX_STEERING_DISPLAY_LINES,
+				),
+			invalidate() {},
+		};
 	}
 
-	private clampScrollOffset(): void {
-		this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, this.getMaxScrollOffset()));
+	private createFooterComponent(): Component {
+		return {
+			render: (width) => [this.renderFooter(width)],
+			invalidate: () => this.loader.invalidate(),
+		};
 	}
 
 	private getMaxScrollOffset(): number {
-		return Math.max(0, this.lastContentLineCount - this.lastViewportHeight);
+		return Math.max(0, this.lastContentLineCount - this.scrollView.viewportHeight);
 	}
 }