@vanillagreen/pi-qol 1.2.0 → 1.3.0

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

@@ -0,0 +1,152 @@
+import { readFileSync } from "node:fs";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { SessionManager, type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { acquireVstackModalLock } from "../bridges.js";
+import { generateQolSummary, serializeMessagesForSummary } from "../compaction.js";
+import {
+	DEFAULT_SESSION_SEARCH_SUMMARY_INPUT_CHARS,
+	DEFAULT_SESSION_SEARCH_SUMMARY_MAX_TOKENS,
+	SESSION_SEARCH_CONTEXT_TYPE,
+	SESSION_SEARCH_STATUS_KEY,
+} from "../constants.js";
+import { settingNumber, settingString } from "../settings.js";
+import { sessionDisplayName } from "./cache.js";
+import { QolSessionSearchLoadingComponent } from "./component.js";
+import type { QolSessionSearchPendingMessage, QolSessionSearchResult } from "./types.js";
+
+export function trimSessionSummaryInput(text: string, cwd: string): string {
+	const maxChars = Math.max(20_000, Math.floor(settingNumber("sessionSearch.summaryInputMaxChars", DEFAULT_SESSION_SEARCH_SUMMARY_INPUT_CHARS, cwd)));
+	if (text.length <= maxChars) return text;
+	const headChars = Math.floor(maxChars * 0.35);
+	const tailChars = maxChars - headChars;
+	const omitted = text.length - maxChars;
+	return `${text.slice(0, headChars)}\n\n[... ${omitted.toLocaleString()} character(s) omitted from the middle of this imported session ...]\n\n${text.slice(-tailChars)}`;
+}
+
+function messagesForSessionSummary(sessionPath: string): AgentMessage[] {
+	try {
+		const manager = SessionManager.open(sessionPath);
+		const context = manager.buildSessionContext();
+		if (Array.isArray(context.messages) && context.messages.length > 0) return context.messages as AgentMessage[];
+	} catch {
+		// Fall back to a direct JSONL parse below.
+	}
+	try {
+		const lines = readFileSync(sessionPath, "utf8").split(/\r?\n/);
+		const messages: AgentMessage[] = [];
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			let entry: any;
+			try { entry = JSON.parse(line); } catch { continue; }
+			if (entry?.type === "message" && entry.message) messages.push(entry.message);
+		}
+		return messages;
+	} catch {
+		return [];
+	}
+}
+
+export async function buildSessionSearchContextMessage(ctx: ExtensionContext, result: QolSessionSearchResult, customPrompt?: string, signal?: AbortSignal): Promise<QolSessionSearchPendingMessage> {
+	const messages = messagesForSessionSummary(result.path);
+	const fallbackText = result.allMessagesText || result.firstMessage;
+	const conversationText = messages.length > 0 ? serializeMessagesForSummary(messages) : fallbackText;
+	if (!conversationText.trim()) throw new Error("Selected session has no text content to summarize");
+	const focus = customPrompt?.trim();
+	const summary = await generateQolSummary(ctx, {
+		conversationText: trimSessionSummaryInput(conversationText, ctx.cwd),
+		maxTokens: Math.max(256, Math.floor(settingNumber("sessionSearch.summaryMaxTokens", DEFAULT_SESSION_SEARCH_SUMMARY_MAX_TOKENS, ctx.cwd))),
+		model: settingString("sessionSearch.summaryModel", "current", ctx.cwd),
+		customInstructions: [
+			`Source session file: ${result.path}`,
+			`Source project/cwd: ${result.cwd || sessionDisplayName(result)}`,
+			focus ? `User focus: ${focus}` : "Focus on facts needed to continue or reference this previous session.",
+		].join("\n"),
+		purpose: "session-search",
+		signal: signal ?? ctx.signal,
+	});
+	const title = sessionDisplayName(result);
+	const content = [
+		`## Session Search Context: ${title}`,
+		`**Date:** ${result.modified.toISOString()} | **File:** ${result.path}`,
+		focus ? `**Focus:** ${focus}` : undefined,
+		"",
+		summary.summary,
+	].filter((line): line is string => line !== undefined).join("\n");
+	return {
+		content,
+		details: {
+			file: result.path,
+			focus,
+			model: summary.model,
+			project: result.cwd || title,
+			source: "pi-qol-session-search",
+			via: summary.via,
+		},
+	};
+}
+
+export async function buildSessionSearchContextMessageWithLoader(ctx: ExtensionContext, result: QolSessionSearchResult, customPrompt: string | undefined, actionLabel: string): Promise<QolSessionSearchPendingMessage> {
+	const title = sessionDisplayName(result);
+	if (!ctx.hasUI) return buildSessionSearchContextMessage(ctx, result, customPrompt);
+	ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, `Summarizing ${title}...`);
+	const releaseModalLock = acquireVstackModalLock();
+	let failure: unknown;
+	try {
+		const message = await ctx.ui.custom<QolSessionSearchPendingMessage | null>((tui: any, theme: any, _kb: any, done: (value: QolSessionSearchPendingMessage | null) => void) => {
+			let closed = false;
+			const loader = new QolSessionSearchLoadingComponent(tui, theme, actionLabel, "Summarizing session context...", (value) => {
+				if (closed) return;
+				closed = true;
+				done(value);
+			});
+			const finish = (value: QolSessionSearchPendingMessage | null) => {
+				if (closed) return;
+				closed = true;
+				loader.dispose();
+				done(value);
+			};
+			buildSessionSearchContextMessage(ctx, result, customPrompt, loader.signal)
+				.then(finish)
+				.catch((error) => {
+					if (!loader.signal?.aborted) failure = error;
+					finish(null);
+				});
+			return loader;
+		}, {
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: Math.max(56, Math.min(92, Math.floor(settingNumber("sessionSearch.overlayWidth", 104, ctx.cwd) * 0.75))),
+				maxHeight: "70%",
+			},
+		});
+		if (failure) throw failure;
+		if (!message) throw new Error("Session context summary cancelled");
+		return message;
+	} finally {
+		releaseModalLock();
+		ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, undefined);
+	}
+}
+
+export async function injectSessionSearchContext(pi: ExtensionAPI, ctx: ExtensionContext, result: QolSessionSearchResult, customPrompt?: string): Promise<void> {
+	const title = sessionDisplayName(result);
+	const message = await buildSessionSearchContextMessageWithLoader(ctx, result, customPrompt, "Inject + Context");
+	pi.sendMessage({ customType: SESSION_SEARCH_CONTEXT_TYPE, content: message.content, details: message.details, display: true }, { deliverAs: "followUp", triggerTurn: false });
+	ctx.ui.notify(`Session context injected: ${title}`, "info");
+}
+
+export function renderSessionSearchContextMessage(message: any, options: any, theme: Theme): Text {
+	const raw = typeof message.content === "string"
+		? message.content
+		: Array.isArray(message.content)
+			? message.content.map((part: any) => part?.type === "text" ? part.text ?? "" : "").join("")
+			: "";
+	const title = raw.match(/^## Session Search Context:\s*(.+)$/m)?.[1]?.trim() || "session";
+	const date = raw.match(/\*\*Date:\*\*\s*([^|\n]+)/)?.[1]?.trim() || "";
+	const header = `${theme.fg("customMessageLabel", theme.bold("Session context: "))}${theme.fg("accent", title)}${date ? theme.fg("muted", ` (${date})`) : ""}`;
+	if (!options?.expanded) return new Text(`${header}${theme.fg("dim", "  ctrl+o expand")}`, 0, 0);
+	const body = raw.slice(raw.indexOf("\n") + 1).trim();
+	return new Text(body ? `${header}\n\n${body}` : header, 0, 0);
+}

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

@@ -0,0 +1,171 @@
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { acquireVstackModalLock } from "../bridges.js";
+import { SESSION_SEARCH_CONTEXT_TYPE, SESSION_SEARCH_STATUS_KEY } from "../constants.js";
+import { settingNumber } from "../settings.js";
+import { stringifyError } from "../util.js";
+import {
+	getPendingSessionSearchMessage,
+	nextSessionSearchPendingActionId,
+	pinSessionModel,
+	qolSessionSearchPendingActions,
+	refreshQolSessionSearchCache,
+	sessionDisplayName,
+	setPendingSessionSearchMessage,
+} from "./cache.js";
+import { QolSessionSearchComponent } from "./component.js";
+import {
+	buildSessionSearchContextMessageWithLoader,
+	injectSessionSearchContext,
+} from "./context.js";
+import type { QolSessionPaletteAction, QolSessionSearchResult } from "./types.js";
+
+export {
+	qolSessionSearchPendingActions,
+	refreshQolSessionSearchCache,
+	sessionSearchShortcut,
+} from "./cache.js";
+export { renderSessionSearchContextMessage } from "./context.js";
+
+function asCommandContext(ctx: ExtensionContext): (ExtensionContext & Partial<ExtensionCommandContext>) {
+	return ctx as ExtensionContext & Partial<ExtensionCommandContext>;
+}
+
+function queueSessionSearchCommandAction(ctx: ExtensionContext, action: QolSessionPaletteAction): void {
+	const id = nextSessionSearchPendingActionId();
+	qolSessionSearchPendingActions.set(id, action);
+	ctx.ui.setEditorText(`/search:resume-pending ${id}`);
+	ctx.ui.notify(`${sessionDisplayName(action.result!)} — press Enter to ${action.type === "fork" ? "fork" : "resume"}`, "info");
+}
+
+export async function runSessionSearchResumeOrFork(pi: ExtensionAPI, ctx: ExtensionContext, action: QolSessionPaletteAction): Promise<boolean> {
+	if (!action.result || (action.type !== "resume" && action.type !== "fork")) return true;
+	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 result = await commandCtx.switchSession(action.result.path, {
+			withSession: async (replacementCtx: any) => {
+				replacementStarted = true;
+				if (currentModel) replacementCtx.ui.notify(`Using current model: ${currentModel.provider}/${currentModel.id}`, "info");
+				if (selectedMessage) {
+					const manager = replacementCtx.sessionManager as any;
+					if (selectedMessage.entryId && selectedMessage.parentId && typeof manager?.branch === "function") manager.branch(selectedMessage.parentId);
+					else if (selectedMessage.entryId && selectedMessage.parentId === null && typeof manager?.resetLeaf === "function") manager.resetLeaf();
+					replacementCtx.ui.setEditorText(selectedMessage.text);
+					const timer = setTimeout(() => {
+						replacementCtx.ui.notify(`Forked session: ${targetTitle} at prompt #${selectedMessage.index}. Submit to branch from here.`, "info");
+					}, 0);
+					timer.unref?.();
+					return;
+				}
+				replacementCtx.ui.notify(`Resumed session: ${targetTitle}${currentModel ? " with current model" : ""}`, "info");
+			},
+		});
+		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");
+	}
+	return true;
+}
+
+async function createNewSessionWithSearchContext(pi: ExtensionAPI, ctx: ExtensionContext, result: QolSessionSearchResult, customPrompt?: string): Promise<void> {
+	const title = sessionDisplayName(result);
+	const message = await buildSessionSearchContextMessageWithLoader(ctx, result, customPrompt, "New + Context");
+
+	const commandCtx = asCommandContext(ctx);
+	if (typeof commandCtx.newSession === "function") {
+		const parentSession = ctx.sessionManager.getSessionFile?.();
+		let replacementStarted = false;
+		try {
+			const switchResult = await commandCtx.newSession({
+				parentSession,
+				withSession: async (replacementCtx: any) => {
+					replacementStarted = true;
+					try {
+						if (typeof replacementCtx.sendMessage === "function") {
+							await replacementCtx.sendMessage({ customType: SESSION_SEARCH_CONTEXT_TYPE, content: message.content, details: message.details, display: true }, { triggerTurn: false });
+						}
+						replacementCtx.ui.notify(`New session has context from ${title}`, "info");
+					} catch (error) {
+						replacementCtx.ui.notify(`New session context import failed: ${stringifyError(error)}`, "error");
+					}
+				},
+			});
+			if (switchResult.cancelled) ctx.ui.notify("New session cancelled", "info");
+		} catch (error) {
+			if (!replacementStarted) throw error;
+		}
+		return;
+	}
+	setPendingSessionSearchMessage(message);
+	ctx.ui.setEditorText("/new");
+	ctx.ui.notify(`${title} — press enter to create a new session with this context`, "info");
+}
+
+export async function consumePendingSessionSearchContext(pi: ExtensionAPI, ctx: ExtensionContext, reason: unknown): Promise<void> {
+	if (reason !== "new") return;
+	const pending = getPendingSessionSearchMessage();
+	if (!pending) return;
+	setPendingSessionSearchMessage(undefined);
+	pi.sendMessage({ customType: SESSION_SEARCH_CONTEXT_TYPE, content: pending.content, details: pending.details, display: true }, { triggerTurn: false });
+	if (ctx.hasUI) ctx.ui.notify("Imported session-search context.", "info");
+}
+
+export async function openQolSessionSearch(pi: ExtensionAPI, ctx: ExtensionContext, initialQuery = ""): Promise<void> {
+	if (!ctx.hasUI) {
+		ctx.ui.notify("Session search requires interactive UI", "warning");
+		return;
+	}
+	const sessions = await refreshQolSessionSearchCache(ctx);
+	const releaseModalLock = acquireVstackModalLock();
+	let action: QolSessionPaletteAction | undefined;
+	try {
+		const currentModel = ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined;
+		action = await ctx.ui.custom<QolSessionPaletteAction>((tui, theme, _keybindings, done) =>
+			new QolSessionSearchComponent(done, tui, theme, sessions, ctx.cwd, initialQuery, currentModel), {
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: Math.max(70, Math.floor(settingNumber("sessionSearch.overlayWidth", 104, ctx.cwd))),
+				maxHeight: "90%",
+			},
+		});
+	} finally {
+		releaseModalLock();
+	}
+	if (!action || action.type === "cancel" || !action.result) return;
+	if (action.type === "resume" || action.type === "fork") {
+		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);
+		} catch (error) {
+			const message = stringifyError(error);
+			ctx.ui.notify(/cancelled/i.test(message) ? "Inject + Context cancelled" : `Inject + Context failed: ${message}`, /cancelled/i.test(message) ? "info" : "error");
+			ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, undefined);
+		}
+		return;
+	}
+	if (action.type === "newSession") {
+		try {
+			await createNewSessionWithSearchContext(pi, ctx, action.result, action.customPrompt);
+		} catch (error) {
+			const message = stringifyError(error);
+			ctx.ui.notify(/cancelled/i.test(message) ? "New + Context cancelled" : `New + Context failed: ${message}`, /cancelled/i.test(message) ? "info" : "error");
+			ctx.ui.setStatus(SESSION_SEARCH_STATUS_KEY, undefined);
+		}
+	}
+}

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

@@ -0,0 +1,288 @@
+import {
+	DEFAULT_SESSION_SEARCH_LIMIT,
+	DEFAULT_SESSION_SEARCH_PREVIEW_SNIPPETS,
+} from "../constants.js";
+import { settingNumber } from "../settings.js";
+import { stringifyError } from "../util.js";
+import { sessionDisplayName, sessionResumeTitle, userMessagesForResult } from "./cache.js";
+import type {
+	QolParsedSessionQuery,
+	QolSessionSearchHit,
+	QolSessionSearchResult,
+	QolSessionSearchSession,
+	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();
+}
+
+export function parseSessionSearchQuery(query: string): QolParsedSessionQuery {
+	const trimmed = query.trim();
+	if (!trimmed) return { mode: "tokens", tokens: [] };
+	if (trimmed.startsWith("re:")) {
+		const source = trimmed.slice(3).trim();
+		if (!source) return { error: "Empty regex", mode: "regex", tokens: [] };
+		try {
+			return { mode: "regex", regex: new RegExp(source, "i"), tokens: [] };
+		} catch (error) {
+			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]!;
+		if (char === '"') {
+			if (inQuote) {
+				flush("phrase");
+				inQuote = false;
+			} else {
+				flush("fuzzy");
+				inQuote = true;
+			}
+			continue;
+		}
+		if (!inQuote && /\s/.test(char)) {
+			flush("fuzzy");
+			continue;
+		}
+		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");
+	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);
+	};
+	if (/^[a-z0-9_]+$/i.test(query)) {
+		for (const match of text.matchAll(/[a-z0-9_]+/gi)) {
+			const word = match[0].toLowerCase();
+			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));
+		}
+		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 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);
+}
+
+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 };
+	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 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 {
+	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);
+	const lower = source.toLowerCase();
+	for (const token of parsed.tokens) {
+		const value = normalizeSearchText(token.value);
+		if (!value) continue;
+		const index = lower.indexOf(value.toLowerCase());
+		if (index >= 0) return snippetAround(source, index, value.length, 160, 24);
+	}
+	return source.slice(0, 160);
+}
+
+export function promptRecencyTime(hit: QolSessionSearchHit): number {
+	if (typeof hit.message.timestamp === "number" && Number.isFinite(hit.message.timestamp)) return hit.message.timestamp;
+	return hit.result.modified.getTime();
+}
+
+function compareSessionSearchHitsRecent(a: QolSessionSearchHit, b: QolSessionSearchHit): number {
+	return promptRecencyTime(b) - promptRecencyTime(a)
+		|| b.result.modified.getTime() - a.result.modified.getTime()
+		|| b.message.index - a.message.index;
+}
+
+export function searchQolSessionHits(sessions: QolSessionSearchSession[], query: string, cwd: string): QolSessionSearchHit[] {
+	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);
+	}
+	for (const session of sessions) {
+		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;
+		}
+		if (!addedPromptHit) {
+			const titleMatch = matchTextSearch(sessionTitleSearchText(session), parsed);
+			if (!titleMatch.matches) continue;
+			const messages = userMessagesForResult(resultFromSession(session));
+			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 });
+		}
+	}
+	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 diffMins = Math.floor(diffMs / 60_000);
+	const diffHours = Math.floor(diffMs / 3_600_000);
+	const diffDays = Math.floor(diffMs / 86_400_000);
+	if (diffMins < 1) return "now";
+	if (diffMins < 60) return `${diffMins}m ago`;
+	if (diffHours < 24) return `${diffHours}h ago`;
+	if (diffDays < 7) return `${diffDays}d ago`;
+	return date.toLocaleDateString("en-GB", { day: "numeric", month: "short" });
+}