@vanillagreen/pi-qol 2.2.1 → 2.3.4

package/extensions/qol/session-search/cache.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { SessionManager, type ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -8,9 +8,13 @@ import {
 	DEFAULT_SESSION_SEARCH_SHORTCUT,
 	SESSION_SEARCH_PENDING_SYMBOL,
 	SESSION_SEARCH_STATUS_KEY,
+	SESSION_SEARCH_TEXT_MAX_CHARS,
+	SESSION_SEARCH_TEXT_MAX_CHARS_PER_SESSION,
+	SESSION_SEARCH_USER_MESSAGES_MAX_SESSIONS,
 } from "../constants.js";
-import { expandHome, piSettingsPaths, settingBoolean, settingNumber, settingString, settingStringAllowEmpty } from "../settings.js";
-import { forEachSessionJsonlLine } from "./jsonl.js";
+import { expandHome, piSettingsPaths, readSettingsFiles } from "../package-config.js";
+import { settingBoolean, settingNumber, settingString, settingStringAllowEmpty } from "../settings.js";
+import { forEachSessionJsonlLine, forEachSessionJsonlLineAsync } from "./jsonl.js";
 import type {
 	QolSessionPaletteAction,
 	QolSessionSearchPendingMessage,
@@ -23,12 +27,34 @@ import type {
 let qolSessionSearchCache: QolSessionSearchSession[] = [];
 let qolSessionSearchLoadedAt = 0;
 let qolSessionSearchLoading: Promise<QolSessionSearchSession[]> | undefined;
+let qolSessionSearchLoadController: AbortController | undefined;
+let qolSessionSearchReleaseTimer: ReturnType<typeof setTimeout> | undefined;
+/** Parsed user prompts per session path, oldest insertion first; at most
+ *  SESSION_SEARCH_USER_MESSAGES_MAX_SESSIONS entries. */
 const qolSessionUserMessagesCache = new Map<string, QolSessionUserMessage[]>();
-export const qolSessionSearchPendingActions = new Map<string, QolSessionPaletteAction>();
+/** The resume or fork action the editor's `/search:resume-pending <id>` line
+ *  names. Queuing another replaces it, since the editor holds one line. */
+let qolSessionSearchPendingAction: { id: string; action: QolSessionPaletteAction } | undefined;
 let qolSessionSearchPendingActionCounter = 0;
 
-export function nextSessionSearchPendingActionId(): string {
-	return `ss-${Date.now().toString(36)}-${(++qolSessionSearchPendingActionCounter).toString(36)}`;
+/** Hold `action` as the one pending action and return the id that claims it. */
+export function queueSessionSearchPendingAction(action: QolSessionPaletteAction): string {
+	const id = `ss-${Date.now().toString(36)}-${(++qolSessionSearchPendingActionCounter).toString(36)}`;
+	qolSessionSearchPendingAction = { id, action };
+	return id;
+}
+
+/** Remove and return the pending action when `id` names it. */
+export function takeSessionSearchPendingAction(id: string): QolSessionPaletteAction | undefined {
+	if (qolSessionSearchPendingAction?.id !== id) return undefined;
+	const { action } = qolSessionSearchPendingAction;
+	qolSessionSearchPendingAction = undefined;
+	return action;
+}
+
+/** Drop the pending action. Runs on session shutdown. */
+export function clearSessionSearchPendingAction(): void {
+	qolSessionSearchPendingAction = undefined;
 }
 
 export function getPendingSessionSearchMessage(): QolSessionSearchPendingMessage | undefined {
@@ -82,62 +108,136 @@ function configuredSessionDir(cwd: string): string | undefined {
 	const envDir = process.env.PI_CODING_AGENT_SESSION_DIR?.trim();
 	if (envDir) return resolveSettingsRelativePath(envDir, join(resolve(cwd), ".pi", "settings.json"));
 	let configured: string | undefined;
-	for (const settingsPath of piSettingsPaths(cwd)) {
-		if (!existsSync(settingsPath)) continue;
-		try {
-			const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
-			if (typeof parsed?.sessionDir === "string" && parsed.sessionDir.trim()) {
-				configured = resolveSettingsRelativePath(parsed.sessionDir, settingsPath);
-			}
-		} catch {
-			// Ignore malformed optional settings.
-		}
+	for (const file of readSettingsFiles(piSettingsPaths(cwd))) {
+		if (file.kind !== "parsed") continue;
+		const sessionDir = file.settings.sessionDir;
+		if (typeof sessionDir === "string" && sessionDir.trim()) configured = resolveSettingsRelativePath(sessionDir, file.path);
 	}
 	return configured;
 }
 
-function canonicalPathForSessionSearch(path: string | undefined): string | undefined {
-	if (!path) return undefined;
+/** Resolve a project once at index entry. A deleted directory keeps its
+ * absolute spelling; other filesystem failures remain visible. */
+export async function canonicalPathForSessionSearch(path: string): Promise<string> {
 	try {
-		return realpathSync.native(path);
-	} catch {
-		return resolve(path);
+		return await realpath(path);
+	} catch (error) {
+		if (["ENOENT", "ENOTDIR"].includes((error as NodeJS.ErrnoException).code ?? "")) return resolve(path);
+		throw error;
 	}
 }
 
-export function sameSessionSearchProject(sessionCwd: string | undefined, cwd: string): boolean {
-	return canonicalPathForSessionSearch(sessionCwd) === canonicalPathForSessionSearch(cwd);
+/** Prepare prompts and canonical projects asynchronously. Both the shared
+ * cache and an overlay supplied with sessions use this index entry point. */
+export async function prepareQolSessionSearchSessions(sessions: QolSessionSearchSession[], signal: AbortSignal): Promise<QolSessionSearchSession[]> {
+	const paths = new Map<string, string>();
+	let budget = SESSION_SEARCH_TEXT_MAX_CHARS;
+	const prepared: QolSessionSearchSession[] = [];
+	for (const session of [...sessions].sort((a, b) => b.modified.getTime() - a.modified.getTime())) {
+		signal.throwIfAborted();
+		let canonicalCwd = session.canonicalCwd ?? paths.get(session.cwd);
+		if (canonicalCwd === undefined) {
+			canonicalCwd = session.cwd ? await canonicalPathForSessionSearch(session.cwd) : "";
+			paths.set(session.cwd, canonicalCwd);
+		}
+		const messages: QolSessionUserMessage[] = [];
+		let remaining = Math.min(SESSION_SEARCH_TEXT_MAX_CHARS_PER_SESSION, budget);
+		const keep = (message: QolSessionUserMessage) => {
+			if (remaining <= 0) return;
+			const text = message.text.slice(0, remaining);
+			remaining -= text.length;
+			budget -= text.length;
+			messages.push({ ...message, text });
+		};
+		if (session.userMessages !== undefined) session.userMessages.forEach(keep);
+		else if (remaining > 0) {
+			try {
+				let index = 0;
+				await forEachSessionJsonlLineAsync(session.path, (line) => {
+					const message = userMessageFromLine(line, index + 1);
+					if (message) { index++; keep(message); }
+				}, signal);
+			} catch (error) {
+				signal.throwIfAborted();
+				// Pi can list a session which is removed before its prompt read.
+				if (!["ENOENT", "ENOTDIR"].includes((error as NodeJS.ErrnoException).code ?? "")) throw error;
+			}
+		}
+		prepared.push({ ...session, canonicalCwd, userMessages: messages });
+	}
+	signal.throwIfAborted();
+	return prepared;
 }
 
 export function defaultSessionSearchScope(cwd?: string): QolSessionSearchScope {
 	return settingString("sessionSearch.defaultScope", "current", cwd).toLowerCase() === "all" ? "all" : "current";
 }
 
-async function loadQolSessionSearchSessions(ctx: ExtensionContext, onProgress?: (loaded: number, total: number) => void): Promise<QolSessionSearchSession[]> {
+/** Cap the message text the index keeps: each session's text at the per-session
+ *  limit, and the sum at the index limit, filled newest session first. */
+export function capSessionSearchText(sessions: QolSessionSearchSession[]): QolSessionSearchSession[] {
+	let budget = SESSION_SEARCH_TEXT_MAX_CHARS;
+	const newestFirst = [...sessions].sort((a, b) => b.modified.getTime() - a.modified.getTime());
+	for (const session of newestFirst) {
+		const kept = session.allMessagesText.slice(0, Math.min(SESSION_SEARCH_TEXT_MAX_CHARS_PER_SESSION, budget));
+		budget -= kept.length;
+		session.allMessagesText = kept;
+	}
+	return sessions;
+}
+
+async function loadQolSessionSearchSessions(ctx: ExtensionContext, signal: AbortSignal, onProgress?: (loaded: number, total: number) => void): Promise<QolSessionSearchSession[]> {
 	const customSessionDir = configuredSessionDir(ctx.cwd);
 	const infos = customSessionDir
-		? await SessionManager.list(ctx.cwd, customSessionDir, onProgress)
-		: await SessionManager.listAll(onProgress);
-	return infos.map(sessionInfoToSearchSession).filter((session): session is QolSessionSearchSession => session !== undefined);
+		? await SessionManager.list(ctx.cwd, customSessionDir, onProgress, signal)
+		: await SessionManager.listAll(onProgress, signal);
+	signal.throwIfAborted();
+	return prepareQolSessionSearchSessions(capSessionSearchText(infos.map(sessionInfoToSearchSession).filter((session): session is QolSessionSearchSession => session !== undefined)), signal);
+}
+
+/** Drop the loaded index and the parsed prompts. Runs when the index outlives
+ *  its TTL and on session shutdown; the next search loads the index again. */
+export function releaseQolSessionSearchCache(): void {
+	qolSessionSearchLoadController?.abort();
+	qolSessionSearchLoadController = undefined;
+	qolSessionSearchLoading = undefined;
+	if (qolSessionSearchReleaseTimer) clearTimeout(qolSessionSearchReleaseTimer);
+	qolSessionSearchReleaseTimer = undefined;
+	qolSessionSearchCache = [];
+	qolSessionSearchLoadedAt = 0;
+	qolSessionUserMessagesCache.clear();
 }
 
 export async function refreshQolSessionSearchCache(ctx: ExtensionContext, options?: { force?: boolean; quiet?: boolean }): Promise<QolSessionSearchSession[]> {
 	const ttlMs = Math.max(0, settingNumber("sessionSearch.cacheTtlSeconds", DEFAULT_SESSION_SEARCH_CACHE_TTL_SECONDS, ctx.cwd) * 1000);
+	// A TTL of 0 keeps the index until session shutdown.
 	const fresh = qolSessionSearchCache.length > 0 && (ttlMs === 0 || Date.now() - qolSessionSearchLoadedAt < ttlMs);
 	if (!options?.force && fresh) return qolSessionSearchCache;
 	if (qolSessionSearchLoading) return qolSessionSearchLoading;
 
 	if (!options?.quiet && ctx.hasUI) ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, "Loading sessions...");
-	qolSessionSearchLoading = loadQolSessionSearchSessions(ctx, (loaded, total) => {
+	const controller = new AbortController();
+	qolSessionSearchLoadController = controller;
+	qolSessionSearchLoading = loadQolSessionSearchSessions(ctx, controller.signal, (loaded, total) => {
+		if (controller.signal.aborted) return;
 		if (!options?.quiet && ctx.hasUI) ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, `Loading sessions ${loaded}/${total}`);
 	}).then((sessions) => {
+		controller.signal.throwIfAborted();
+		qolSessionSearchLoadController = undefined;
+		releaseQolSessionSearchCache();
 		qolSessionSearchCache = sessions;
 		qolSessionSearchLoadedAt = Date.now();
-		qolSessionUserMessagesCache.clear();
+		if (ttlMs > 0) {
+			qolSessionSearchReleaseTimer = setTimeout(releaseQolSessionSearchCache, ttlMs);
+			qolSessionSearchReleaseTimer.unref?.();
+		}
 		return sessions;
 	}).finally(() => {
-		qolSessionSearchLoading = undefined;
-		if (!options?.quiet && ctx.hasUI) ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, undefined);
+		if (qolSessionSearchLoadController === controller || !controller.signal.aborted) {
+			qolSessionSearchLoadController = undefined;
+			qolSessionSearchLoading = undefined;
+			if (!options?.quiet && ctx.hasUI) ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, undefined);
+		}
 	});
 	return qolSessionSearchLoading;
 }
@@ -162,40 +262,69 @@ function sessionMessageTimestamp(entry: any, message: any): number | undefined {
 	return undefined;
 }
 
+function userMessageFromLine(line: string, index: number, fullText = false): QolSessionUserMessage | undefined {
+	let entry: { type?: string; id?: unknown; parentId?: unknown; timestamp?: unknown; message?: { role?: string; content?: unknown; timestamp?: unknown } };
+	try { entry = JSON.parse(line); } catch { return undefined; }
+	const message = entry?.type === "message" ? entry.message : undefined;
+	if (message?.role !== "user") return undefined;
+	const content = messageContentText(message.content);
+	const text = fullText ? content : oneLine(content);
+	if (!text) return undefined;
+	return {
+		entryId: typeof entry.id === "string" ? entry.id : undefined,
+		index,
+		parentId: typeof entry.parentId === "string" || entry.parentId === null ? entry.parentId : undefined,
+		text,
+		timestamp: sessionMessageTimestamp(entry, message),
+	};
+}
+
 export function sessionUserMessages(sessionPath: string): QolSessionUserMessage[] {
 	const cached = qolSessionUserMessagesCache.get(sessionPath);
 	if (cached) return cached;
 	const messages: QolSessionUserMessage[] = [];
 	try {
 		forEachSessionJsonlLine(sessionPath, (line) => {
-			if (!line.trim()) return;
-			let entry: any;
-			try { entry = JSON.parse(line); } catch { return; }
-			const message = entry?.type === "message" ? entry.message : undefined;
-			if (!message || message.role !== "user") return;
-			const text = oneLine(messageContentText(message.content));
-			if (!text) return;
-			messages.push({
-				entryId: typeof entry.id === "string" ? entry.id : undefined,
-				index: messages.length + 1,
-				parentId: typeof entry.parentId === "string" || entry.parentId === null ? entry.parentId : undefined,
-				text,
-				timestamp: sessionMessageTimestamp(entry, message),
-			});
+			const message = userMessageFromLine(line, messages.length + 1);
+			if (message) messages.push(message);
 		});
 	} catch {
 		// Ignore unreadable sessions; callers fall back to SessionInfo.firstMessage.
 	}
 	qolSessionUserMessagesCache.set(sessionPath, messages);
+	for (const oldest of qolSessionUserMessagesCache.keys()) {
+		if (qolSessionUserMessagesCache.size <= SESSION_SEARCH_USER_MESSAGES_MAX_SESSIONS) break;
+		qolSessionUserMessagesCache.delete(oldest);
+	}
 	return messages;
 }
 
 export function userMessagesForResult(result: QolSessionSearchResult): QolSessionUserMessage[] {
-	const messages = sessionUserMessages(result.path);
+	const messages = result.userMessages ?? sessionUserMessages(result.path);
 	if (messages.length > 0) return messages;
 	return [{ index: 1, text: oneLine(result.firstMessage || "No user messages") }];
 }
 
+/** Load the original Copy/Fork payload without retaining it in the index.
+ * SessionManager.open reads synchronously, so use Pi's documented JSONL
+ * format to stream to the selected entry instead. */
+export async function sessionUserMessageForAction(result: QolSessionSearchResult, selected?: QolSessionUserMessage, signal = new AbortController().signal): Promise<QolSessionUserMessage> {
+	let found: QolSessionUserMessage | undefined;
+	let index = 0;
+	await forEachSessionJsonlLineAsync(result.path, (line) => {
+		const message = userMessageFromLine(line, index + 1, true);
+		if (!message) return;
+		index++;
+		if (selected?.entryId ? message.entryId === selected.entryId : message.index === (selected?.index ?? 1)) {
+			found = message;
+			return false;
+		}
+	}, signal, { maxLineChars: Infinity });
+	signal.throwIfAborted();
+	if (!found) throw new Error(`Session prompt not found: ${selected?.entryId ?? selected?.index ?? 1}`);
+	return found;
+}
+
 export function sessionUserPromptCount(session: QolSessionSearchSession): number {
 	const count = sessionUserMessages(session.path).length;
 	if (count > 0) return count;

package/extensions/qol/session-search/component.ts

@@ -5,17 +5,18 @@ import { SESSION_SEARCH_OVERLAY_HEIGHT_RATIO } from "../constants.js";
 import { settingNumber } from "../settings.js";
 import {
 	defaultSessionSearchScope,
+	canonicalPathForSessionSearch,
+	prepareQolSessionSearchSessions,
 	modelLabel,
 	sameModel,
-	sameSessionSearchProject,
 	sessionModelInfo,
 	sessionResumeTitle,
 	shortPathForUi,
 	userMessagesForResult,
+	sessionUserMessageForAction,
 	type QolModelInfo,
 } from "./cache.js";
 import {
-	buildPromptSnippet,
 	formatSessionSearchDate,
 	parseSessionSearchQuery,
 	promptRecencyTime,
@@ -29,6 +30,7 @@ import type {
 	QolSessionMessagesState,
 	QolSessionPaletteAction,
 	QolSessionSearchHit,
+	QolSessionSearchLoad,
 	QolSessionSearchResult,
 	QolSessionSearchScope,
 	QolSessionSearchSession,
@@ -108,7 +110,8 @@ export class QolSessionSearchComponent {
 	private readonly done: (action: QolSessionPaletteAction) => void;
 	private readonly tui: { requestRender(): void; terminal?: { rows?: number } };
 	private readonly theme: Theme;
-	private readonly sessions: QolSessionSearchSession[];
+	/** The index, while it loads, once loaded, or the load's failure. */
+	private sessions: QolSessionSearchLoad;
 	private readonly cwd: string;
 	private readonly currentModel: QolModelInfo | undefined;
 	private screen: "search" | "messages" | "actions" | "confirmContext" | "confirmFork" | "confirmModel" = "search";
@@ -119,18 +122,38 @@ export class QolSessionSearchComponent {
 	private contextConfirmState: QolSessionContextConfirmState | undefined;
 	private forkConfirmState: QolSessionForkConfirmState | undefined;
 	private confirmModelState: QolSessionConfirmModelState | undefined;
+	private readonly indexController = new AbortController();
+	private queryController: AbortController | undefined;
+	private debounceTimer: ReturnType<typeof setTimeout> | undefined;
+	private currentSessions: QolSessionSearchSession[] = [];
+	private searchStatus: { status: "searching" | "action" } | { status: "ready" } | { status: "failed"; error: string } = { status: "ready" };
 
 
 	constructor(
 		done: (action: QolSessionPaletteAction) => void,
 		tui: { requestRender(): void; terminal?: { rows?: number } },
 		theme: Theme,
-		sessions: QolSessionSearchSession[],
+		sessions: QolSessionSearchLoad,
 		cwd: string,
 		initialQuery = "",
 		currentModel: QolModelInfo | undefined = undefined,
 	) {
-		this.done = done;
+		this.done = async (action) => {
+			try {
+				if (action.type === "copy" || action.type === "fork") {
+					this.screen = "search";
+					this.searchStatus = { status: "action" };
+					this.tui.requestRender();
+					action = { ...action, message: await sessionUserMessageForAction(action.result!, action.message, this.indexController.signal) };
+				}
+				if (this.indexController.signal.aborted) return;
+				this.dispose(); done(action);
+			} catch (error) {
+				if (this.indexController.signal.aborted) return;
+				this.searchStatus = { status: "failed", error: `${action.type === "copy" ? "Copy" : "Fork"} failed: ${String(error)}` };
+				this.tui.requestRender();
+			}
+		};
 		this.tui = tui;
 		this.theme = theme;
 		this.sessions = sessions;
@@ -138,19 +161,55 @@ export class QolSessionSearchComponent {
 		this.currentModel = currentModel;
 		const query = initialQuery.trim();
 		const scope = defaultSessionSearchScope(cwd);
-		const scopedSessions = this.sessionsForScope(scope);
 		this.searchState = {
 			cursor: query.length,
 			query,
-			results: searchQolSessionHits(scopedSessions, query, cwd),
+			results: [],
 			selected: 0,
 			scope,
-			total: scopedSessions.length,
+			total: 0,
 		};
+		if (sessions.status === "ready") this.setSessions(sessions);
 	}
 
 	invalidate(): void {}
 
+	/** Pi disposes a completed custom overlay. Late loads cannot redraw it. */
+	dispose(): void {
+		this.indexController.abort();
+		this.queryController?.abort();
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		this.debounceTimer = undefined;
+		this.currentSessions = [];
+		this.sessions = { status: "loading" };
+		this.searchState.results = [];
+	}
+
+	/** Show the index once its load settles; the overlay opens before that. */
+	setSessions(sessions: QolSessionSearchLoad): void {
+		const signal = this.indexController.signal;
+		if (signal.aborted) return;
+		if (sessions.status !== "ready") {
+			this.sessions = sessions;
+			this.tui.requestRender();
+			return;
+		}
+		this.sessions = { status: "loading" };
+		void Promise.all([
+			prepareQolSessionSearchSessions(sessions.sessions, signal),
+			canonicalPathForSessionSearch(this.cwd),
+		]).then(([prepared, cwd]) => {
+			if (signal.aborted) return;
+			this.sessions = { status: "ready", sessions: prepared };
+			this.currentSessions = prepared.filter((session) => session.canonicalCwd === cwd);
+			this.updateResults(false);
+		}, (error: unknown) => {
+			if (signal.aborted) return;
+			this.sessions = { status: "failed", error: String(error) };
+			this.tui.requestRender();
+		});
+	}
+
 	private maxOverlayRows(): number {
 		const terminalRows = Number(this.tui.terminal?.rows ?? process.stdout.rows ?? 30);
 		const safeRows = Number.isFinite(terminalRows) && terminalRows > 0 ? terminalRows : 30;
@@ -196,6 +255,7 @@ export class QolSessionSearchComponent {
 	}
 
 	handleInput(data: string): void {
+		if (this.searchStatus.status === "action") return matchesKey(data, "escape") ? this.done({ type: "cancel" }) : undefined;
 		if (this.screen === "messages" && this.messagesState) this.handleMessagesInput(data);
 		else if (this.screen === "actions" && this.actionState) this.handleActionInput(data);
 		else if (this.screen === "confirmContext" && this.contextConfirmState) this.handleContextConfirmInput(data);
@@ -213,17 +273,35 @@ export class QolSessionSearchComponent {
 	}
 
 	private sessionsForScope(scope = this.searchState.scope): QolSessionSearchSession[] {
-		if (scope === "all") return this.sessions;
-		return this.sessions.filter((session) => sameSessionSearchProject(session.cwd, this.cwd));
+		if (this.sessions.status !== "ready") return [];
+		if (scope === "all") return this.sessions.sessions;
+		return this.currentSessions;
 	}
 
 	private updateResults(resetSelection = true): void {
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		this.debounceTimer = undefined;
+		this.queryController?.abort();
+		if (this.indexController.signal.aborted || this.sessions.status !== "ready") return;
+		const controller = new AbortController();
+		this.queryController = controller;
 		const state = this.searchState;
 		const scopedSessions = this.sessionsForScope(state.scope);
-		state.results = searchQolSessionHits(scopedSessions, state.query, this.cwd);
+		state.results = [];
+		this.searchStatus = { status: "searching" };
 		state.total = scopedSessions.length;
 		if (resetSelection) state.selected = 0;
-		this.clampSelection();
+		void searchQolSessionHits(scopedSessions, state.query, this.cwd, controller.signal).then((results) => {
+			if (controller.signal.aborted || this.indexController.signal.aborted) return;
+			state.results = results;
+			this.searchStatus = { status: "ready" };
+			this.clampSelection();
+			this.tui.requestRender();
+		}, (error: unknown) => {
+			if (controller.signal.aborted || this.indexController.signal.aborted) return;
+			this.searchStatus = { status: "failed", error: String(error) };
+			this.tui.requestRender();
+		});
 	}
 
 	private toggleScope(): void {
@@ -234,7 +312,11 @@ export class QolSessionSearchComponent {
 	private updateQuery(query: string, cursor: number): void {
 		this.searchState.query = query;
 		this.searchState.cursor = Math.max(0, Math.min(cursor, query.length));
-		this.updateResults(true);
+		this.queryController?.abort();
+		this.searchState.results = [];
+		this.searchStatus = { status: "searching" };
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		this.debounceTimer = setTimeout(() => this.updateResults(true), 20);
 	}
 
 	private selectedMessageIndex(messages: QolSessionUserMessage[], query: string): number {
@@ -614,7 +696,15 @@ export class QolSessionSearchComponent {
 		if (!compact) lines.push(row(dim(`tokens · re:<pattern> regex · "phrase" exact`)));
 		lines.push(divider());
 
-		if (state.results.length === 0) {
+		if (this.sessions.status === "loading") {
+			lines.push(row(muted("Loading sessions…")));
+		} else if (this.sessions.status === "failed") {
+			lines.push(row(muted(`Could not load sessions: ${this.sessions.error.split("\n")[0]}`)));
+		} else if (this.searchStatus.status === "failed") {
+			lines.push(row(muted(`Search failed: ${this.searchStatus.error.split("\n")[0]}`)));
+		} else if (this.searchStatus.status === "searching" || this.searchStatus.status === "action") {
+			lines.push(row(muted(this.searchStatus.status === "action" ? "Loading prompt…  Esc cancel" : "Searching…")));
+		} else if (state.results.length === 0) {
 			lines.push(row(muted(state.query.trim() ? "No prompts match your search" : "No prompts found")));
 		} else {
 			lines.push(...this.renderSearchHitPane(inner, row, dim, muted, accent));

package/extensions/qol/session-search/index.ts

@@ -5,9 +5,8 @@ import { settingNumber } from "../settings.js";
 import { stringifyError } from "../util.js";
 import {
 	getPendingSessionSearchMessage,
-	nextSessionSearchPendingActionId,
 	pinSessionModel,
-	qolSessionSearchPendingActions,
+	queueSessionSearchPendingAction,
 	refreshQolSessionSearchCache,
 	sessionDisplayName,
 	setPendingSessionSearchMessage,
@@ -17,12 +16,14 @@ import {
 	buildSessionSearchContextMessageWithLoader,
 	injectSessionSearchContext,
 } from "./context.js";
-import type { QolSessionPaletteAction, QolSessionSearchResult } from "./types.js";
+import type { QolSessionPaletteAction, QolSessionSearchLoad, QolSessionSearchResult } from "./types.js";
 
 export {
-	qolSessionSearchPendingActions,
+	clearSessionSearchPendingAction,
 	refreshQolSessionSearchCache,
+	releaseQolSessionSearchCache,
 	sessionSearchShortcut,
+	takeSessionSearchPendingAction,
 } from "./cache.js";
 export { renderSessionSearchContextMessage } from "./context.js";
 
@@ -31,8 +32,7 @@ function asCommandContext(ctx: ExtensionContext): (ExtensionContext & Partial<Ex
 }
 
 function queueSessionSearchCommandAction(ctx: ExtensionContext, action: QolSessionPaletteAction): void {
-	const id = nextSessionSearchPendingActionId();
-	qolSessionSearchPendingActions.set(id, action);
+	const id = queueSessionSearchPendingAction(action);
 	ctx.ui.setEditorText(`/search:resume-pending ${id}`);
 	ctx.ui.notify(`${sessionDisplayName(action.result!)} — press enter to ${action.type === "fork" ? "fork" : "resume"}`, "info");
 }
@@ -42,12 +42,12 @@ export async function runSessionSearchResumeOrFork(pi: ExtensionAPI, ctx: Extens
 	const commandCtx = asCommandContext(ctx);
 	if (typeof commandCtx.switchSession !== "function") return false;
 	const targetTitle = sessionDisplayName(action.result);
-	const selectedMessage = action.type === "fork" ? action.message : undefined;
 	const currentModel = action.keepCurrentModel ? ctx.model : undefined;
 	const currentThinking = action.keepCurrentModel && typeof pi.getThinkingLevel === "function" ? pi.getThinkingLevel() : undefined;
-	if (currentModel) pinSessionModel(action.result.path, currentModel, currentThinking);
 	let replacementStarted = false;
 	try {
+		const selectedMessage = action.type === "fork" ? action.message : undefined;
+		if (currentModel) pinSessionModel(action.result.path, currentModel, currentThinking);
 		const result = await commandCtx.switchSession(action.result.path, {
 			withSession: async (replacementCtx: any) => {
 				replacementStarted = true;
@@ -68,7 +68,7 @@ export async function runSessionSearchResumeOrFork(pi: ExtensionAPI, ctx: Extens
 		});
 		if (result.cancelled) ctx.ui.notify(selectedMessage ? "Fork cancelled" : "Resume cancelled", "info");
 	} catch (error) {
-		if (!replacementStarted) ctx.ui.notify(`${selectedMessage ? "Fork" : "Resume"} failed: ${stringifyError(error)}`, "error");
+		if (!replacementStarted) ctx.ui.notify(`${action.type === "fork" ? "Fork" : "Resume"} failed: ${stringifyError(error)}`, "error");
 	}
 	return true;
 }
@@ -121,13 +121,28 @@ export async function openQolSessionSearch(pi: ExtensionAPI, ctx: ExtensionConte
 		ctx.ui.notify("Session search requires interactive UI", "warning");
 		return;
 	}
-	const sessions = await refreshQolSessionSearchCache(ctx);
+	// The overlay opens at once and fills in when the index is loaded: a
+	// released index takes a full read of every session file to load again.
+	const loading: Promise<QolSessionSearchLoad> = refreshQolSessionSearchCache(ctx).then(
+		(sessions) => ({ status: "ready", sessions }),
+		(error) => ({ status: "failed", error: stringifyError(error) }),
+	);
 	const releaseModalLock = acquirekendexModalLock();
 	let action: QolSessionPaletteAction | undefined;
+	let component: QolSessionSearchComponent | undefined;
 	try {
 		const currentModel = ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined;
-		action = await ctx.ui.custom<QolSessionPaletteAction>((tui, theme, _keybindings, done) =>
-			new QolSessionSearchComponent(done, tui, theme, sessions, ctx.cwd, initialQuery, currentModel), {
+		action = await ctx.ui.custom<QolSessionPaletteAction>((tui, theme, _keybindings, done) => {
+			component = new QolSessionSearchComponent((selected) => {
+				if (selected.type === "copy") {
+					ctx.ui.setEditorText(selected.message!.text);
+					ctx.ui.notify("Copied selected prompt into the editor", "info");
+				}
+				done(selected);
+			}, tui, theme, { status: "loading" }, ctx.cwd, initialQuery, currentModel);
+			void loading.then((load) => component?.setSessions(load));
+			return component;
+		}, {
 			overlay: true,
 			overlayOptions: {
 				anchor: "center",
@@ -136,6 +151,7 @@ export async function openQolSessionSearch(pi: ExtensionAPI, ctx: ExtensionConte
 			},
 		});
 	} finally {
+		component?.dispose();
 		releaseModalLock();
 	}
 	if (!action || action.type === "cancel" || !action.result) return;
@@ -143,12 +159,6 @@ export async function openQolSessionSearch(pi: ExtensionAPI, ctx: ExtensionConte
 		if (!(await runSessionSearchResumeOrFork(pi, ctx, action))) queueSessionSearchCommandAction(ctx, action);
 		return;
 	}
-	if (action.type === "copy") {
-		const text = action.message?.text || action.result.firstMessage;
-		ctx.ui.setEditorText(text);
-		ctx.ui.notify("Copied selected prompt into the editor", "info");
-		return;
-	}
 	if (action.type === "summarize") {
 		try {
 			await injectSessionSearchContext(pi, ctx, action.result, action.customPrompt);