@narumitw/pi-btw 0.42.0 → 0.43.0

package/src/menu.ts

@@ -0,0 +1,256 @@
+import type {
+	ExtensionCommandContext,
+	KeybindingsManager,
+	Theme,
+} from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { defineMenu, type MenuContext, type RunMenuResult, runMenu } from "@narumitw/pi-tui-kit";
+import {
+	type BtwSettings,
+	btwSettingsPath,
+	effectiveRememberThinkingLevelChanges,
+	readBtwSettings,
+	type UpdateBtwSettingsOptions,
+	updateBtwSettings,
+} from "./settings.js";
+import { BTW_THINKING_LEVELS, type BtwThinkingLevel } from "./side-thread.js";
+import { sanitizeSingleLine } from "./text.js";
+
+interface BtwMenuState {
+	kind: "valid" | "invalid";
+	settings: BtwSettings;
+	reason?: string;
+}
+
+export interface ShowBtwCommandMenuOptions {
+	currentThinkingLevel: BtwThinkingLevel;
+	availableThinkingLevels: readonly BtwThinkingLevel[];
+	settingsPath?: string;
+	readSettings?: typeof readBtwSettings;
+	updateSettings?: (
+		patch: Partial<Pick<BtwSettings, "thinkingLevel" | "rememberThinkingLevelChanges">>,
+		options: UpdateBtwSettingsOptions,
+	) => Promise<BtwSettings>;
+}
+
+export type BtwCommandMenuResult = "start" | "closed";
+
+type BtwMenuScreen = "main" | "settings" | "invalid";
+type BtwMenuAction = "start" | "set-thinking" | "set-remember";
+type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
+
+type BtwCustomFactory<T> = (
+	tui: TUI,
+	theme: Theme,
+	keybindings: KeybindingsManager,
+	done: (result: T) => void,
+) => Component;
+
+export async function showBtwCommandMenu(
+	ctx: ExtensionCommandContext,
+	options: ShowBtwCommandMenuOptions,
+): Promise<BtwCommandMenuResult> {
+	if (ctx.mode !== "tui") return "closed";
+	const settingsPath = options.settingsPath ?? btwSettingsPath();
+	const readSettings = options.readSettings ?? readBtwSettings;
+	const updateSettings = options.updateSettings ?? updateBtwSettings;
+	const levels =
+		options.availableThinkingLevels.length > 0
+			? [...options.availableThinkingLevels]
+			: (["off"] satisfies BtwThinkingLevel[]);
+	const displaySettingsPath = sanitizeSingleLine(settingsPath);
+	let startSelected = false;
+
+	const loadState = async (): Promise<BtwMenuState> => {
+		const loaded = await readSettings(settingsPath);
+		if (loaded.kind === "invalid") {
+			return { kind: "invalid", settings: {}, reason: loaded.reason };
+		}
+		return { kind: "valid", settings: loaded.kind === "loaded" ? loaded.settings : {} };
+	};
+	const displayThinkingLevel = (settings: BtwSettings): BtwThinkingLevel =>
+		clampToAvailableThinkingLevel(settings.thinkingLevel ?? options.currentThinkingLevel, levels);
+
+	const menu = defineMenu<BtwMenuState, BtwMenuScreen, BtwMenuAction, MenuContext>({
+		start: "main",
+		screens: {
+			main: ({ state }) => ({
+				kind: "actions",
+				title: "Pi BTW",
+				lines: [
+					`Thinking: ${displayThinkingLevel(state.settings)} · Remember changes: ${effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off"}`,
+				],
+				items: [
+					{
+						id: "start",
+						label: "Start side thread",
+						description: "Open an empty side thread",
+						action: "start",
+					},
+					{
+						id: "settings",
+						label: "Settings",
+						description: "Choose pi-btw thinking and whether shortcut changes are remembered",
+						to: state.kind === "invalid" ? "invalid" : "settings",
+					},
+				],
+				hint: "close",
+			}),
+			settings: ({ state }) => ({
+				kind: "settings",
+				title: "Pi BTW Settings",
+				lines: [`User settings · ${displaySettingsPath}`],
+				items: [
+					{
+						id: "thinkingLevel",
+						label: "Thinking level",
+						description: "Set the starting level for future pi-btw side threads.",
+						currentValue: displayThinkingLevel(state.settings),
+						values: levels,
+						action: "set-thinking",
+					},
+					{
+						id: "rememberThinkingLevelChanges",
+						label: "Remember thinking level changes",
+						description: "Save side-thread shortcut changes to pi-btw.json for next time.",
+						currentValue: effectiveRememberThinkingLevelChanges(state.settings) ? "On" : "Off",
+						values: ["On", "Off"],
+						action: "set-remember",
+					},
+				],
+			}),
+			invalid: ({ state }) => ({
+				kind: "detail",
+				title: "Pi BTW Settings · Read only",
+				lines: [
+					`Invalid settings file. Fix ${displaySettingsPath} before saving.`,
+					sanitizeSingleLine(state.reason ?? "The settings file is invalid."),
+				],
+				hint: "back",
+			}),
+		},
+		actions: {
+			start: async () => {
+				startSelected = true;
+				return { kind: "close" };
+			},
+			"set-thinking": async ({ value, signal }) => {
+				if (!value || !levels.includes(value as BtwThinkingLevel)) return { kind: "rejected" };
+				try {
+					await updateSettings(
+						{ thinkingLevel: value as BtwThinkingLevel },
+						{ settingsPath, signal },
+					);
+					if (signal.aborted) return { kind: "rejected" };
+					notifySafely(ctx, `Pi BTW thinking level: ${value}.`, "info");
+					return { kind: "stay" };
+				} catch (error) {
+					if (!signal.aborted) notifySaveFailure(ctx, error);
+					return { kind: "rejected" };
+				}
+			},
+			"set-remember": async ({ value, signal }) => {
+				if (value !== "On" && value !== "Off") return { kind: "rejected" };
+				try {
+					await updateSettings(
+						{ rememberThinkingLevelChanges: value === "On" },
+						{ settingsPath, signal },
+					);
+					if (signal.aborted) return { kind: "rejected" };
+					notifySafely(ctx, `Remember thinking level changes: ${value}.`, "info");
+					return { kind: "stay" };
+				} catch (error) {
+					if (!signal.aborted) notifySaveFailure(ctx, error);
+					return { kind: "rejected" };
+				}
+			},
+		},
+	});
+
+	const result = await runBtwMenuPreservingEditor(ctx, (menuContext) =>
+		runMenu(menuContext, menu, { getState: loadState }),
+	);
+	return startSelected && result.kind === "closed" && result.reason === "close"
+		? "start"
+		: "closed";
+}
+
+export async function runBtwMenuPreservingEditor(
+	ctx: ExtensionCommandContext,
+	run: (menuContext: MenuContext) => Promise<RunMenuResult>,
+): Promise<RunMenuResult> {
+	let liveEditorText = ctx.ui.getEditorText();
+	let completed = false;
+	const ui = new Proxy(ctx.ui, {
+		get(target, property) {
+			if (property === "custom") {
+				return <Value>(factory: BtwCustomFactory<Value>, customOptions?: BtwCustomOptions) =>
+					target.custom<Value>(
+						(tui, theme, keybindings, done) =>
+							factory(tui, theme, keybindings, (value) => {
+								try {
+									liveEditorText = target.getEditorText();
+								} catch {
+									// Keep completion finite if session replacement invalidates the editor context.
+								}
+								completed = true;
+								done(value);
+							}),
+						customOptions,
+					);
+			}
+			const value = Reflect.get(target, property, target) as unknown;
+			return typeof value === "function" ? value.bind(target) : value;
+		},
+	});
+	const result = await run({ mode: ctx.mode, hasUI: ctx.hasUI, ui });
+	if (result.kind !== "stale" && 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;
+}
+
+function clampToAvailableThinkingLevel(
+	requested: BtwThinkingLevel,
+	available: readonly BtwThinkingLevel[],
+): BtwThinkingLevel {
+	if (available.includes(requested)) return requested;
+	const requestedIndex = BTW_THINKING_LEVELS.indexOf(requested);
+	for (let index = requestedIndex; index < BTW_THINKING_LEVELS.length; index += 1) {
+		const candidate = BTW_THINKING_LEVELS[index];
+		if (candidate && available.includes(candidate)) return candidate;
+	}
+	for (let index = requestedIndex - 1; index >= 0; index -= 1) {
+		const candidate = BTW_THINKING_LEVELS[index];
+		if (candidate && available.includes(candidate)) return candidate;
+	}
+	return available[0] ?? "off";
+}
+
+function notifySaveFailure(ctx: ExtensionCommandContext, error: unknown): void {
+	notifySafely(
+		ctx,
+		`Pi BTW settings were not saved; the previous value remains active: ${formatError(error)}`,
+		"error",
+	);
+}
+
+function notifySafely(
+	ctx: ExtensionCommandContext,
+	message: string,
+	level: Parameters<ExtensionCommandContext["ui"]["notify"]>[1],
+): void {
+	try {
+		ctx.ui.notify(sanitizeSingleLine(message), level);
+	} catch {
+		// A completed save remains valid if its command context was replaced before notification.
+	}
+}
+
+function formatError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/settings.ts

@@ -0,0 +1,237 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { BTW_THINKING_LEVELS, type BtwThinkingLevel } from "./side-thread.js";
+
+export const BTW_SETTINGS_FILE = "pi-btw.json";
+export const DEFAULT_REMEMBER_THINKING_LEVEL_CHANGES = true;
+const MAX_SETTINGS_BYTES = 64 * 1024;
+
+export interface BtwSettings {
+	model?: string;
+	thinkingLevel?: BtwThinkingLevel;
+	rememberThinkingLevelChanges?: boolean;
+}
+
+export type BtwSettingsLoadResult =
+	| { kind: "missing" }
+	| { kind: "invalid"; reason: string }
+	| { kind: "loaded"; settings: BtwSettings };
+
+export interface UpdateBtwSettingsOptions {
+	settingsPath?: string;
+	signal?: AbortSignal;
+	beforeRename?: (temporaryPath: string, settingsPath: string) => Promise<void>;
+}
+
+type SettingsDocument = Record<string, unknown>;
+
+const mutationQueues = new Map<string, Promise<void>>();
+
+export function btwSettingsPath(): string {
+	return join(getAgentDir(), BTW_SETTINGS_FILE);
+}
+
+export function normalizeBtwSettings(value: unknown): BtwSettings | undefined {
+	if (!isSettingsDocument(value)) return undefined;
+
+	const settings: BtwSettings = {};
+	if (Object.hasOwn(value, "model")) {
+		const model = Reflect.get(value, "model");
+		if (typeof model !== "string" || !parseBtwModelReference(model)) return undefined;
+		settings.model = model;
+	}
+	if (Object.hasOwn(value, "thinkingLevel")) {
+		const thinkingLevel = Reflect.get(value, "thinkingLevel");
+		if (!isBtwThinkingLevel(thinkingLevel)) return undefined;
+		settings.thinkingLevel = thinkingLevel;
+	}
+	if (Object.hasOwn(value, "rememberThinkingLevelChanges")) {
+		const remember = Reflect.get(value, "rememberThinkingLevelChanges");
+		if (typeof remember !== "boolean") return undefined;
+		settings.rememberThinkingLevelChanges = remember;
+	}
+	return settings;
+}
+
+export function parseBtwModelReference(
+	reference: string,
+): { provider: string; modelId: string } | undefined {
+	if (/[\s\p{Cc}]/u.test(reference)) return undefined;
+	const separator = reference.indexOf("/");
+	if (separator <= 0 || separator === reference.length - 1) return undefined;
+	return { provider: reference.slice(0, separator), modelId: reference.slice(separator + 1) };
+}
+
+export function effectiveRememberThinkingLevelChanges(settings: BtwSettings): boolean {
+	return settings.rememberThinkingLevelChanges ?? DEFAULT_REMEMBER_THINKING_LEVEL_CHANGES;
+}
+
+export async function readBtwSettings(
+	settingsPath = btwSettingsPath(),
+): Promise<BtwSettingsLoadResult> {
+	await awaitBtwSettingsWrites(settingsPath);
+	return readBtwSettingsUncoordinated(settingsPath);
+}
+
+export function updateBtwSettings(
+	patch: Partial<Pick<BtwSettings, "thinkingLevel" | "rememberThinkingLevelChanges">>,
+	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 settings = normalizeBtwSettings(updated);
+		if (!settings) throw invalidSettingsError(settingsPath, "invalid settings shape");
+		await publishSettings(settingsPath, updated, options.signal, options.beforeRename);
+		return settings;
+	});
+}
+
+export async function awaitBtwSettingsWrites(settingsPath = btwSettingsPath()): Promise<void> {
+	await mutationQueues.get(settingsPath);
+}
+
+function enqueueMutation<T>(settingsPath: string, mutation: () => Promise<T>): Promise<T> {
+	const previous = mutationQueues.get(settingsPath) ?? Promise.resolve();
+	const result = previous.then(mutation, mutation);
+	const settled = result.then(
+		() => undefined,
+		() => undefined,
+	);
+	mutationQueues.set(settingsPath, settled);
+	void settled.finally(() => {
+		if (mutationQueues.get(settingsPath) === settled) mutationQueues.delete(settingsPath);
+	});
+	return result;
+}
+
+async function readBtwSettingsUncoordinated(settingsPath: string): Promise<BtwSettingsLoadResult> {
+	let contents: string;
+	try {
+		contents = await readSettingsContents(settingsPath);
+	} catch (error: unknown) {
+		if (isNodeError(error) && error.code === "ENOENT") return { kind: "missing" };
+		return { kind: "invalid", reason: `${settingsPath}: ${formatError(error)}` };
+	}
+
+	try {
+		const settings = normalizeBtwSettings(JSON.parse(contents) as unknown);
+		return settings
+			? { kind: "loaded", settings }
+			: { kind: "invalid", reason: `${settingsPath}: invalid settings shape` };
+	} catch {
+		return { kind: "invalid", reason: `${settingsPath}: invalid JSON` };
+	}
+}
+
+async function readSettingsDocumentForUpdate(settingsPath: string): Promise<SettingsDocument> {
+	let contents: string;
+	try {
+		contents = await readSettingsContents(settingsPath);
+	} catch (error: unknown) {
+		if (isNodeError(error) && error.code === "ENOENT") return {};
+		throw invalidSettingsError(settingsPath, formatError(error));
+	}
+
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(contents) as unknown;
+	} catch {
+		throw invalidSettingsError(settingsPath, "invalid JSON");
+	}
+	if (!isSettingsDocument(parsed) || !normalizeBtwSettings(parsed)) {
+		throw invalidSettingsError(settingsPath, "invalid settings shape");
+	}
+	return parsed;
+}
+
+async function readSettingsContents(settingsPath: string): Promise<string> {
+	const flags = constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
+	const handle = await open(settingsPath, flags);
+	try {
+		const descriptorStats = await handle.stat();
+		if (!descriptorStats.isFile()) throw new Error("settings path is not a regular file");
+		if (descriptorStats.size > MAX_SETTINGS_BYTES) {
+			throw new Error(`settings file exceeds ${MAX_SETTINGS_BYTES} bytes`);
+		}
+
+		const buffer = Buffer.alloc(MAX_SETTINGS_BYTES + 1);
+		let offset = 0;
+		while (offset < buffer.byteLength) {
+			const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, offset);
+			if (bytesRead === 0) break;
+			offset += bytesRead;
+		}
+		if (offset > MAX_SETTINGS_BYTES) {
+			throw new Error(`settings file exceeds ${MAX_SETTINGS_BYTES} bytes`);
+		}
+		try {
+			return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+				buffer.subarray(0, offset),
+			);
+		} catch {
+			throw new Error("settings file is not valid UTF-8");
+		}
+	} finally {
+		await handle.close();
+	}
+}
+
+async function publishSettings(
+	settingsPath: string,
+	document: SettingsDocument,
+	signal?: AbortSignal,
+	beforeRename?: (temporaryPath: string, settingsPath: string) => Promise<void>,
+): Promise<void> {
+	signal?.throwIfAborted();
+	const contents = `${JSON.stringify(document, null, 2)}\n`;
+	if (Buffer.byteLength(contents, "utf8") > MAX_SETTINGS_BYTES) {
+		throw new Error(`settings document exceeds ${MAX_SETTINGS_BYTES} bytes`);
+	}
+	const directory = dirname(settingsPath);
+	await mkdir(directory, { recursive: true });
+	signal?.throwIfAborted();
+	const temporaryPath = join(
+		directory,
+		`.${basename(settingsPath)}.${process.pid}.${randomUUID()}.tmp`,
+	);
+	try {
+		await writeFile(temporaryPath, contents, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 0o600,
+			signal,
+		});
+		await beforeRename?.(temporaryPath, settingsPath);
+		signal?.throwIfAborted();
+		await rename(temporaryPath, settingsPath);
+	} catch (error) {
+		await rm(temporaryPath, { force: true }).catch(() => undefined);
+		throw error;
+	}
+}
+
+function isSettingsDocument(value: unknown): value is SettingsDocument {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isBtwThinkingLevel(value: unknown): value is BtwThinkingLevel {
+	return BTW_THINKING_LEVELS.includes(value as BtwThinkingLevel);
+}
+
+function invalidSettingsError(settingsPath: string, reason: string): Error {
+	return new Error(`pi-btw settings at ${settingsPath} are invalid: ${reason}`);
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+	return error instanceof Error && "code" in error;
+}
+
+function formatError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/text.ts

@@ -0,0 +1,10 @@
+export function sanitizeSingleLine(text: string): string {
+	return [...text.replace(/[\r\n\t]/gu, " ")]
+		.filter((character) => {
+			const code = character.charCodeAt(0);
+			return code > 31 && (code < 127 || code > 159);
+		})
+		.join("")
+		.replace(/ +/gu, " ")
+		.trim();
+}

package/src/transcript-pager.ts

@@ -2,6 +2,7 @@ import type { AssistantMessage } from "@earendil-works/pi-ai";
 import {
 	AssistantMessageComponent,
 	getMarkdownTheme,
+	type KeybindingsManager,
 	type Theme,
 	UserMessageComponent,
 } from "@earendil-works/pi-coding-agent";
@@ -18,7 +19,8 @@ import {
 	truncateToWidth,
 	visibleWidth,
 } from "@earendil-works/pi-tui";
-import type { SideThreadTurn } from "./side-thread.js";
+import type { BtwThinkingLevel, SideThreadTurn } from "./side-thread.js";
+import { sanitizeSingleLine } from "./text.js";
 
 const TRANSCRIPT_CHROME_LINES = 2;
 const OSC133_MARKERS = ["\u001b]133;A\u0007", "\u001b]133;B\u0007", "\u001b]133;C\u0007"];
@@ -30,6 +32,13 @@ export type TranscriptPagerAction =
 	| { kind: "bringToMain"; questionDraft: string }
 	| { kind: "close" };
 
+export interface BtwThinkingControl {
+	level: BtwThinkingLevel;
+	levels: readonly BtwThinkingLevel[];
+	keybindings: KeybindingsManager;
+	onChange: (level: BtwThinkingLevel) => void;
+}
+
 export class BtwTranscriptPager implements Component {
 	private readonly transcriptComponents: Component[];
 	private readonly editor: Editor;
@@ -41,17 +50,23 @@ export class BtwTranscriptPager implements Component {
 	private warning: string | undefined;
 	private finished = false;
 	private isFocused = false;
+	private thinkingLevel: BtwThinkingLevel | undefined;
 
 	constructor(
 		private readonly tui: TUI,
 		private readonly theme: Theme,
 		turns: readonly SideThreadTurn[],
 		private readonly onAction: (action: TranscriptPagerAction) => void,
-		options: { startAtBottom?: boolean; initialQuestion?: string } = {},
+		private readonly options: {
+			startAtBottom?: boolean;
+			initialQuestion?: string;
+			thinking?: BtwThinkingControl;
+		} = {},
 	) {
 		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),
 			selectList: {
@@ -102,7 +117,7 @@ export class BtwTranscriptPager implements Component {
 		this.clampScrollOffset();
 
 		return fitComposerLayout(
-			renderSideThreadHeader(safeWidth, this.theme),
+			renderSideThreadHeader(safeWidth, this.theme, this.thinkingLevel),
 			contentLines.slice(this.scrollOffset, this.scrollOffset + viewportHeight),
 			this.renderFooter(safeWidth),
 			editorLines,
@@ -122,6 +137,22 @@ export class BtwTranscriptPager implements Component {
 			this.onAction({ kind: "bringToMain", questionDraft: this.editor.getExpandedText() });
 			return;
 		}
+		const thinking = this.options.thinking;
+		if (
+			thinking &&
+			thinking.levels.length > 1 &&
+			thinking.keybindings.matches(data, "app.thinking.cycle")
+		) {
+			const currentIndex = thinking.levels.indexOf(this.thinkingLevel ?? thinking.level);
+			const nextLevel = thinking.levels[(currentIndex + 1) % thinking.levels.length];
+			if (nextLevel) {
+				this.thinkingLevel = nextLevel;
+				thinking.onChange(nextLevel);
+				this.warning = undefined;
+				this.tui.requestRender();
+			}
+			return;
+		}
 		if (matchesKey(data, Key.pageUp)) {
 			const previousOffset = this.scrollOffset;
 			this.scrollBy(-this.lastViewportHeight);
@@ -144,23 +175,38 @@ export class BtwTranscriptPager implements Component {
 		this.editor.invalidate();
 	}
 
+	dispose(): void {
+		if (this.finished) return;
+		this.finished = true;
+		this.onAction({ kind: "close" });
+	}
+
 	private renderFooter(width: number): string {
 		if (this.warning) {
 			const warning = width < 32 ? "Empty • Ctrl+C" : `${this.warning} • Ctrl+C exit`;
 			return truncateToWidth(this.theme.fg("warning", warning), width);
 		}
 		const scrollable = this.getMaxScrollOffset() > 0;
-		const fullBase = this.canBringToMain
+		const thinking = this.options.thinking;
+		const cycleHint =
+			thinking && thinking.levels.length > 1 && this.thinkingLevel
+				? ` • thinking ${this.thinkingLevel} • ${thinkingKeyLabel(thinking.keybindings)} cycle`
+				: "";
+		const base = this.canBringToMain
 			? "btw • Enter send • Ctrl+R bring to main • Ctrl+C exit"
 			: "btw • Enter send • Ctrl+C exit";
+		const fullBase = `${base}${cycleHint}`;
 		const fallbackBase = "btw • Enter • Ctrl+C";
 		const compactBase = this.canBringToMain ? "btw • Enter • Ctrl+R • Ctrl+C" : fallbackBase;
+		const compactWithThinking = `${compactBase}${cycleHint}`;
 		let hints =
 			visibleWidth(fullBase) <= width
 				? fullBase
-				: visibleWidth(compactBase) <= width
-					? compactBase
-					: fallbackBase;
+				: visibleWidth(compactWithThinking) <= width
+					? compactWithThinking
+					: visibleWidth(compactBase) <= width
+						? compactBase
+						: fallbackBase;
 		if (scrollable) {
 			const history = ` • ${this.scrollOffset > 0 ? "↑ older" : "↓ newer"} • PgUp/PgDn history`;
 			const compactHistory = " • PgUp/PgDn";
@@ -212,6 +258,7 @@ export class BtwAnsweringView implements Component {
 		turns: readonly SideThreadTurn[],
 		pendingQuestion: string,
 		private readonly onCancel: () => void,
+		private readonly thinkingLevel?: BtwThinkingLevel,
 	) {
 		this.transcriptComponents = buildTranscriptComponents(turns, this.theme, pendingQuestion);
 		this.loader = new Loader(
@@ -239,7 +286,7 @@ export class BtwAnsweringView implements Component {
 		const loaderWidth = Math.max(1, safeWidth - visibleWidth(cancelHint) - 3);
 		const loaderLine = this.loader.render(loaderWidth).at(-1) ?? "Answering…";
 		const lines = [
-			renderSideThreadHeader(safeWidth, this.theme),
+			renderSideThreadHeader(safeWidth, this.theme, this.thinkingLevel),
 			...contentLines.slice(this.scrollOffset, this.scrollOffset + viewportHeight),
 			truncateToWidth(`${loaderLine} • ${this.theme.fg("muted", cancelHint)}`, safeWidth),
 		];
@@ -278,8 +325,15 @@ export class BtwAnsweringView implements Component {
 	}
 
 	dispose(): void {
-		this.finish();
+		if (this.finished) {
+			this.loader.stop();
+			this.controller.abort();
+			return;
+		}
+		this.finished = true;
+		this.loader.stop();
 		this.controller.abort();
+		this.onCancel();
 	}
 
 	private scrollBy(delta: number): void {
@@ -350,12 +404,35 @@ function renderTranscriptLines(components: readonly Component[], width: number):
 		.map(stripShellIntegrationMarkers);
 }
 
-function renderSideThreadHeader(width: number, theme: Theme): string {
-	const title = truncateToWidth("─ btw · side thread ", width);
+function renderSideThreadHeader(
+	width: number,
+	theme: Theme,
+	thinkingLevel?: BtwThinkingLevel,
+): string {
+	const thinking = thinkingLevel ? ` · thinking ${thinkingLevel}` : "";
+	const title = truncateToWidth(`─ btw · side thread${thinking} `, width);
 	const ruleWidth = Math.max(0, width - visibleWidth(title));
 	return theme.fg("muted", `${title}${"─".repeat(ruleWidth)}`);
 }
 
+function thinkingKeyLabel(keybindings: KeybindingsManager): string {
+	const key =
+		sanitizeSingleLine(String(keybindings.getKeys("app.thinking.cycle")[0] ?? "shift+tab")) ||
+		"Shift+Tab";
+	return key
+		.split("+")
+		.map((part) => {
+			const lower = part.toLowerCase();
+			if (lower === "shift") return "Shift";
+			if (lower === "ctrl") return "Ctrl";
+			if (lower === "alt") return "Alt";
+			return part.length === 1
+				? part.toUpperCase()
+				: `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`;
+		})
+		.join("+");
+}
+
 function fitComposerLayout(
 	header: string,
 	contentLines: string[],