@vanillagreen/pi-qol 2.3.2 → 2.4.0

package/README.md

@@ -33,8 +33,10 @@ The extension reads your enabled features when Pi starts. It adds their editor c
 
 - A session without a UI loads no session-search index. With a UI, the index is loaded shortly after start and kept for `sessionSearch.cacheTtlSeconds` (default 300 seconds; 0 keeps it until the session ends). A search after the index was released opens at once and fills in when the index has loaded again.
 - The index keeps at most 32,768 characters of message text per session and 8,388,608 characters in total, newest session first. A session past the total is searched by name, path and first prompt only.
+- Prepared user prompts have the same per-session and total character limits, measured in decoded UTF-16 code units. Indexing skips JSONL records above 2,097,152 decoded UTF-16 code units, not bytes. Copy and Fork read the complete selected prompt separately. Search waits 20 ms after the last edit and cancels an older query. Regex matching runs in a disposable worker with a 25 ms deadline and a separate 1 second startup deadline. A deadline error appears in the search popup.
+- Submitted image paths and existing clipboard images share a 20 MiB raw-byte limit. The extension checks all file sizes before reading any image. A refusal blocks submission and reports an error. It restores the rejected prompt only if the editor is empty; a newer draft stays unchanged. Print and JSON callers receive the diagnostic on stderr.
 - Where Pi cannot switch sessions directly, a chosen resume or fork waits as one `/search:resume-pending` command in the editor. Only the latest one is kept, and it is dropped when the session ends.
-- Parsed prompts are kept for at most 64 sessions, and finished thinking times for at most 256 blocks. Thinking labels are released at the end of each agent run, and notification cooldown entries once their cooldown has passed and all of them when the session ends.
+- The separate on-demand parsed-prompt cache keeps at most 64 sessions. The prepared search index uses the character limits above, not this session count. Finished thinking times are kept for at most 256 blocks. Thinking labels are released at the end of each agent run, and notification cooldown entries once their cooldown has passed and all of them when the session ends.
 
 ## Saved files
 
@@ -49,14 +51,14 @@ Open `/extensions:settings`; settings appear under the **QOL** tab. Project sett
 - `enabled`: package toggle for everything below.
 - Statusline and editor: `statusline.enabled`, `statusline.showProvider`, `statusline.showAccount`, `replaceFooter`, `compactPrompt`, `showSessionNameTitle`, `showSessionNameWindow`, `inputBottomPaddingLines`, `gitRefreshTimeoutMs`, `showDirtyMarker`, `newlineOnShiftEnter`, `newlineFallbackKey`, `pendingQueue.asciiGreen`, `showImageChips`, `showAttachmentCountInStatus`.
 - Commands: `enableSessionNameCommand`, `enableHandoffCommand`, `enableScheduleCommand`, `enableContextCommand`, `handoffReviewPrompt`.
-- Session naming: `sessionAutoRename.*` (model, fallback model, deterministic fallback, prefix, prompt, limits, notify, debug).
+- Session naming: `sessionAutoRename.*` (model, fallback model, deterministic fallback, prefix, prompt, limits, notify, debug). `sessionAutoRename.maxTokens` also counts the naming model's reasoning tokens: with `gpt-5.4-mini` naming 40 issue-sized first messages, 22 got a title at 96 and 29 at 128, the default. `sessionAutoRename.maxNameChars` stays 80 because no title in those runs was longer than 36 characters, so 70 and 80 give the same names.
 - Session search: `sessionSearch.*` (shortcut, result and row limits, snippets, overlay width, cache TTL, summary model and limits).
 - Rate limits: `rateLimitAutoResume.*`.
 - Permission gate: `permissionGate.enabled`, `permissionGate.commands` (comma-separated literal fragments or `/regex/flags`), `permissionGate.previewLines`, `permissionGate.previewChars`.
 - Notifications: `notification.*` (triggers, channels, tmux options, protocol, cooldown, title and body).
-- Compaction and budget guard: `compaction.*` (custom summaries, model, profile, remote endpoint, branch summaries, idle trigger, budget guard thresholds, chunk input cap, handoff artifact, transcript-risk budget).
+- Compaction and budget guard: `compaction.*` (custom summaries, model, profile, remote endpoint, branch summaries, idle trigger, budget guard thresholds, chunk input cap, handoff artifact, transcript-risk budget). `compaction.maxTokens` stays 8192, the cap on the budget-guard, custom and branch summaries. The fleet value considered was 10192, but no comparison was possible: the fleet's settings, Pi's `compaction.enabled` false with `compaction.customEnabled` and `compaction.branchSummaryEnabled` off, run none of these summaries.
   - Pi's own `compaction.enabled` (the top-level `compaction` object in the same settings files, not a QOL key) turns off every automatic compaction: when it is `false`, neither the budget guard nor the idle trigger starts one, and `/qol` reports both as disabled by that key. A manual `/compact` still runs. While it is `true` or absent, both keep the defaults and thresholds above: the budget guard on at `compaction.budgetPercent` 85, the idle trigger off until `compaction.idleEnabled` is set.
-- Thinking: `thinkingLabel.text`, `thinkingTimer.enabled`, `workingIndicator.mode` (`static` if the animated indicator flashes).
+- Thinking: `thinkingLabel.text`, `thinkingTimer.enabled`, `workingIndicator.mode`. `workingIndicator.mode` defaults to `static`, a dot with no animation timer; `animated` restores Pi's spinner. In a scripted 100-second streaming session on Pi 1.0.1, `animated` drew 2050 and 2080 frames with 4.9 s of CPU, and `static` 867 and 873 frames with 3.2 to 3.4 s. `thinkingTimer.enabled` stays on because turning it off in the same session changed neither the frames (2056 and 2066) nor the CPU (4.8 to 4.9 s).
 
 **Show model provider** displays a readable provider name before the model, such as `Copilot / GPT 6 Astra`. It is on by default; changes apply on the next render without reloading. Disabling the QOL statusline leaves Pi's standalone working indicator in place.
 

package/extensions/qol/constants.ts

@@ -92,7 +92,7 @@ export const DEFAULT_AUTO_RENAME_MODEL = "openai-codex/gpt-5.4-mini";
 export const DEFAULT_AUTO_RENAME_FALLBACK_MODEL = "current";
 export const DEFAULT_AUTO_RENAME_INPUT_CHARS = 2000;
 export const DEFAULT_AUTO_RENAME_NAME_CHARS = 80;
-export const DEFAULT_AUTO_RENAME_MAX_TOKENS = 96;
+export const DEFAULT_AUTO_RENAME_MAX_TOKENS = 128;
 export const DEFAULT_AUTO_RENAME_TIMEOUT_MS = 12_000;
 export const DEFAULT_INPUT_BOTTOM_PADDING_LINES = 0;
 

package/extensions/qol/images.ts

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { open } from "node:fs/promises";
 import { basename, resolve } from "node:path";
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { applyVisibleReplacements, buildVisibleMap, type VisibleReplacement } from "./ansi.js";
@@ -42,11 +43,44 @@ function mimeTypeForPath(path: string): string {
 	return "image/png";
 }
 
-export function imageContentForPath(path: string): { type: "image"; data: string; mimeType: string } | undefined {
+/** Submitted image paths and clipboard images share this raw-byte budget. */
+export const SUBMITTED_IMAGES_MAX_BYTES = 20 * 1024 * 1024;
+
+/** Stat every open file before reading any of them. Read only the observed
+ * bytes and one growth probe, so a growing file cannot bypass the budget. */
+export async function imageContentsForPaths(paths: string[], existing: Array<{ data: string }> = []): Promise<Array<{ type: "image"; data: string; mimeType: string }>> {
+	const files: Array<{ path: string; handle: Awaited<ReturnType<typeof open>>; size: number }> = [];
+	let total = existing.reduce((sum, image) => sum + Buffer.byteLength(image.data, "base64"), 0);
+	const checkSize = () => {
+		if (total > SUBMITTED_IMAGES_MAX_BYTES) throw new Error(`IMAGE_SIZE_LIMIT: ${total} bytes exceeds ${SUBMITTED_IMAGES_MAX_BYTES}`);
+	};
 	try {
-		return { data: readFileSync(path).toString("base64"), mimeType: mimeTypeForPath(path), type: "image" };
-	} catch {
-		return undefined;
+		checkSize();
+		for (const path of paths) {
+			const handle = await open(path, "r");
+			const file = { path, handle, size: 0 };
+			files.push(file);
+			const stat = await handle.stat();
+			if (!stat.isFile()) throw new Error(`IMAGE_NOT_FILE: ${path}`);
+			file.size = stat.size;
+			total += stat.size;
+			checkSize();
+		}
+		const buffers: Buffer[] = [];
+		for (const file of files) {
+			const buffer = Buffer.alloc(file.size + 1);
+			let offset = 0;
+			while (offset < buffer.length) {
+				const { bytesRead } = await file.handle.read(buffer, offset, buffer.length - offset, offset);
+				if (bytesRead === 0) break;
+				offset += bytesRead;
+			}
+			if (offset > file.size) throw new Error(`IMAGE_SIZE_CHANGED: ${file.path}`);
+			buffers.push(buffer.subarray(0, offset));
+		}
+		return files.map((file, index) => ({ type: "image", data: buffers[index]!.toString("base64"), mimeType: mimeTypeForPath(file.path) }));
+	} finally {
+		await Promise.all(files.map((file) => file.handle.close()));
 	}
 }
 

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

@@ -1,4 +1,4 @@
-import { 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";
@@ -14,7 +14,7 @@ import {
 } from "../constants.js";
 import { expandHome, piSettingsPaths, readSettingsFiles } from "../package-config.js";
 import { settingBoolean, settingNumber, settingString, settingStringAllowEmpty } from "../settings.js";
-import { forEachSessionJsonlLine } from "./jsonl.js";
+import { forEachSessionJsonlLine, forEachSessionJsonlLineAsync } from "./jsonl.js";
 import type {
 	QolSessionPaletteAction,
 	QolSessionSearchPendingMessage,
@@ -27,6 +27,7 @@ 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. */
@@ -115,17 +116,57 @@ function configuredSessionDir(cwd: string): string | undefined {
 	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 {
@@ -145,17 +186,21 @@ export function capSessionSearchText(sessions: QolSessionSearchSession[]): QolSe
 	return sessions;
 }
 
-async function loadQolSessionSearchSessions(ctx: ExtensionContext, onProgress?: (loaded: number, total: number) => void): Promise<QolSessionSearchSession[]> {
+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 capSessionSearchText(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 = [];
@@ -171,9 +216,14 @@ export async function refreshQolSessionSearchCache(ctx: ExtensionContext, option
 	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();
@@ -183,8 +233,11 @@ export async function refreshQolSessionSearchCache(ctx: ExtensionContext, option
 		}
 		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;
 }
@@ -209,26 +262,31 @@ 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.
@@ -242,11 +300,31 @@ export function sessionUserMessages(sessionPath: string): QolSessionUserMessage[
 }
 
 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,
@@ -121,6 +122,11 @@ 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(
@@ -132,7 +138,22 @@ export class QolSessionSearchComponent {
 		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;
@@ -140,24 +161,53 @@ 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 {
-		this.sessions = sessions;
-		this.updateResults(false);
-		this.tui.requestRender();
+		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 {
@@ -205,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);
@@ -224,16 +275,33 @@ export class QolSessionSearchComponent {
 	private sessionsForScope(scope = this.searchState.scope): QolSessionSearchSession[] {
 		if (this.sessions.status !== "ready") return [];
 		if (scope === "all") return this.sessions.sessions;
-		return this.sessions.sessions.filter((session) => sameSessionSearchProject(session.cwd, this.cwd));
+		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 {
@@ -244,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 {
@@ -628,6 +700,10 @@ export class QolSessionSearchComponent {
 			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 {

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

@@ -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;
 }
@@ -129,11 +129,18 @@ export async function openQolSessionSearch(pi: ExtensionAPI, ctx: ExtensionConte
 	);
 	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) => {
-			const component = new QolSessionSearchComponent(done, tui, theme, { status: "loading" }, ctx.cwd, initialQuery, currentModel);
-			void loading.then((load) => component.setSessions(load));
+			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,
@@ -144,6 +151,7 @@ export async function openQolSessionSearch(pi: ExtensionAPI, ctx: ExtensionConte
 			},
 		});
 	} finally {
+		component?.dispose();
 		releaseModalLock();
 	}
 	if (!action || action.type === "cancel" || !action.result) return;
@@ -151,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);

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

@@ -1,6 +1,38 @@
-import { closeSync, openSync, readSync } from "node:fs";
+import { closeSync, createReadStream, openSync, readSync } from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 
+/** Stream records off the input path. Index reads skip oversized records;
+ * an action can read a complete prompt and stop at its selected entry. */
+export async function forEachSessionJsonlLineAsync(sessionPath: string, onLine: (line: string) => unknown, signal: AbortSignal, options?: { maxLineChars: number }): Promise<void> {
+	const stream = createReadStream(sessionPath, { signal, highWaterMark: 64 * 1024 });
+	const decoder = new StringDecoder("utf8");
+	const maxLineChars = options?.maxLineChars ?? 2 * 1024 * 1024;
+	let pending = "";
+	let skipping = false;
+	try {
+		for await (const chunk of stream) {
+			signal.throwIfAborted();
+			const text = decoder.write(chunk);
+			let start = 0;
+			for (;;) {
+				const end = text.indexOf("\n", start);
+				const part = text.slice(start, end < 0 ? undefined : end);
+				if (!skipping && pending.length + part.length <= maxLineChars) pending += part;
+				else { pending = ""; skipping = true; }
+				if (end < 0) break;
+				if (!skipping && onLine(pending.endsWith("\r") ? pending.slice(0, -1) : pending) === false) return;
+				pending = "";
+				skipping = false;
+				start = end + 1;
+			}
+		}
+		pending += decoder.end();
+		if (!skipping && pending.length > 0) onLine(pending.endsWith("\r") ? pending.slice(0, -1) : pending);
+	} finally {
+		stream.destroy();
+	}
+}
+
 export function forEachSessionJsonlLine(sessionPath: string, onLine: (line: string) => void, chunkSize = 64 * 1024): void {
 	const fd = openSync(sessionPath, "r");
 	const buffer = Buffer.allocUnsafe(Math.max(1, Math.floor(chunkSize)));

package/extensions/qol/session-search/regex-worker.mjs

@@ -0,0 +1,12 @@
+import { parentPort } from "node:worker_threads";
+
+// The parent owns the deadline and terminates this worker even when exec
+// never returns. Neither prompt matching nor snippet matching runs in Pi.
+parentPort.on("message", ({ source, texts }) => {
+	const regex = new RegExp(source, "i");
+	parentPort.postMessage({ status: "matched", matches: texts.map((text) => {
+		const match = regex.exec(text);
+		return match ? { index: match.index, length: match[0].length } : null;
+	}) });
+});
+parentPort.postMessage({ status: "ready" });

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

@@ -0,0 +1,49 @@
+import { Worker } from "node:worker_threads";
+
+export interface SessionRegexMatch { index: number; length: number }
+type WorkerReply = { status: "ready" } | { status: "matched"; matches: Array<SessionRegexMatch | null> };
+
+/** Run one query's matching in a disposable worker. User-entered regex can
+ * backtrack forever, so the owner terminates it rather than timing exec. */
+export function sessionRegexMatches(source: string, texts: string[], signal: AbortSignal): Promise<Array<SessionRegexMatch | null>> {
+	signal.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const worker = new Worker(new URL("./regex-worker.mjs", import.meta.url), { execArgv: [], env: {} });
+		let settled = false;
+		// Startup is separate from the 25 ms execution budget.
+		let timer = setTimeout(() => finish(new Error("SESSION_SEARCH_REGEX_DEADLINE: worker startup")), 1000);
+		const finish = (error?: Error, matches?: Array<SessionRegexMatch | null>) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			signal.removeEventListener("abort", abort);
+			worker.removeAllListeners("message");
+			// A runtime can defer thread exit until native regex execution returns.
+			// Request cleanup without making input wait for that exit.
+			worker.unref();
+			void worker.terminate().catch((cleanupError: unknown) => {
+				console.error("Session regex worker cleanup failed:", cleanupError);
+			});
+			if (error) reject(error);
+			else resolve(matches!);
+		};
+		const abort = () => finish(new Error("Session search cancelled"));
+		signal.addEventListener("abort", abort, { once: true });
+		worker.on("message", (reply: WorkerReply) => {
+			if (settled) return;
+			switch (reply.status) {
+				case "ready":
+					clearTimeout(timer);
+					timer = setTimeout(() => finish(new Error("SESSION_SEARCH_REGEX_DEADLINE: 25 ms")), 25);
+					worker.postMessage({ source, texts });
+					break;
+				case "matched": finish(undefined, reply.matches); break;
+				default: { const unexpected: never = reply; finish(new Error(`Unknown regex worker reply: ${unexpected}`)); }
+			}
+		});
+		worker.once("error", (error) => finish(error));
+		worker.once("exit", (code) => {
+			if (!settled) finish(new Error(`Session regex worker exited before results: ${code}`));
+		});
+	});
+}

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

@@ -1,10 +1,9 @@
-import {
-	DEFAULT_SESSION_SEARCH_LIMIT,
-	DEFAULT_SESSION_SEARCH_PREVIEW_SNIPPETS,
-} from "../constants.js";
+import { setImmediate as yieldToInput } from "node:timers/promises";
+import { DEFAULT_SESSION_SEARCH_LIMIT } from "../constants.js";
 import { settingNumber } from "../settings.js";
 import { stringifyError } from "../util.js";
 import { sessionDisplayName, sessionResumeTitle, userMessagesForResult } from "./cache.js";
+import { sessionRegexMatches, type SessionRegexMatch } from "./regex.js";
 import type {
 	QolParsedSessionQuery,
 	QolSessionSearchHit,
@@ -13,10 +12,6 @@ import type {
 	QolSessionUserMessage,
 } from "./types.js";
 
-export function sessionSearchText(session: QolSessionSearchSession): string {
-	return [session.id, session.name ?? "", session.cwd, session.path, session.firstMessage, session.allMessagesText].join("\n");
-}
-
 export function normalizeSearchText(text: string): string {
 	return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
@@ -33,161 +28,57 @@ export function parseSessionSearchQuery(query: string): QolParsedSessionQuery {
 			return { error: stringifyError(error), mode: "regex", tokens: [] };
 		}
 	}
-
 	const tokens: QolParsedSessionQuery["tokens"] = [];
 	let buffer = "";
 	let inQuote = false;
-	let unclosed = false;
 	const flush = (kind: "fuzzy" | "phrase") => {
 		const value = buffer.trim();
 		buffer = "";
 		if (value) tokens.push({ kind, value });
 	};
-
-	for (let i = 0; i < trimmed.length; i++) {
-		const char = trimmed[i]!;
+	for (const char of trimmed) {
 		if (char === '"') {
-			if (inQuote) {
-				flush("phrase");
-				inQuote = false;
-			} else {
-				flush("fuzzy");
-				inQuote = true;
-			}
-			continue;
-		}
-		if (!inQuote && /\s/.test(char)) {
-			flush("fuzzy");
-			continue;
-		}
-		buffer += char;
+			flush(inQuote ? "phrase" : "fuzzy");
+			inQuote = !inQuote;
+		} else if (!inQuote && /\s/.test(char)) flush("fuzzy");
+		else buffer += char;
 	}
-	if (inQuote) unclosed = true;
-	if (unclosed) {
-		return {
-			mode: "tokens",
-			tokens: trimmed.split(/\s+/).filter(Boolean).map((value) => ({ kind: "fuzzy", value })),
-		};
-	}
-	flush(inQuote ? "phrase" : "fuzzy");
+	if (inQuote) return { mode: "tokens", tokens: trimmed.split(/\s+/).filter(Boolean).map((value) => ({ kind: "fuzzy", value })) };
+	flush("fuzzy");
 	return { mode: "tokens", tokens };
 }
 
-function searchWordLengthPenalty(word: string, query: string): number {
-	return Math.max(0, word.length - query.length);
-}
-
 export function searchStringScore(needle: string, haystack: string): number | undefined {
 	const query = normalizeSearchText(needle);
 	const text = normalizeSearchText(haystack);
 	if (!query) return 0;
 	let best: number | undefined;
-	const record = (score: number) => {
-		best = best === undefined ? score : Math.min(best, score);
-	};
+	const record = (score: number) => { best = best === undefined ? score : Math.min(best, score); };
 	if (/^[a-z0-9_]+$/i.test(query)) {
 		for (const match of text.matchAll(/[a-z0-9_]+/gi)) {
 			const word = match[0].toLowerCase();
+			const penalty = Math.max(0, word.length - query.length);
 			if (word === query) record(0);
-			else if (word.startsWith(query)) record(10 + searchWordLengthPenalty(word, query));
-			else if (word.includes(query)) record(100 + searchWordLengthPenalty(word, query));
+			else if (word.startsWith(query)) record(10 + penalty);
+			else if (word.includes(query)) record(100 + penalty);
 		}
 		return best;
 	}
 	return text.includes(query) ? 0 : undefined;
 }
 
-export function matchSessionSearch(session: QolSessionSearchSession, parsed: QolParsedSessionQuery): { matches: boolean; score: number } {
-	const text = sessionSearchText(session);
-	if (parsed.mode === "regex") {
-		if (!parsed.regex) return { matches: false, score: 0 };
-		const index = text.search(parsed.regex);
-		return index < 0 ? { matches: false, score: 0 } : { matches: true, score: 0 };
-	}
-	if (parsed.tokens.length === 0) return { matches: true, score: 0 };
-	let score = 0;
-	for (const token of parsed.tokens) {
-		const tokenScore = searchStringScore(token.value, text);
-		if (tokenScore === undefined) return { matches: false, score: 0 };
-		score += tokenScore;
-	}
-	return { matches: true, score };
-}
-
-function sessionSnippetSource(session: QolSessionSearchSession): string {
-	return (session.allMessagesText || session.firstMessage || "").replace(/\s+/g, " ").trim();
-}
-
 function snippetAround(text: string, start: number, length: number, width: number, lead = Math.floor(width / 3)): string {
-	const safeLead = Math.max(0, Math.min(width, lead));
-	const safeStart = Math.max(0, start - safeLead);
+	const safeStart = Math.max(0, start - Math.max(0, Math.min(width, lead)));
 	const safeEnd = Math.min(text.length, Math.max(start + length, safeStart + width));
-	const prefix = safeStart > 0 ? "…" : "";
-	const suffix = safeEnd < text.length ? "…" : "";
-	return `${prefix}${text.slice(safeStart, safeEnd)}${suffix}`;
-}
-
-export function buildSessionSnippets(session: QolSessionSearchSession, parsed: QolParsedSessionQuery, limit: number): string[] {
-	const source = sessionSnippetSource(session);
-	if (!source) return [];
-	if (parsed.mode === "regex" && parsed.regex) {
-		parsed.regex.lastIndex = 0;
-		const match = parsed.regex.exec(source);
-		return match ? [snippetAround(source, match.index, match[0].length, 220)] : [];
-	}
-	if (parsed.tokens.length === 0) return [source.slice(0, 220)];
-	const snippets: string[] = [];
-	const lower = source.toLowerCase();
-	const seen = new Set<string>();
-	for (const token of parsed.tokens) {
-		const value = normalizeSearchText(token.value);
-		if (!value) continue;
-		const index = lower.indexOf(value.toLowerCase());
-		if (index < 0) continue;
-		const snippet = snippetAround(source, index, value.length, 220);
-		const key = snippet.toLowerCase();
-		if (!seen.has(key)) {
-			seen.add(key);
-			snippets.push(snippet);
-		}
-		if (snippets.length >= limit) break;
-	}
-	return snippets.length > 0 ? snippets : [source.slice(0, 220)];
-}
-
-export function searchQolSessions(sessions: QolSessionSearchSession[], query: string, cwd: string): QolSessionSearchResult[] {
-	const limit = Math.max(1, Math.floor(settingNumber("sessionSearch.resultLimit", DEFAULT_SESSION_SEARCH_LIMIT, cwd)));
-	const snippetLimit = Math.max(1, Math.floor(settingNumber("sessionSearch.previewSnippets", DEFAULT_SESSION_SEARCH_PREVIEW_SNIPPETS, cwd)));
-	const parsed = parseSessionSearchQuery(query);
-	if (parsed.error) return [];
-	if (!query.trim()) {
-		return sessions
-			.slice()
-			.sort((a, b) => b.modified.getTime() - a.modified.getTime())
-			.slice(0, limit)
-			.map((session) => ({ ...session, rank: 0, snippets: buildSessionSnippets(session, { mode: "tokens", tokens: [] }, 1) }));
-	}
-	const results: QolSessionSearchResult[] = [];
-	for (const session of sessions) {
-		const match = matchSessionSearch(session, parsed);
-		if (!match.matches) continue;
-		results.push({ ...session, rank: match.score, snippets: buildSessionSnippets(session, parsed, snippetLimit) });
-	}
-	results.sort((a, b) => a.rank - b.rank || b.modified.getTime() - a.modified.getTime());
-	return results.slice(0, limit);
+	return `${safeStart > 0 ? "…" : ""}${text.slice(safeStart, safeEnd)}${safeEnd < text.length ? "…" : ""}`;
 }
 
 export function resultFromSession(session: QolSessionSearchSession, rank = 0, snippets: string[] = []): QolSessionSearchResult {
 	return { ...session, rank, snippets };
 }
 
-function matchTextSearch(text: string, parsed: QolParsedSessionQuery): { matches: boolean; score: number } {
-	if (parsed.mode === "regex") {
-		if (!parsed.regex) return { matches: false, score: 0 };
-		const index = text.search(parsed.regex);
-		return index < 0 ? { matches: false, score: 0 } : { matches: true, score: 0 };
-	}
-	if (parsed.tokens.length === 0) return { matches: true, score: 0 };
+function matchTextSearch(text: string, parsed: QolParsedSessionQuery, regexMatches: Map<string, SessionRegexMatch | null>): { matches: boolean; score: number } {
+	if (parsed.mode === "regex") return { matches: regexMatches.get(text) != null, score: 0 };
 	let score = 0;
 	for (const token of parsed.tokens) {
 		const tokenScore = searchStringScore(token.value, text);
@@ -201,24 +92,17 @@ function sessionTitleSearchText(session: QolSessionSearchSession): string {
 	return [session.name ?? "", sessionResumeTitle(session), sessionDisplayName(session)].join("\n");
 }
 
-function matchPromptSearch(_session: QolSessionSearchSession, message: QolSessionUserMessage, parsed: QolParsedSessionQuery): { matches: boolean; score: number } {
-	return matchTextSearch(message.text, parsed);
-}
-
-export function buildPromptSnippet(message: QolSessionUserMessage, parsed: QolParsedSessionQuery): string {
+export function buildPromptSnippet(message: QolSessionUserMessage, parsed: QolParsedSessionQuery, regexMatch?: SessionRegexMatch | null): string {
+	// Worker offsets refer to the original prompt, before whitespace collapses.
+	if (parsed.mode === "regex" && regexMatch) return snippetAround(message.text, regexMatch.index, Math.min(regexMatch.length, 160), 160, 24).replace(/\s+/g, " ").trim();
 	const source = message.text.replace(/\s+/g, " ").trim();
 	if (!source) return "";
-	if (parsed.mode === "regex" && parsed.regex) {
-		parsed.regex.lastIndex = 0;
-		const match = parsed.regex.exec(source);
-		return match ? snippetAround(source, match.index, match[0].length, 160, 24) : source.slice(0, 160);
-	}
-	if (parsed.tokens.length === 0) return source.slice(0, 160);
+	if (parsed.mode === "regex") return source.slice(0, 160);
 	const lower = source.toLowerCase();
 	for (const token of parsed.tokens) {
 		const value = normalizeSearchText(token.value);
 		if (!value) continue;
-		const index = lower.indexOf(value.toLowerCase());
+		const index = lower.indexOf(value);
 		if (index >= 0) return snippetAround(source, index, value.length, 160, 24);
 	}
 	return source.slice(0, 160);
@@ -235,48 +119,58 @@ function compareSessionSearchHitsRecent(a: QolSessionSearchHit, b: QolSessionSea
 		|| b.message.index - a.message.index;
 }
 
-export function searchQolSessionHits(sessions: QolSessionSearchSession[], query: string, cwd: string): QolSessionSearchHit[] {
+/** Search only prepared prompts. Yield between batches, cancel obsolete
+ * queries, and run all regex matching in a deadline-owned worker. */
+export async function searchQolSessionHits(sessions: QolSessionSearchSession[], query: string, cwd: string, signal: AbortSignal): Promise<QolSessionSearchHit[]> {
+	signal.throwIfAborted();
 	const limit = Math.max(1, Math.floor(settingNumber("sessionSearch.resultLimit", DEFAULT_SESSION_SEARCH_LIMIT, cwd)));
 	const parsed = parseSessionSearchQuery(query);
-	if (parsed.error) return [];
-	const hits: QolSessionSearchHit[] = [];
-	if (!query.trim()) {
-		for (const session of sessions) {
-			const result = resultFromSession(session);
-			for (const message of userMessagesForResult(result)) {
-				const snippet = buildPromptSnippet(message, parsed);
-				hits.push({ message, rank: 0, result: resultFromSession(session, 0, [snippet]), snippet });
-			}
-		}
-		hits.sort(compareSessionSearchHitsRecent);
-		return hits.slice(0, limit);
+	if (parsed.error) throw new Error(parsed.error);
+	const regexMatches = new Map<string, SessionRegexMatch | null>();
+	if (parsed.mode === "regex" && parsed.regex) {
+		const texts = [...new Set(sessions.flatMap((session) => [sessionTitleSearchText(session), ...userMessagesForResult(resultFromSession(session)).map((message) => message.text)]))];
+		const matches = await sessionRegexMatches(parsed.regex.source, texts, signal);
+		texts.forEach((text, index) => regexMatches.set(text, matches[index]!));
 	}
+	const hits: QolSessionSearchHit[] = [];
+	let batchStarted = performance.now();
 	for (const session of sessions) {
+		signal.throwIfAborted();
+		const messages = userMessagesForResult(resultFromSession(session));
 		let addedPromptHit = false;
-		for (const message of userMessagesForResult(resultFromSession(session))) {
-			const match = matchPromptSearch(session, message, parsed);
-			if (!match.matches) continue;
-			const snippet = buildPromptSnippet(message, parsed);
-			hits.push({ message, rank: match.score, result: resultFromSession(session, match.score, [snippet]), snippet });
-			addedPromptHit = true;
+		for (const message of messages) {
+			const match = matchTextSearch(message.text, parsed, regexMatches);
+			if (match.matches) {
+				const snippet = buildPromptSnippet(message, parsed, regexMatches.get(message.text));
+				hits.push({ message, rank: match.score, result: resultFromSession(session, match.score, [snippet]), snippet });
+				addedPromptHit = true;
+			}
+			if (performance.now() - batchStarted >= 4) {
+				await yieldToInput(undefined, { signal });
+				batchStarted = performance.now();
+			}
 		}
 		if (!addedPromptHit) {
-			const titleMatch = matchTextSearch(sessionTitleSearchText(session), parsed);
-			if (!titleMatch.matches) continue;
-			const messages = userMessagesForResult(resultFromSession(session));
+			const titleMatch = matchTextSearch(sessionTitleSearchText(session), parsed, regexMatches);
 			const message = messages[messages.length - 1];
-			if (!message) continue;
-			const snippet = buildPromptSnippet(message, { mode: "tokens", tokens: [] });
-			hits.push({ message, rank: titleMatch.score, result: resultFromSession(session, titleMatch.score, [snippet]), snippet });
+			if (titleMatch.matches && message) {
+				const snippet = buildPromptSnippet(message, { mode: "tokens", tokens: [] });
+				hits.push({ message, rank: titleMatch.score, result: resultFromSession(session, titleMatch.score, [snippet]), snippet });
+			}
+		}
+		// Only the best resultLimit hits need to stay alive between batches.
+		if (hits.length > limit * 2) {
+			hits.sort((a, b) => a.rank - b.rank || compareSessionSearchHitsRecent(a, b));
+			hits.length = limit;
 		}
 	}
+	signal.throwIfAborted();
 	hits.sort((a, b) => a.rank - b.rank || compareSessionSearchHitsRecent(a, b));
 	return hits.slice(0, limit);
 }
 
 export function formatSessionSearchDate(date: Date): string {
-	const now = Date.now();
-	const diffMs = Math.max(0, now - date.getTime());
+	const diffMs = Math.max(0, Date.now() - date.getTime());
 	const diffMins = Math.floor(diffMs / 60_000);
 	const diffHours = Math.floor(diffMs / 3_600_000);
 	const diffDays = Math.floor(diffMs / 86_400_000);

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

@@ -11,6 +11,9 @@ export interface QolSessionSearchSession {
 	name?: string;
 	parentSessionPath?: string;
 	path: string;
+	/** Prepared once per index load, not read from disk during a query. */
+	canonicalCwd?: string;
+	userMessages?: QolSessionUserMessage[];
 }
 
 /** The session-search index as the overlay sees it: still loading, loaded,

package/extensions/qol.ts

@@ -39,7 +39,7 @@ import {
 	QolEditor,
 } from "./qol/editor.js";
 import { runHandoff } from "./qol/handoff.js";
-import { imageContentForPath, resolveSubmittedImagePaths } from "./qol/images.js";
+import { imageContentsForPaths, resolveSubmittedImagePaths } from "./qol/images.js";
 import {
 	clearTmuxWindowMark,
 	notifyQuestionOpened,
@@ -226,12 +226,12 @@ export default function qol(pi: ExtensionAPI): void {
 		thinkingTimerStore.enabled = !!ctx?.hasUI && settingBoolean("thinkingTimer.enabled", true, ctx?.cwd);
 	};
 
-	// Pi's Loader starts no animation timer for a single-frame indicator.
-	// Keep static mode available for terminals where frequent redraws flash,
-	// whether the indicator is embedded in QOL or in Pi's standalone row.
+	// Pi's Loader starts no animation timer for a single-frame indicator, so
+	// static mode, the default, draws no frames of its own whether the
+	// indicator is embedded in QOL or in Pi's standalone row.
 	const applyWorkingIndicatorMode = (ctx: ExtensionContext): void => {
 		if (!ctx.hasUI) return;
-		const mode = settingString("workingIndicator.mode", "animated", ctx.cwd);
+		const mode = settingString("workingIndicator.mode", "static", ctx.cwd);
 		if (mode === "static") {
 			ctx.ui.setWorkingVisible(true);
 			ctx.ui.setWorkingIndicator({ frames: [ctx.ui.theme.fg("accent", "●")] });
@@ -847,15 +847,24 @@ export default function qol(pi: ExtensionAPI): void {
 		if (event?.toolName === "tasks_write") maybeNotifyTaskCompletion(ctx, event.details?.state);
 	});
 
-	pi.on("input", async (event) => {
+	pi.on("input", async (event, ctx) => {
 		clearTmuxWindowMark(pi);
 		if (event.source === "extension") return { action: "continue" };
 		const text = event.text ?? "";
-		const paths = currentCtx?.cwd ? resolveSubmittedImagePaths(text, currentCtx.cwd) : [];
+		const paths = resolveSubmittedImagePaths(text, ctx.cwd);
 		if (paths.length === 0) return { action: "continue" };
-		const images = paths.map(imageContentForPath).filter(Boolean);
-		if (images.length === 0) return { action: "continue" };
-		return { action: "transform", images: [...(event.images ?? []), ...images], text: event.text };
+		try {
+			const images = await imageContentsForPaths(paths, event.images ?? []);
+			return { action: "transform", images: [...(event.images ?? []), ...images], text: event.text };
+		} catch (error) {
+			const message = `Image submission refused: ${stringifyError(error)}`;
+			ctx.ui.notify(message, "error");
+			// Print and JSON modes reserve stderr for diagnostics; input exceptions
+			// would let Pi continue submission instead of refusing the image.
+			if (!ctx.hasUI) console.error(message);
+			if (ctx.hasUI && ctx.ui.getEditorText() === "") ctx.ui.setEditorText(text);
+			return { action: "handled" };
+		}
 	});
 
 	if (settingBoolean("enableSessionNameCommand", true)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillagreen/pi-qol",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "description": "Pi quality-of-life extension: compact statusline/π prompt, reliable multiline input, styled pasted-image chips, session naming/search/context import, scheduled prompts, handoff, permission prompts, notifications, custom compaction, and a collapsed-thinking timer.",
   "license": "MIT",
   "keywords": [
@@ -310,9 +310,9 @@
         {
           "key": "sessionAutoRename.maxTokens",
           "label": "Auto-rename output tokens",
-          "description": "Maximum output tokens requested from the naming model.",
+          "description": "Maximum output tokens requested from the naming model, reasoning tokens included.",
           "type": "number",
-          "default": 96,
+          "default": 128,
           "category": "Session Auto-Rename",
           "apply": "live"
         },
@@ -966,13 +966,13 @@
         {
           "key": "workingIndicator.mode",
           "label": "Working indicator mode",
-          "description": "Control Pi's built-in streaming spinner. The default animated spinner ticks every 80ms; in terminals where rendered content overflows the viewport (chat scrolled past the top, /tree open, etc.) each tick can trigger a pi-tui full-screen redraw and visible flash. Use 'static' for a single non-animating dot that keeps the working indicator visible without the 80ms timer. It appears before the project name when the QOL statusline is enabled, or in Pi's working row otherwise.",
+          "description": "Control Pi's built-in streaming spinner. The default 'static' shows a single non-animating dot that keeps the working indicator visible without a timer. 'animated' restores Pi's spinner, which ticks every 80ms; in terminals where rendered content overflows the viewport (chat scrolled past the top, /tree open, etc.) each tick can trigger a pi-tui full-screen redraw and visible flash. It appears before the project name when the QOL statusline is enabled, or in Pi's working row otherwise.",
           "type": "enum",
           "enumValues": [
             "animated",
             "static"
           ],
-          "default": "animated",
+          "default": "static",
           "category": "Thinking",
           "apply": "reload",
           "requiresReload": true