@narumitw/pi-btw 0.51.0 → 0.53.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.
@@ -18,7 +19,7 @@ Use it when you want to ask a temporary question, inspect context, or get a shor
 - 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`.
-- Uses a pi-btw thinking level that can be changed with Pi's configured thinking shortcut and remembered for next time.
+- Uses a pi-btw thinking level that can either start from the main thread or use a fixed remembered value.
 - Does not append the side question or answer to the main conversation.
 - Works as an independently installable npm Pi extension package.
 
@@ -59,9 +60,14 @@ 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 are remembered.
+**Settings** changes the starting thinking level and whether shortcut changes for fixed levels are remembered.
 Each Resume row keeps the first question as its fixed title, shows its question count, and the list is ordered by the newest recorded answer or visible error.
 Opening and closing a thread without a new result does not reorder it.
 `/btw <question>` bypasses this menu and always starts a fresh side thread.
@@ -79,9 +85,11 @@ Previous side questions and answers remain available to the model and visible fo
 invocation. The side-thread header shows its current thinking level. Press Pi's configured
 `app.thinking.cycle` shortcut (`Shift+Tab` by default) in the composer to cycle the levels
 supported by the side-thread model; every later question uses the displayed level until it is
-changed again. By default, each shortcut change is also written to `pi-btw.json` for the next
-invocation. Turn **Remember thinking level changes** off in Settings to keep changes local to the
-current side thread. Neither path changes the main session's thinking level.
+changed again. When a fixed thinking level is selected, each shortcut change is also written to
+`pi-btw.json` for the next invocation by default. Turn **Remember thinking level changes** off in
+Settings to keep fixed-level changes local to the current side thread. When **Same as main thread** is
+selected, shortcut changes are always local to the current side thread. Neither path changes the main
+session's thinking level.
 While a response is running, the transcript and composer remain visible above an `Answering…`
 status.
 Type another question and press `Enter` to queue it as `Steering`; queued questions are shown in
@@ -148,18 +156,23 @@ cannot be found or authenticated, pi-btw warns and falls back to the current ses
 If neither model is available, `/btw` reports an error and stops. This selection affects only
 `/btw`; it does not change the main session model.
 
-Pi calls its reasoning setting the **thinking level**. `thinkingLevel` sets pi-btw's starting
-level; accepted values are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. When the
-field is absent for backward compatibility, the next invocation starts from the current session
-level. The initial value and shortcut cycle are clamped to the selected side model's capabilities
-using Pi's model rules. Pi-btw does not read, write, or change the main session's
-`defaultThinkingLevel`.
+Pi calls its reasoning setting the **thinking level**. In Settings, choose **Same as main thread**
+to start each new side thread from the main thread's current thinking level. This is stored by
+omitting `thinkingLevel` from `pi-btw.json`.
 
-`rememberThinkingLevelChanges` controls only persistence and defaults to `true` when omitted. A
-side-thread shortcut always changes that side thread immediately. When remembering is on, the
-concrete level is written for the next invocation; when off, `pi-btw.json` stays unchanged. If a
-shortcut write fails, the local change remains active and pi-btw warns that it was not remembered.
-A failed Settings-screen save instead restores the previous displayed value.
+Set `thinkingLevel` only when you want a fixed pi-btw starting level. Accepted fixed values are
+`off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. The initial value and shortcut cycle
+are clamped to the selected side model's capabilities using Pi's model rules. Resumed side threads
+keep their own local thinking level instead of re-syncing with the main thread. Pi-btw does not read,
+write, or change the main session's `defaultThinkingLevel`.
+
+`rememberThinkingLevelChanges` controls only persistence for fixed thinking levels and defaults to
+`true` when omitted. A side-thread shortcut always changes that side thread immediately. When a fixed
+thinking level is selected and remembering is on, the concrete level is written for the next
+invocation; when off, `pi-btw.json` stays unchanged. When **Same as main thread** is selected,
+shortcut changes stay local even when remembering is on. If a shortcut write fails, the local change
+remains active and pi-btw warns that it was not remembered. A failed Settings-screen save instead
+restores the previous displayed value.
 
 A missing settings file is a side-effect-free read: pi-btw creates it only after a Settings change
 or a remembered shortcut change. Saves are ordered within the Pi process and published atomically
@@ -181,6 +194,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.51.0",
+	"version": "0.53.0",
 	"description": "Pi extension that adds a /btw side-question command.",
 	"type": "module",
 	"license": "MIT",
@@ -31,10 +31,10 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.5.7",
-		"@earendil-works/pi-ai": "0.84.1",
-		"@earendil-works/pi-coding-agent": "0.84.1",
-		"@earendil-works/pi-tui": "0.84.1",
+		"@biomejs/biome": "2.5.8",
+		"@earendil-works/pi-ai": "0.84.2",
+		"@earendil-works/pi-coding-agent": "0.84.2",
+		"@earendil-works/pi-tui": "0.84.2",
 		"typescript": "7.0.2"
 	},
 	"repository": {
@@ -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,
@@ -194,7 +193,7 @@ export async function loadBtwThinkingLevel(
 
 	options.warn?.(
 		sanitizeSingleLine(
-			`pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", and boolean rememberThinkingLevelChanges. Using current Pi thinking level.`,
+			`pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", omitted thinkingLevel for Same as main thread or thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", and boolean rememberThinkingLevelChanges. Using current Pi thinking level.`,
 		),
 	);
 	return currentThinkingLevel;
@@ -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,12 +260,41 @@ 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);
+			const sameAsMainThinkingLevel = settings.thinkingLevel === undefined;
 			const resolution = await resolveModel(settings, ctx);
 			if (resolution.kind === "cancelled") {
 				notifySafely(ctx, "Cancelled", "info");
@@ -290,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,
@@ -302,7 +333,8 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 						initialQuestion: question || undefined,
 						selected: resolution.selected,
 						thinkingLevel: state.thinkingLevel,
-						rememberThinkingLevelChanges: effectiveRememberThinkingLevelChanges(settings),
+						rememberThinkingLevelChanges:
+							!sameAsMainThinkingLevel && effectiveRememberThinkingLevelChanges(settings),
 						state,
 						ctx: fullscreenCtx,
 					});
@@ -544,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/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

@@ -7,6 +7,7 @@ import type { Component, TUI } from "@earendil-works/pi-tui";
 import type { MenuContext, RunMenuResult } from "@narumitw/pi-tui-kit";
 import {
 	type BtwSettings,
+	type BtwSettingsPatch,
 	btwSettingsPath,
 	effectiveRememberThinkingLevelChanges,
 	readBtwSettings,
@@ -35,15 +36,20 @@ export interface ShowBtwCommandMenuOptions {
 	settingsPath?: string;
 	readSettings?: typeof readBtwSettings;
 	updateSettings?: (
-		patch: Partial<Pick<BtwSettings, "thinkingLevel" | "rememberThinkingLevelChanges">>,
+		patch: BtwSettingsPatch,
 		options: UpdateBtwSettingsOptions,
 	) => 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];
 
 type BtwCustomFactory<T> = (
@@ -70,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> => {
@@ -79,8 +86,22 @@ export async function showBtwCommandMenu(
 		}
 		return { kind: "valid", settings: loaded.kind === "loaded" ? loaded.settings : {} };
 	};
-	const displayThinkingLevel = (settings: BtwSettings): BtwThinkingLevel =>
-		clampToAvailableThinkingLevel(settings.thinkingLevel ?? options.currentThinkingLevel, levels);
+	const currentMainThinkingLevel = clampToAvailableThinkingLevel(
+		options.currentThinkingLevel,
+		levels,
+	);
+	const displayThinkingLevel = (settings: BtwSettings): string =>
+		settings.thinkingLevel === undefined
+			? SAME_AS_MAIN_THREAD
+			: clampToAvailableThinkingLevel(settings.thinkingLevel, levels);
+	const displayThinkingSummary = (settings: BtwSettings): string =>
+		settings.thinkingLevel === undefined
+			? `${SAME_AS_MAIN_THREAD} (currently ${currentMainThinkingLevel})`
+			: displayThinkingLevel(settings);
+	const displayRememberSummary = (settings: BtwSettings): string => {
+		const value = effectiveRememberThinkingLevelChanges(settings) ? "On" : "Off";
+		return settings.thinkingLevel === undefined ? `${value} (fixed levels only)` : value;
+	};
 
 	const menu = defineMenu<BtwMenuState, BtwMenuScreen, BtwMenuAction, MenuContext>({
 		start: "main",
@@ -89,7 +110,7 @@ export async function showBtwCommandMenu(
 				kind: "actions",
 				title: "Pi BTW",
 				lines: [
-					`Thinking: ${displayThinkingLevel(state.settings)} · Remember changes: ${effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off"}`,
+					`Thinking: ${displayThinkingSummary(state.settings)} · Remember changes: ${displayRememberSummary(state.settings)}`,
 				],
 				items: [
 					{
@@ -98,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
 						? [
 								{
@@ -111,7 +138,7 @@ export async function showBtwCommandMenu(
 					{
 						id: "settings",
 						label: "Settings",
-						description: "Choose pi-btw thinking and whether shortcut changes are remembered",
+						description: "Choose pi-btw thinking level and fixed-level shortcut memory",
 						to: state.kind === "invalid" ? "invalid" : "settings",
 					},
 				],
@@ -138,15 +165,15 @@ export async function showBtwCommandMenu(
 					{
 						id: "thinkingLevel",
 						label: "Thinking level",
-						description: "Set the starting level for future pi-btw side threads.",
+						description: `Set the starting level for future pi-btw side threads. Currently ${currentMainThinkingLevel}.`,
 						currentValue: displayThinkingLevel(state.settings),
-						values: levels,
+						values: [SAME_AS_MAIN_THREAD, ...levels],
 						action: "set-thinking",
 					},
 					{
 						id: "rememberThinkingLevelChanges",
 						label: "Remember thinking level changes",
-						description: "Save side-thread shortcut changes to pi-btw.json for next time.",
+						description: "Save shortcut changes for fixed thinking levels to pi-btw.json.",
 						currentValue: effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off",
 						values: ["On", "Off"],
 						action: "set-remember",
@@ -168,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;
@@ -176,12 +207,16 @@ export async function showBtwCommandMenu(
 				return { kind: "close" } as const;
 			},
 			"set-thinking": async ({ value, signal }) => {
-				if (!value || !levels.includes(value as BtwThinkingLevel)) return { kind: "rejected" };
+				if (!value) return { kind: "rejected" };
+				const patch =
+					value === SAME_AS_MAIN_THREAD
+						? ({ thinkingLevel: undefined } satisfies BtwSettingsPatch)
+						: levels.includes(value as BtwThinkingLevel)
+							? ({ thinkingLevel: value as BtwThinkingLevel } satisfies BtwSettingsPatch)
+							: undefined;
+				if (!patch) return { kind: "rejected" };
 				try {
-					await updateSettings(
-						{ thinkingLevel: value as BtwThinkingLevel },
-						{ settingsPath, signal },
-					);
+					await updateSettings(patch, { settingsPath, signal });
 					if (signal.aborted) return { kind: "rejected" };
 					notifySafely(ctx, `Pi BTW thinking level: ${value}.`, "info");
 					return { kind: "stay" };
@@ -213,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/settings.ts

@@ -20,6 +20,11 @@ export type BtwSettingsLoadResult =
 	| { kind: "invalid"; reason: string }
 	| { kind: "loaded"; settings: BtwSettings };
 
+export interface BtwSettingsPatch {
+	thinkingLevel?: BtwThinkingLevel;
+	rememberThinkingLevelChanges?: boolean;
+}
+
 export interface UpdateBtwSettingsOptions {
 	settingsPath?: string;
 	signal?: AbortSignal;
@@ -77,14 +82,14 @@ export async function readBtwSettings(
 }
 
 export function updateBtwSettings(
-	patch: Partial<Pick<BtwSettings, "thinkingLevel" | "rememberThinkingLevelChanges">>,
+	patch: BtwSettingsPatch,
 	options: UpdateBtwSettingsOptions = {},
 ): Promise<BtwSettings> {
 	const settingsPath = options.settingsPath ?? btwSettingsPath();
 	return enqueueMutation(settingsPath, async () => {
 		options.signal?.throwIfAborted();
 		const current = await readSettingsDocumentForUpdate(settingsPath);
-		const updated: SettingsDocument = { ...current, ...patch };
+		const updated = applyBtwSettingsPatch(current, patch);
 		const settings = normalizeBtwSettings(updated);
 		if (!settings) throw invalidSettingsError(settingsPath, "invalid settings shape");
 		await publishSettings(settingsPath, updated, options.signal, options.beforeRename);
@@ -216,6 +221,21 @@ async function publishSettings(
 	}
 }
 
+function applyBtwSettingsPatch(
+	current: SettingsDocument,
+	patch: BtwSettingsPatch,
+): SettingsDocument {
+	const updated: SettingsDocument = { ...current };
+	if (Object.hasOwn(patch, "thinkingLevel")) {
+		if (patch.thinkingLevel === undefined) delete updated.thinkingLevel;
+		else updated.thinkingLevel = patch.thinkingLevel;
+	}
+	if (Object.hasOwn(patch, "rememberThinkingLevelChanges")) {
+		updated.rememberThinkingLevelChanges = patch.rememberThinkingLevelChanges;
+	}
+	return updated;
+}
+
 function isSettingsDocument(value: unknown): value is SettingsDocument {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }