@vanillagreen/pi-qol 2.3.2 → 2.3.4

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
 

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,
@@ -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.3.4",
   "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": [