@vanillagreen/pi-qol 2.2.1 → 2.3.4

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,8 +11,18 @@ 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,
+ *  or failed with the load's error. */
+export type QolSessionSearchLoad =
+	| { status: "loading" }
+	| { status: "ready"; sessions: QolSessionSearchSession[] }
+	| { status: "failed"; error: string };
+
 export interface QolSessionSearchResult extends QolSessionSearchSession {
 	rank: number;
 	snippets: string[];

package/extensions/qol/settings.ts

@@ -1,113 +1,18 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
 import { CONFIG_ID } from "./constants.js";
+import { piSettingsPaths, readPackageConfig, readSettingsFiles } from "./package-config.js";
 
 export type kendexConfig = Record<string, unknown>;
 
-export function expandHome(input: string): string {
-	if (input === "~") return homedir();
-	if (input.startsWith("~/")) return join(homedir(), input.slice(2));
-	return input;
-}
-
-export function projectSettingsPath(cwd: string): string {
-	let current = resolve(cwd);
-	while (true) {
-		const candidate = join(current, ".pi", "settings.json");
-		if (existsSync(candidate)) return candidate;
-		if (existsSync(join(current, ".pi")) || existsSync(join(current, ".git")) || existsSync(join(current, ".kendex-lock.json"))) return candidate;
-		const parent = dirname(current);
-		if (parent === current) return join(resolve(cwd), ".pi", "settings.json");
-		current = parent;
-	}
-}
-
-const PROJECT_TRUST_SYMBOL = Symbol.for("kendex.pi.project-trust");
-
-interface ProjectTrustRegistry {
-	projectSettings?: Map<string, boolean>;
-}
-
-function projectTrustRegistry(): ProjectTrustRegistry {
-	const host = globalThis as unknown as Record<PropertyKey, ProjectTrustRegistry | undefined>;
-	const existing = host[PROJECT_TRUST_SYMBOL];
-	if (existing) return existing;
-	const created: ProjectTrustRegistry = {};
-	host[PROJECT_TRUST_SYMBOL] = created;
-	return created;
-}
-
-export function recordProjectTrust(ctx: { cwd?: string; isProjectTrusted?: () => boolean }): void {
-	if (!ctx.cwd) return;
-	let trusted = true;
-	try {
-		trusted = ctx.isProjectTrusted?.() === true;
-	} catch {
-		trusted = false;
-	}
-	const registry = projectTrustRegistry();
-	if (!registry.projectSettings) registry.projectSettings = new Map();
-	registry.projectSettings.set(projectSettingsPath(ctx.cwd), trusted);
-}
-
-function projectSettingsTrusted(settingsPath: string): boolean {
-	return projectTrustRegistry().projectSettings?.get(settingsPath) === true;
-}
-
-/** Root-anchored as `crates/core/src/harness/pi.rs::pi_root_is_absolute_for`
- * means it, which `isAbsolute` is not: it calls a driveless `\root` absolute
- * where the renderer does not, putting the two on different roots. Hoisted, so
- * a circular import cannot reach it inside a temporal dead zone. */
-function rootAnchored(path: string, windows: boolean): boolean { return windows ? /^(?:[A-Za-z]:[\\/]|[\\/]{2}[^\\/]+[\\/][^\\/]+)/.test(path) : path.startsWith("/"); }
-
-export function piSettingsPaths(cwd = process.cwd()): string[] {
-	const override = expandHome(process.env.PI_CODING_AGENT_DIR?.trim() || "");
-	const userDir = resolve(rootAnchored(override, process.platform === "win32") ? override : expandHome("~/.pi/agent"));
-	const user = join(userDir, "settings.json");
-	const project = projectSettingsPath(cwd);
-	return projectSettingsTrusted(project) ? [user, project] : [user];
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-/** Each settings file `piSettingsPaths` names that exists and parses, later
- * files overriding earlier ones. A malformed file is skipped, as Pi's own
- * settings load treats one as empty. */
-function readPiSettingsFiles(cwd?: string): Record<string, any>[] {
-	const files: Record<string, any>[] = [];
-	for (const settingsPath of piSettingsPaths(cwd)) {
-		if (!existsSync(settingsPath)) continue;
-		try {
-			const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
-			if (isRecord(parsed)) files.push(parsed);
-		} catch {
-			// Ignore a malformed settings file.
-		}
-	}
-	return files;
-}
-
-export function readPackageConfig(packageId: string, cwd?: string): Record<string, unknown> {
-	const merged: Record<string, unknown> = {};
-	for (const settings of readPiSettingsFiles(cwd)) {
-		const config = settings.kendex?.extensionManager?.config?.[packageId];
-		if (isRecord(config)) Object.assign(merged, config);
-	}
-	return merged;
-}
-
 /** Pi core's `compaction.enabled` over the files QOL reads its own config
  * from, resolved as Pi's `SettingsManager.getCompactionEnabled` resolves it:
  * the last file that sets the key decides, a key no file sets is Pi's default,
  * true, and any falsy value turns compaction off. */
 export function piCompactionEnabled(cwd?: string): boolean {
 	let enabled: unknown;
-	for (const settings of readPiSettingsFiles(cwd)) {
-		const compaction = settings.compaction;
-		if (isRecord(compaction) && compaction.enabled !== undefined) enabled = compaction.enabled;
+	for (const file of readSettingsFiles(piSettingsPaths(cwd))) {
+		if (file.kind !== "parsed") continue;
+		const compaction = file.settings.compaction as { enabled?: unknown } | null | undefined;
+		if (compaction && typeof compaction === "object" && !Array.isArray(compaction) && compaction.enabled !== undefined) enabled = compaction.enabled;
 	}
 	return Boolean(enabled ?? true);
 }