@narumitw/pi-btw 0.49.7 → 0.50.0

package/README.md

@@ -8,11 +8,12 @@ Use it when you want to ask a temporary question, inspect context, or get a shor
 
 ## ✨ Features
 
-- Adds a `/btw` menu for starting a side thread or changing pi-btw settings.
-- Keeps `/btw <question>` as a direct fast path.
+- Adds a `/btw` menu for starting or resuming an in-memory side thread or changing pi-btw settings.
+- 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.
 - Supports follow-up questions in the same ephemeral side thread.
+- Resumes any non-empty side thread retained by the current Pi session, listed by its first question.
 - Queues Pi-style `Steering` questions while an answer is running and processes them one at a time.
 - 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.
@@ -57,10 +58,14 @@ Examples:
 /btw is this API name idiomatic?
 ```
 
-Running `/btw` alone opens a two-row menu. **Start side thread** is selected first, so pressing
-`Enter` opens an empty ephemeral side thread; **Settings** changes the starting thinking level
-and whether shortcut changes are remembered. `/btw <question>` bypasses this menu, and its answer
-opens above the side-thread editor. The side thread uses a dedicated full-screen terminal view.
+Running `/btw` alone opens a menu with **Start side thread** selected first. When the current Pi
+session has non-empty side threads in memory, **Resume side thread** opens a bounded choice list;
+**Settings** changes the starting thinking level and whether shortcut changes 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. Its answer opens above the side-thread editor. The side thread uses a dedicated full-screen
+terminal view.
 The main agent continues running in the background, but its screen rendering stays suspended until
 `/btw` closes, so new main-thread output cannot move a mouse selection inside the side thread.
 Drag the primary mouse button across side-thread text to select and copy it through Pi's terminal
@@ -83,8 +88,9 @@ 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.
-Steering remains entirely inside pi-btw and never appends to the main conversation or editor.
+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
@@ -108,9 +114,11 @@ into Pi's main editor. It never sends the draft automatically. If the main edito
 draft, append is the recommended default. Replace is labeled as destructive and requires a second
 confirmation; Cancel returns to the side thread without changing either draft. Concurrent editor
 updates made while these menus are open are preserved. A success message reports whether context
-was loaded, appended, or replaced and its approximate size. Without an explicit bring-to-main
-action, closing `/btw`, reloading Pi, or switching sessions still discards the side thread without
-adding it to the main conversation.
+was loaded, appended, or replaced and its approximate size.
+Without an explicit bring-to-main action, closing `/btw` never adds the side thread to the main
+conversation. Non-empty threads remain only in memory for Resume within the current Pi session.
+`/new`, Pi `/resume`, `/reload`, extension replacement, and process restart discard every retained
+thread. Unsent drafts, steering queues, interrupted answers, and model credentials are never retained.
 
 ## ⚙️ Model and thinking level
 

package/package.json

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

package/src/btw.ts

@@ -28,6 +28,7 @@ import {
 import { type RunBtwFullscreen, runBtwFullscreen } from "./fullscreen-ui.js";
 import {
 	type BtwCommandMenuResult,
+	type BtwResumeThreadSummary,
 	runBtwMenuPreservingEditor,
 	showBtwCommandMenu,
 } from "./menu.js";
@@ -107,6 +108,15 @@ export interface ResolvedBtwModel {
 	auth: SideQuestionAuth;
 }
 
+export interface BtwThreadState {
+	id: string;
+	title?: string;
+	thread: SideThread;
+	thinkingLevel: BtwThinkingLevel;
+	createdAt: number;
+	updatedAt: number;
+}
+
 export async function resolveBtwModel({
 	settings,
 	currentModel,
@@ -210,6 +220,7 @@ export interface BtwExtensionDependencies {
 	showCommandMenu?: (
 		pi: ExtensionAPI,
 		ctx: ExtensionCommandContext,
+		resumeThreads: readonly BtwResumeThreadSummary[],
 	) => Promise<BtwCommandMenuResult>;
 	loadSettings?: typeof loadSettingsForCommand;
 	resolveModel?: typeof resolveBtwModelWithLoader;
@@ -223,6 +234,21 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 	const resolveModel = dependencies.resolveModel ?? resolveBtwModelWithLoader;
 	const runThread = dependencies.runThread ?? runBtwThread;
 	const runFullscreen = dependencies.runFullscreen ?? runBtwFullscreen;
+	// Pi creates a fresh extension instance after session replacement or reload.
+	const resumableThreads = new Map<string, BtwThreadState>();
+	let nextThreadNumber = 1;
+	const listResumeThreads = (): BtwResumeThreadSummary[] =>
+		[...resumableThreads.values()]
+			.reverse()
+			.filter((state) => state.thread.turns.length > 0 && state.title)
+			.sort(
+				(first, second) => second.updatedAt - first.updatedAt || second.createdAt - first.createdAt,
+			)
+			.map((state) => ({
+				id: state.id,
+				title: state.title ?? "Untitled side thread",
+				questionCount: state.thread.turns.length,
+			}));
 	pi.registerCommand("btw", {
 		description: "Ask a quick side question without adding it to the main conversation",
 		handler: async (args, ctx) => {
@@ -231,7 +257,12 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 				ctx.ui.notify("/btw requires interactive TUI mode", "error");
 				return;
 			}
-			if (!question && (await showCommandMenu(pi, ctx)) !== "start") return;
+
+			let menuResult: BtwCommandMenuResult = "start";
+			if (!question) {
+				menuResult = await showCommandMenu(pi, ctx, listResumeThreads());
+				if (menuResult === "closed") return;
+			}
 
 			const settings = await loadSettings(ctx);
 			const resolution = await resolveModel(settings, ctx);
@@ -244,15 +275,46 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 				return;
 			}
 
-			await runFullscreen(ctx, (fullscreenCtx) =>
-				runThread({
-					initialQuestion: question || undefined,
-					selected: resolution.selected,
-					thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
-					rememberThinkingLevelChanges: effectiveRememberThinkingLevelChanges(settings),
-					ctx: fullscreenCtx,
-				}),
-			);
+			let state =
+				typeof menuResult === "object" ? resumableThreads.get(menuResult.threadId) : undefined;
+			if (typeof menuResult === "object" && !state) {
+				notifySafely(ctx, "The selected /btw side thread is no longer available", "warning");
+				return;
+			}
+			const startingTurnCount = state?.thread.turns.length ?? 0;
+
+			try {
+				await runFullscreen(ctx, (fullscreenCtx) => {
+					if (!state) {
+						const createdAt = Date.now();
+						state = {
+							id: `btw-${nextThreadNumber}`,
+							thread: createSideThread(
+								buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
+							),
+							thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
+							createdAt,
+							updatedAt: createdAt,
+						};
+						nextThreadNumber += 1;
+					}
+					return runThread({
+						initialQuestion: question || undefined,
+						selected: resolution.selected,
+						thinkingLevel: state.thinkingLevel,
+						rememberThinkingLevelChanges: effectiveRememberThinkingLevelChanges(settings),
+						state,
+						ctx: fullscreenCtx,
+					});
+				});
+			} finally {
+				if (state?.title && state.thread.turns.length > 0) {
+					if (state.thread.turns.length > startingTurnCount) {
+						resumableThreads.delete(state.id);
+					}
+					resumableThreads.set(state.id, state);
+				}
+			}
 		},
 	});
 }
@@ -260,6 +322,7 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 async function showCommandMenuForBtw(
 	pi: ExtensionAPI,
 	ctx: ExtensionCommandContext,
+	resumeThreads: readonly BtwResumeThreadSummary[],
 ): Promise<BtwCommandMenuResult> {
 	const currentModel = ctx.model;
 	const availableModels = ctx.modelRegistry.getAll();
@@ -276,6 +339,7 @@ async function showCommandMenuForBtw(
 	return showBtwCommandMenu(ctx, {
 		currentThinkingLevel,
 		availableThinkingLevels: model ? getSupportedThinkingLevels(model) : BTW_THINKING_LEVELS,
+		resumeThreads,
 	});
 }
 
@@ -335,6 +399,7 @@ interface RunBtwThreadDependencies {
 	chooseBringToMain?: typeof chooseBringToMain;
 	deliverBringToMain?: typeof loadBringToMainDraft;
 	persistThinkingLevel?: (level: BtwThinkingLevel) => Promise<unknown>;
+	now?: () => number;
 }
 
 export type BtwThreadResult = { kind: "closed" };
@@ -365,6 +430,7 @@ interface RunBtwThreadOptions {
 	thinkingLevel: BtwThinkingLevel;
 	rememberThinkingLevelChanges?: boolean;
 	settingsPath?: string;
+	state?: BtwThreadState;
 	ctx: ExtensionCommandContext;
 	dependencies?: RunBtwThreadDependencies;
 }
@@ -375,6 +441,7 @@ export async function runBtwThread({
 	thinkingLevel,
 	rememberThinkingLevelChanges = false,
 	settingsPath,
+	state,
 	ctx,
 	dependencies = {},
 }: RunBtwThreadOptions): Promise<BtwThreadResult> {
@@ -385,11 +452,17 @@ export async function runBtwThread({
 	const persistThinkingLevel =
 		dependencies.persistThinkingLevel ??
 		((level: BtwThinkingLevel) => updateBtwSettings({ thinkingLevel: level }, { settingsPath }));
-	const thread = createSideThread(buildConversationContext(ctx.sessionManager.getBranch()));
+	const now = dependencies.now ?? Date.now;
+	const thread =
+		state?.thread ?? createSideThread(buildConversationContext(ctx.sessionManager.getBranch()));
 	const thinkingLevels = getSupportedThinkingLevels(selected.model);
 	const pendingWrites = new Set<Promise<void>>();
 	const steeringQuestions: string[] = [];
-	let activeThinkingLevel = clampThinkingLevel(selected.model, thinkingLevel);
+	let activeThinkingLevel = clampThinkingLevel(
+		selected.model,
+		state?.thinkingLevel ?? thinkingLevel,
+	);
+	if (state) state.thinkingLevel = activeThinkingLevel;
 	let pendingQuestion = initialQuestion;
 	let composerDraft: string | undefined;
 	const createThinkingControl = (): BtwThreadThinkingControl => ({
@@ -398,6 +471,7 @@ export async function runBtwThread({
 		onChange: (level) => {
 			if (!thinkingLevels.includes(level)) return;
 			activeThinkingLevel = level;
+			if (state) state.thinkingLevel = level;
 			if (!rememberThinkingLevelChanges) return;
 			let write!: Promise<void>;
 			write = Promise.resolve()
@@ -458,6 +532,10 @@ export async function runBtwThread({
 					answer: result.message,
 				});
 			}
+			if (state) {
+				state.title ||= sanitizeSingleLine(pendingQuestion) || "Untitled side thread";
+				state.updatedAt = now();
+			}
 
 			pendingQuestion = steeringQuestions.shift();
 		}

package/src/menu.ts

@@ -22,9 +22,16 @@ interface BtwMenuState {
 	reason?: string;
 }
 
+export interface BtwResumeThreadSummary {
+	id: string;
+	title: string;
+	questionCount: number;
+}
+
 export interface ShowBtwCommandMenuOptions {
 	currentThinkingLevel: BtwThinkingLevel;
 	availableThinkingLevels: readonly BtwThinkingLevel[];
+	resumeThreads?: readonly BtwResumeThreadSummary[];
 	settingsPath?: string;
 	readSettings?: typeof readBtwSettings;
 	updateSettings?: (
@@ -33,10 +40,10 @@ export interface ShowBtwCommandMenuOptions {
 	) => Promise<BtwSettings>;
 }
 
-export type BtwCommandMenuResult = "start" | "closed";
+export type BtwCommandMenuResult = "start" | "closed" | { kind: "resume"; threadId: string };
 
-type BtwMenuScreen = "main" | "settings" | "invalid";
-type BtwMenuAction = "start" | "set-thinking" | "set-remember";
+type BtwMenuScreen = "main" | "resume" | "settings" | "invalid";
+type BtwMenuAction = "start" | "resume" | "set-thinking" | "set-remember";
 type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
 
 type BtwCustomFactory<T> = (
@@ -61,7 +68,9 @@ export async function showBtwCommandMenu(
 			? [...options.availableThinkingLevels]
 			: (["off"] satisfies BtwThinkingLevel[]);
 	const displaySettingsPath = sanitizeSingleLine(settingsPath);
+	const resumeThreads = options.resumeThreads ?? [];
 	let startSelected = false;
+	let resumedThreadId: string | undefined;
 
 	const loadState = async (): Promise<BtwMenuState> => {
 		const loaded = await readSettings(settingsPath);
@@ -89,6 +98,16 @@ export async function showBtwCommandMenu(
 						description: "Open an empty side thread",
 						action: "start",
 					},
+					...(resumeThreads.length > 0
+						? [
+								{
+									id: "resume" as const,
+									label: "Resume side thread",
+									description: "Continue an in-memory side thread",
+									to: "resume" as const,
+								},
+							]
+						: []),
 					{
 						id: "settings",
 						label: "Settings",
@@ -98,6 +117,18 @@ export async function showBtwCommandMenu(
 				],
 				hint: "close",
 			}),
+			resume: () => ({
+				kind: "choice",
+				title: "Resume BTW side thread",
+				items: resumeThreads.map((thread) => ({
+					id: thread.id,
+					label: thread.title,
+					description: `${thread.questionCount} ${thread.questionCount === 1 ? "question" : "questions"}`,
+				})),
+				action: "resume",
+				viewportSize: 10,
+				hint: "back",
+			}),
 			settings: ({ state }) => ({
 				kind: "settings",
 				title: "Pi BTW Settings",
@@ -136,6 +167,13 @@ export async function showBtwCommandMenu(
 				startSelected = true;
 				return { kind: "close" };
 			},
+			resume: async ({ itemId }: { itemId: string }) => {
+				if (!resumeThreads.some((thread) => thread.id === itemId)) {
+					return { kind: "rejected" } as const;
+				}
+				resumedThreadId = itemId;
+				return { kind: "close" } as const;
+			},
 			"set-thinking": async ({ value, signal }) => {
 				if (!value || !levels.includes(value as BtwThinkingLevel)) return { kind: "rejected" };
 				try {
@@ -172,9 +210,9 @@ export async function showBtwCommandMenu(
 	const result = await runBtwMenuPreservingEditor(ctx, (menuContext) =>
 		runMenu(menuContext, menu, { getState: loadState }),
 	);
-	return startSelected && result.kind === "closed" && result.reason === "close"
-		? "start"
-		: "closed";
+	if (result.kind !== "closed" || result.reason !== "close") return "closed";
+	if (resumedThreadId) return { kind: "resume", threadId: resumedThreadId };
+	return startSelected ? "start" : "closed";
 }
 
 export async function runBtwMenuPreservingEditor(