pi-lens 3.8.24 → 3.8.26

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to pi-lens will be documented in this file.
 
 ## [Unreleased]
 
+## [3.8.26] - 2026-04-15
+
+### Fixed
+- **Silent crash on unhandled promise rejection** — the LSP crash guard's `unhandledRejection` handler was swallowing all non-ignorable rejections without rethrowing, causing silent process exits. The handler now rethrows so non-ignorable rejections surface as `uncaughtException` and are properly reported. Triggered most visibly when editing JSON files while Biome or another LSP server was active.
+
+## [3.8.25] - 2026-04-13
+
+### Changed
+- **Go LSP PATH augmentation on Windows** — LSP subprocess PATH now includes common Go install directories (`C:\Program Files\Go\bin`, `C:\Go\bin`) to prevent `gopls` startup/runtime failures when `go` is not in inherited shell PATH.
+- **Similarity runner cold-start behavior** — similarity now skips fast when no cached project index exists and for tiny/trivial files, reducing write/edit pipeline tail latency and eliminating frequent 30s timeout noise in scratch-file workflows.
+
+### Fixed
+- **Non-git workspace commit lookup noise** — metrics snapshot commit detection now pre-checks repository context before invoking Git, preventing `fatal: not a git repository` terminal noise in non-repo folders.
+
 ## [3.8.24] - 2026-04-12
 
 ### Changed

package/clients/dispatch/runners/architect.ts

@@ -47,7 +47,11 @@ const architectRunner: RunnerDefinition = {
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		const relPath = path.relative(ctx.cwd, ctx.filePath).replace(/\\/g, "/");
-		const content = readFileContent(ctx.filePath);
+		const contentFromFacts = ctx.facts.getFileFact<string | null>(
+			ctx.filePath,
+			"file.content",
+		);
+		const content = contentFromFacts ?? readFileContent(ctx.filePath);
 
 		if (!content) {
 			return { status: "skipped", diagnostics: [], semantic: "none" };

package/clients/dispatch/runners/ast-grep-napi.ts

@@ -423,10 +423,18 @@ const astGrepNapiRunner: RunnerDefinition = {
 		}
 
 		let content: string;
-		try {
-			content = fs.readFileSync(ctx.filePath, "utf-8");
-		} catch {
-			return { status: "skipped", diagnostics: [], semantic: "none" };
+		const contentFromFacts = ctx.facts.getFileFact<string | null>(
+			ctx.filePath,
+			"file.content",
+		);
+		if (contentFromFacts !== undefined && contentFromFacts !== null) {
+			content = contentFromFacts;
+		} else {
+			try {
+				content = fs.readFileSync(ctx.filePath, "utf-8");
+			} catch {
+				return { status: "skipped", diagnostics: [], semantic: "none" };
+			}
 		}
 
 		let root: import("@ast-grep/napi").SgRoot;

package/clients/dispatch/runners/similarity.ts

@@ -9,8 +9,8 @@ import * as nodeFs from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as ts from "typescript";
-import { EXCLUDED_DIRS } from "../../file-utils.js";
 import { NativeRustCoreClient } from "../../native-rust-client.js";
+import { collectSourceFiles } from "../../source-filter.js";
 import {
 	buildProjectIndex,
 	findSimilarFunctions,
@@ -40,6 +40,7 @@ const CONFIG = {
 	SIMILARITY_THRESHOLD: 0.96, // align with booboo: stricter to reduce boilerplate false positives
 	MIN_TRANSITIONS: 40, // stronger signal floor for structural comparisons
 	MIN_FUNCTION_LINES: 8, // Ignore tiny helpers/wrappers
+	MIN_FILE_CHARS: 140, // Skip tiny/trivial files early
 	MAX_TRANSITION_RATIO: 1.8, // Skip pairs with highly mismatched complexity/size
 	MAX_SUGGESTIONS: 3, // Max 3 suggestions per file
 	MAX_PER_TARGET_NAME: 1, // Avoid one-to-many spam for the same target utility
@@ -115,12 +116,26 @@ const similarityRunner: RunnerDefinition = {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
+		const lineCount = content.split(/\r?\n/).length;
+		if (
+			content.trim().length < CONFIG.MIN_FILE_CHARS ||
+			lineCount < CONFIG.MIN_FUNCTION_LINES + 2 ||
+			!/(\bfunction\b|=>)/.test(content)
+		) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
 		// Find project root and load index
 		const projectRoot = await findProjectRoot(filePath);
 		if (!projectRoot) {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
+		const cachedIndex = await loadCachedIndex(projectRoot);
+		if (!cachedIndex || cachedIndex.entries.size === 0) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
 		// ── Rust fast-path ─────────────────────────────────────────────────────
 		// Try Rust for file scanning + similarity detection. If the Rust binary
 		// is available, use it. On any failure, fall through to the pure-TS path.
@@ -139,10 +154,7 @@ const similarityRunner: RunnerDefinition = {
 		}
 		// ── TypeScript fallback ─────────────────────────────────────────────────
 
-		const index = await loadOrBuildIndex(projectRoot);
-		if (!index || index.entries.size === 0) {
-			return { status: "skipped", diagnostics: [], semantic: "none" };
-		}
+		const index = cachedIndex;
 
 		// Parse the file
 		const sourceFile = ts.createSourceFile(
@@ -512,30 +524,42 @@ async function loadOrBuildIndex(
 	}
 
 	// Build new index
-	const { glob } = await import("glob");
-	// Build ignore patterns from centralized EXCLUDED_DIRS
-	const ignorePatterns = [
-		...EXCLUDED_DIRS.map((d) => `**/${d}/**`),
-		"**/*.test.ts",
-		"**/*.spec.ts",
-		"**/*.poc.test.ts",
-	];
-	const files = await glob("**/*.ts", {
-		cwd: projectRoot,
-		ignore: ignorePatterns,
+	const absoluteFiles = collectSourceFiles(projectRoot, {
+		extensions: [".ts"],
+	}).filter((filePath) => {
+		const normalized = filePath.replace(/\\/g, "/");
+		return (
+			!normalized.endsWith(".test.ts") &&
+			!normalized.endsWith(".spec.ts") &&
+			!normalized.endsWith(".poc.test.ts")
+		);
 	});
 
-	if (files.length === 0) {
+	if (absoluteFiles.length === 0) {
 		return null;
 	}
 
-	const absoluteFiles = files.map((f) => path.join(projectRoot, f));
 	const index = await buildProjectIndex(projectRoot, absoluteFiles);
 
 	indexCache.set(projectRoot, index);
 	return index;
 }
 
+async function loadCachedIndex(projectRoot: string): Promise<ProjectIndex | null> {
+	const cached = indexCache.get(projectRoot);
+	if (cached) {
+		return cached;
+	}
+
+	const existing = await loadIndex(projectRoot);
+	if (!existing) {
+		return null;
+	}
+
+	indexCache.set(projectRoot, existing);
+	return existing;
+}
+
 // ============================================================================
 // Testing Helper
 // ============================================================================

package/clients/dispatch/runners/tree-sitter.ts

@@ -519,13 +519,27 @@ const treeSitterRunner: RunnerDefinition = {
 		});
 
 		const diagnostics: Diagnostic[] = [];
+		const contentFromFacts = ctx.facts.getFileFact<string | null>(
+			filePath,
+			"file.content",
+		);
+		const contentOverride =
+			contentFromFacts !== undefined && contentFromFacts !== null
+				? contentFromFacts
+				: undefined;
 
 		// Run each query against the file
 		for (const query of effectiveQueries) {
 			try {
-				const matches = await client.runQueryOnFile(query, filePath, languageId, {
-					maxResults: 10,
-				});
+				const matches = await client.runQueryOnFile(
+					query,
+					filePath,
+					languageId,
+					{
+						maxResults: 10,
+					},
+					contentOverride,
+				);
 
 				for (const match of matches) {
 					// Get line/column from match (already 0-indexed from tree-sitter)

package/clients/lsp/client.ts

@@ -271,6 +271,7 @@ function installCrashGuard(): void {
 		if (isIgnorableLspRuntimeCrash(reason)) {
 			return;
 		}
+		throw reason instanceof Error ? reason : new Error(String(reason));
 	});
 }
 

package/clients/lsp/index.ts

@@ -31,6 +31,20 @@ export interface LSPState {
 }
 
 const BROKEN_RETRY_COOLDOWN_MS = 15_000;
+const OPTIONAL_LSP_RETRY_COOLDOWN_MS = 5 * 60_000;
+const OPTIONAL_LSP_SERVER_IDS = new Set(["biome-lsp"]);
+const NAV_CLIENT_WAIT_TIMEOUT_MS = Math.max(
+	0,
+	Number.parseInt(
+		process.env.PI_LENS_LSP_NAV_CLIENT_WAIT_MS ?? "700",
+		10,
+	) || 700,
+);
+const TOUCH_DEBOUNCE_MS = Math.max(
+	0,
+	Number.parseInt(process.env.PI_LENS_LSP_TOUCH_DEBOUNCE_MS ?? "1500", 10) ||
+		1500,
+);
 const SESSIONSTART_LOG_DIR = path.join(os.homedir(), ".pi-lens");
 const SESSIONSTART_LOG = path.join(SESSIONSTART_LOG_DIR, "sessionstart.log");
 
@@ -57,6 +71,12 @@ export class LSPService {
 	private workspaceProbeLogged = new Set<string>();
 	private warmStartLogged = new Set<string>();
 	private emitConsoleLspErrors = process.env.PI_LENS_CONSOLE_LSP === "1";
+	private optionalFailureLogged = new Set<string>();
+	private optionalDisabled = new Set<string>();
+	private recentTouches = new Map<
+		string,
+		{ fingerprint: string; touchedAt: number; clientScope: "primary" | "all" }
+	>();
 
 	constructor() {
 		this.state = {
@@ -67,11 +87,57 @@ export class LSPService {
 		};
 	}
 
+	private fingerprintContent(content: string): string {
+		if (content.length <= 96) {
+			return `${content.length}:${content}`;
+		}
+		return `${content.length}:${content.slice(0, 48)}:${content.slice(-48)}`;
+	}
+
+	private shouldSkipTouch(
+		filePath: string,
+		content: string,
+		clientScope: "primary" | "all",
+		waitForDiagnostics: boolean,
+	): boolean {
+		if (waitForDiagnostics || TOUCH_DEBOUNCE_MS <= 0) {
+			return false;
+		}
+
+		const key = `${normalizeMapKey(filePath)}:${clientScope}`;
+		const previous = this.recentTouches.get(key);
+		if (!previous) return false;
+
+		const now = Date.now();
+		if (now - previous.touchedAt > TOUCH_DEBOUNCE_MS) {
+			return false;
+		}
+
+		return previous.fingerprint === this.fingerprintContent(content);
+	}
+
+	private markTouched(
+		filePath: string,
+		content: string,
+		clientScope: "primary" | "all",
+	): void {
+		const key = `${normalizeMapKey(filePath)}:${clientScope}`;
+		this.recentTouches.set(key, {
+			fingerprint: this.fingerprintContent(content),
+			touchedAt: Date.now(),
+			clientScope,
+		});
+	}
+
 	/**
 	 * Get or create LSP client for a file
 	 * Prevents duplicate client creation via in-flight promise tracking
 	 */
-	async getClientForFile(filePath: string): Promise<SpawnedServer | undefined> {
+	async getClientForFile(
+		filePath: string,
+		maxWaitMs?: number,
+	): Promise<SpawnedServer | undefined> {
+		const withBudget = async (): Promise<SpawnedServer | undefined> => {
 		const servers = getServersForFileWithConfig(filePath);
 		if (servers.length === 0) return undefined;
 
@@ -105,6 +171,32 @@ export class LSPService {
 		});
 
 		return undefined;
+		};
+
+		if (!maxWaitMs || maxWaitMs <= 0) {
+			return withBudget();
+		}
+
+		const timeoutResult = await Promise.race<SpawnedServer | undefined>([
+			withBudget(),
+			new Promise<undefined>((resolve) =>
+				setTimeout(() => resolve(undefined), maxWaitMs),
+			),
+		]);
+
+		if (!timeoutResult) {
+			logLatency({
+				type: "phase",
+				phase: "lsp_client_wait_timeout",
+				filePath,
+				durationMs: maxWaitMs,
+				metadata: {
+					maxWaitMs,
+				},
+			});
+		}
+
+		return timeoutResult;
 	}
 
 	/**
@@ -131,6 +223,11 @@ export class LSPService {
 
 		const normalizedRoot = normalizeMapKey(root);
 		const key = `${server.id}:${normalizedRoot}`;
+		const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id);
+
+		if (isOptionalServer && this.optionalDisabled.has(key)) {
+			return undefined;
+		}
 
 		const existing = this.state.clients.get(key);
 		if (existing) {
@@ -228,6 +325,7 @@ export class LSPService {
 		filePath: string,
 		allowInstall: boolean,
 	): Promise<SpawnedServer | undefined> {
+		const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id);
 		const startedAt = Date.now();
 		logSessionStart(
 			`lsp spawn ${server.id}: start root=${root} policy=${server.installPolicy ?? "unknown"} install=${allowInstall ? "enabled" : "disabled"} file=${filePath}`,
@@ -258,6 +356,10 @@ export class LSPService {
 					};
 
 			this.state.clients.set(key, client);
+			if (isOptionalServer) {
+				this.optionalDisabled.delete(key);
+				this.optionalFailureLogged.delete(key);
+			}
 			logSessionStart(
 				`lsp spawn ${server.id}: success source=${spawned.source ?? server.installPolicy ?? "unknown"} (${Date.now() - startedAt}ms)`,
 			);
@@ -269,11 +371,16 @@ export class LSPService {
 			}
 			return { client, info: server };
 		} catch (err) {
-			logSessionStart(
-				`lsp spawn ${server.id}: failed (${Date.now() - startedAt}ms) error=${err instanceof Error ? err.message : String(err)}`,
-			);
+			if (!isOptionalServer || !this.optionalFailureLogged.has(key)) {
+				logSessionStart(
+					`lsp spawn ${server.id}: failed (${Date.now() - startedAt}ms) error=${err instanceof Error ? err.message : String(err)}`,
+				);
+				if (isOptionalServer) {
+					this.optionalFailureLogged.add(key);
+				}
+			}
 			const errorMsg = err instanceof Error ? err.message : String(err);
-			if (this.emitConsoleLspErrors) {
+			if (this.emitConsoleLspErrors && !isOptionalServer) {
 				if (errorMsg.includes("Timeout")) {
 					console.error(
 						`[lsp] ${server.id} timed out during initialization (${errorMsg}). The server may be downloading or the project is large. Skipping.`,
@@ -290,7 +397,13 @@ export class LSPService {
 					console.error(`[lsp] Failed to spawn ${server.id}:`, err);
 				}
 			}
-			this.state.broken.set(key, Date.now() + BROKEN_RETRY_COOLDOWN_MS);
+			this.state.broken.set(
+				key,
+				Date.now() + (isOptionalServer ? OPTIONAL_LSP_RETRY_COOLDOWN_MS : BROKEN_RETRY_COOLDOWN_MS),
+			);
+			if (isOptionalServer) {
+				this.optionalDisabled.add(key);
+			}
 			return undefined;
 		}
 	}
@@ -326,12 +439,14 @@ export class LSPService {
 		waitForDiagnostics = false,
 		source = "unknown",
 		useAllClients = false,
+		maxClientWaitMs?: number,
 	): Promise<void> {
 		const startedAt = Date.now();
 		const normalizedPath = normalizeMapKey(filePath);
+		const clientScope = useAllClients ? "all" : "primary";
 		const spawned = useAllClients
 			? await this.getClientsForFile(filePath)
-			: await this.getClientForFile(filePath).then((entry) =>
+			: await this.getClientForFile(filePath, maxClientWaitMs).then((entry) =>
 					entry ? [entry] : [],
 				);
 		if (spawned.length === 0) {
@@ -342,13 +457,32 @@ export class LSPService {
 				durationMs: Date.now() - startedAt,
 			metadata: {
 				serverCountReady: 0,
-				clientScope: useAllClients ? "all" : "primary",
+				clientScope,
 				failureKind: "no_clients",
 			},
 			});
 			return;
 		}
 
+		if (this.shouldSkipTouch(filePath, content, clientScope, waitForDiagnostics)) {
+			logLatency({
+				type: "phase",
+				phase: "lsp_touch_file",
+				filePath: normalizedPath,
+				durationMs: Date.now() - startedAt,
+				metadata: {
+					serverCountReady: spawned.length,
+					clientScope,
+					waitForDiagnostics,
+					source,
+					failureKind: "success",
+					skipped: true,
+					reason: "debounced_unchanged_content",
+				},
+			});
+			return;
+		}
+
 		const languageId = getLanguageId(filePath) ?? "plaintext";
 		await Promise.all(
 			spawned.map((entry) => entry.client.notify.open(filePath, content, languageId)),
@@ -362,6 +496,8 @@ export class LSPService {
 			);
 		}
 
+		this.markTouched(filePath, content, clientScope);
+
 		logLatency({
 			type: "phase",
 			phase: "lsp_touch_file",
@@ -369,7 +505,7 @@ export class LSPService {
 			durationMs: Date.now() - startedAt,
 			metadata: {
 				serverCountReady: spawned.length,
-				clientScope: useAllClients ? "all" : "primary",
+				clientScope,
 				waitForDiagnostics,
 				source,
 				failureKind: "success",
@@ -471,7 +607,10 @@ export class LSPService {
 	 * Navigation: go to definition
 	 */
 	async definition(filePath: string, line: number, character: number) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return [];
 		return spawned.client.definition(filePath, line, character);
 	}
@@ -485,7 +624,10 @@ export class LSPService {
 		character: number,
 		includeDeclaration = true,
 	) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return [];
 		return spawned.client.references(
 			filePath,
@@ -499,7 +641,10 @@ export class LSPService {
 	 * Navigation: hover info
 	 */
 	async hover(filePath: string, line: number, character: number) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return null;
 		return spawned.client.hover(filePath, line, character);
 	}
@@ -508,7 +653,10 @@ export class LSPService {
 	 * Navigation: signature help at cursor position
 	 */
 	async signatureHelp(filePath: string, line: number, character: number) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return null;
 		return spawned.client.signatureHelp(filePath, line, character);
 	}
@@ -517,7 +665,10 @@ export class LSPService {
 	 * Navigation: symbols in document
 	 */
 	async documentSymbol(filePath: string) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return [];
 		return spawned.client.documentSymbol(filePath);
 	}
@@ -527,7 +678,10 @@ export class LSPService {
 	 */
 	async workspaceSymbol(query: string, filePath?: string) {
 		if (filePath) {
-			const spawned = await this.getClientForFile(filePath);
+			const spawned = await this.getClientForFile(
+				filePath,
+				NAV_CLIENT_WAIT_TIMEOUT_MS,
+			);
 			if (!spawned) return [];
 			return spawned.client.workspaceSymbol(query);
 		}
@@ -592,7 +746,10 @@ export class LSPService {
 		endLine: number,
 		endCharacter: number,
 	) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return [];
 		return spawned.client.codeAction(
 			filePath,
@@ -612,7 +769,10 @@ export class LSPService {
 		character: number,
 		newName: string,
 	) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return null;
 		return spawned.client.rename(filePath, line, character, newName);
 	}
@@ -621,7 +781,10 @@ export class LSPService {
 	 * Navigation: go to implementation
 	 */
 	async implementation(filePath: string, line: number, character: number) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return [];
 		return spawned.client.implementation(filePath, line, character);
 	}
@@ -634,7 +797,10 @@ export class LSPService {
 		line: number,
 		character: number,
 	) {
-		const spawned = await this.getClientForFile(filePath);
+		const spawned = await this.getClientForFile(
+			filePath,
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return [];
 		return spawned.client.prepareCallHierarchy(filePath, line, character);
 	}
@@ -643,7 +809,10 @@ export class LSPService {
 	 * Navigation: find incoming calls (callers)
 	 */
 	async incomingCalls(item: import("./client.js").LSPCallHierarchyItem) {
-		const spawned = await this.getClientForFile(uriToPath(item.uri));
+		const spawned = await this.getClientForFile(
+			uriToPath(item.uri),
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return [];
 		return spawned.client.incomingCalls(item);
 	}
@@ -652,7 +821,10 @@ export class LSPService {
 	 * Navigation: find outgoing calls (callees)
 	 */
 	async outgoingCalls(item: import("./client.js").LSPCallHierarchyItem) {
-		const spawned = await this.getClientForFile(uriToPath(item.uri));
+		const spawned = await this.getClientForFile(
+			uriToPath(item.uri),
+			NAV_CLIENT_WAIT_TIMEOUT_MS,
+		);
 		if (!spawned) return [];
 		return spawned.client.outgoingCalls(item);
 	}

package/clients/lsp/launch.ts

@@ -35,6 +35,8 @@ function buildAugmentedPath(basePath?: string): string {
 		candidates.push(path.join(userProfile, ".cargo", "bin"));
 		candidates.push(path.join(userProfile, "go", "bin"));
 	}
+	candidates.push(path.join("C:\\", "Program Files", "Go", "bin"));
+	candidates.push(path.join("C:\\", "Go", "bin"));
 	candidates.push(path.join("C:\\", "Ruby34-x64", "bin"));
 	candidates.push(path.join("C:\\", "Ruby33-x64", "bin"));
 

package/clients/lsp/server.ts

@@ -124,23 +124,35 @@ async function launchWithDirectOrPackageManager(
 	args: string[],
 	options: { cwd: string; env?: NodeJS.ProcessEnv; allowInstall?: boolean },
 ): Promise<{ process: LSPProcess; source: "direct" | "package-manager" } | undefined> {
+	let lastDirectError: unknown;
+
 	for (const command of directCommands) {
 		try {
 			const process = await launchLSP(command, args, options);
 			return { process, source: "direct" };
 		} catch (error) {
-			if (!isCommandNotFoundError(error)) {
-				throw error;
-			}
+			lastDirectError = error;
 		}
 	}
 
-	const process = await launchViaPackageManagerWithPolicy(packageName, args, {
-		cwd: options.cwd,
-		allowInstall: options.allowInstall,
-	});
-	if (!process) return undefined;
-	return { process, source: "package-manager" };
+	try {
+		const process = await launchViaPackageManagerWithPolicy(packageName, args, {
+			cwd: options.cwd,
+			allowInstall: options.allowInstall,
+		});
+		if (!process) {
+			if (lastDirectError && !isCommandNotFoundError(lastDirectError)) {
+				throw lastDirectError;
+			}
+			return undefined;
+		}
+		return { process, source: "package-manager" };
+	} catch (packageManagerError) {
+		if (lastDirectError && !isCommandNotFoundError(lastDirectError)) {
+			throw lastDirectError;
+		}
+		throw packageManagerError;
+	}
 }
 
 type InitializationConfig = Record<string, unknown>;

package/clients/metrics-history.ts

@@ -45,10 +45,30 @@ const MAX_HISTORY_PER_FILE = 20;
 
 // --- Git Helpers ---
 
+/**
+ * Check whether cwd is inside a Git worktree.
+ */
+function isInsideGitRepo(startDir: string): boolean {
+	let dir = path.resolve(startDir);
+	while (true) {
+		if (fs.existsSync(path.join(dir, ".git"))) {
+			return true;
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return false;
+}
+
 /**
  * Get current git commit hash (short)
  */
 function getCurrentCommit(): string {
+	if (!isInsideGitRepo(process.cwd())) {
+		return "unknown";
+	}
+
 	try {
 		return execSync("git rev-parse --short HEAD", {
 			encoding: "utf-8",

package/clients/runtime-session.ts

@@ -10,13 +10,13 @@ import { getKnipIgnorePatterns } from "./file-utils.js";
 import type { GoClient } from "./go-client.js";
 import type { JscpdClient } from "./jscpd-client.js";
 import type { KnipClient } from "./knip-client.js";
+import { canRunStartupHeavyScans } from "./language-policy.js";
 import {
 	detectProjectLanguageProfile,
 	getDefaultStartupTools,
 	hasLanguage,
 	isLanguageConfigured,
 } from "./language-profile.js";
-import { canRunStartupHeavyScans } from "./language-policy.js";
 import type { MetricsClient } from "./metrics-client.js";
 import {
 	buildProjectIndex,
@@ -64,7 +64,10 @@ interface SessionStartDeps {
 
 type StartupMode = "full" | "minimal" | "quick";
 
-function isCommandAvailable(command: string, args: string[] = ["--version"]): boolean {
+function isCommandAvailable(
+	command: string,
+	args: string[] = ["--version"],
+): boolean {
 	const result = safeSpawn(command, args, { timeout: 5000 });
 	return !result.error && result.status === 0;
 }
@@ -97,7 +100,9 @@ function getLanguageInstallHints(
 	};
 
 	if (hasStrongSignal("go") && !isCommandAvailable("gopls")) {
-		hints.push("Go detected: install gopls (`go install golang.org/x/tools/gopls@latest`).");
+		hints.push(
+			"Go detected: install gopls (`go install golang.org/x/tools/gopls@latest`).",
+		);
 	}
 	if (hasStrongSignal("rust") && !isCommandAvailable("rust-analyzer")) {
 		hints.push(
@@ -174,6 +179,25 @@ export async function handleSessionStart(
 		delete process.env.PI_LENS_DISABLE_LSP_INSTALL;
 	}
 
+	const hasWorkspaceCwd = typeof ctxCwd === "string" && ctxCwd.length > 0;
+	const cwd = ctxCwd ?? process.cwd();
+	if (quickMode) {
+		runtime.projectRoot = cwd;
+		const quickTools: string[] = [];
+		if (getFlag("lens-lsp") && !getFlag("no-lsp")) {
+			quickTools.push("LSP Service");
+		}
+		log(`Active tools: ${quickTools.join(", ")}`);
+		dbg(
+			`session_start tools: ${quickTools.join(", ") || "deferred (quick mode)"}`,
+		);
+		dbg(
+			"session_start: quick mode active - skipping slow tool probes, language profiling, preinstall, scans, and error debt baseline",
+		);
+		dbg(`session_start total: ${Date.now() - sessionStartMs}ms`);
+		return;
+	}
+
 	const tools: string[] = [];
 	if (getFlag("lens-lsp") && !getFlag("no-lsp")) {
 		tools.push("LSP Service");
@@ -200,17 +224,6 @@ export async function handleSessionStart(
 		}
 	}
 
-	const hasWorkspaceCwd = typeof ctxCwd === "string" && ctxCwd.length > 0;
-	const cwd = ctxCwd ?? process.cwd();
-	if (quickMode) {
-		runtime.projectRoot = cwd;
-		dbg(
-			"session_start: quick mode active - skipping language profiling, preinstall, scans, and error debt baseline",
-		);
-		dbg(`session_start total: ${Date.now() - sessionStartMs}ms`);
-		return;
-	}
-
 	const startupScan = resolveStartupScanContext(cwd);
 	const scanRoot = startupScan.projectRoot ?? cwd;
 	const useScanRootForSignals =
@@ -236,18 +249,20 @@ export async function handleSessionStart(
 	}
 
 	const lensLspEnabled = !!getFlag("lens-lsp") && !getFlag("no-lsp");
-	const startupDefaults = getDefaultStartupTools(languageProfile).filter((tool) => {
-		if (
-			(tool === "typescript-language-server" || tool === "pyright") &&
-			!lensLspEnabled
-		) {
-			return false;
-		}
-		if (tool === "ruff" && getFlag("no-autofix-ruff")) {
-			return false;
-		}
-		return true;
-	});
+	const startupDefaults = getDefaultStartupTools(languageProfile).filter(
+		(tool) => {
+			if (
+				(tool === "typescript-language-server" || tool === "pyright") &&
+				!lensLspEnabled
+			) {
+				return false;
+			}
+			if (tool === "ruff" && getFlag("no-autofix-ruff")) {
+				return false;
+			}
+			return true;
+		},
+	);
 
 	if (!allowBootstrapTasks) {
 		dbg("session_start: skipping tool preinstall (startup mode)");
@@ -369,7 +384,9 @@ export async function handleSessionStart(
 		runtime.markStartupScanInFlight(name, sessionGeneration);
 		void task()
 			.then(() => {
-				dbg(`session_start task ${name}: success (${Date.now() - startedAt}ms)`);
+				dbg(
+					`session_start task ${name}: success (${Date.now() - startedAt}ms)`,
+				);
 			})
 			.catch((err) => {
 				dbg(`session_start: ${name} background scan failed: ${err}`);
@@ -391,7 +408,9 @@ export async function handleSessionStart(
 		dbg(
 			`session_start: skipping heavy scans (${startupScan.reason ?? "unknown"})`,
 		);
-		dbg(`session_start: skipping TODO scan (${startupScan.reason ?? "unknown"})`);
+		dbg(
+			`session_start: skipping TODO scan (${startupScan.reason ?? "unknown"})`,
+		);
 	} else {
 		const canRunJsTsHeavyScans = canRunStartupHeavyScans(
 			languageProfile,
@@ -401,9 +420,7 @@ export async function handleSessionStart(
 		if (canRunJsTsHeavyScans) {
 			scanNames.push("knip", "jscpd", "ast-grep exports", "project index");
 		}
-		dbg(
-			`session_start: launching background scans (${scanNames.join(", ")})`,
-		);
+		dbg(`session_start: launching background scans (${scanNames.join(", ")})`);
 
 		runStartupTask("todo", async () => {
 			if (!runtime.isCurrentSession(sessionGeneration)) return;
@@ -458,10 +475,9 @@ export async function handleSessionStart(
 			runStartupTask("jscpd", async () => {
 				if (await jscpdClient.ensureAvailable()) {
 					if (!runtime.isCurrentSession(sessionGeneration)) return;
-					const cached = cacheManager.readCache<ReturnType<JscpdClient["scan"]>>(
-						"jscpd",
-						analysisRoot,
-					);
+					const cached = cacheManager.readCache<
+						ReturnType<JscpdClient["scan"]>
+					>("jscpd", analysisRoot);
 					if (cached) {
 						if (!runtime.isCurrentSession(sessionGeneration)) return;
 						dbg("session_start jscpd: cache hit");
@@ -527,7 +543,9 @@ export async function handleSessionStart(
 						);
 					} else {
 						if (!runtime.isCurrentSession(sessionGeneration)) return;
-						dbg(`session_start: skipped project index (${tsFiles.length} files)`);
+						dbg(
+							`session_start: skipped project index (${tsFiles.length} files)`,
+						);
 					}
 				}
 			});

package/clients/tree-sitter-client.ts

@@ -283,6 +283,7 @@ export class TreeSitterClient {
 	async parseFile(
 		filePath: string,
 		languageId: string,
+		contentOverride?: string,
 	): Promise<TreeSitterTree | null> {
 		this.dbg(`Parsing ${filePath} with language ${languageId}`);
 		const parser = await this.getParser(languageId);
@@ -292,7 +293,7 @@ export class TreeSitterClient {
 		}
 
 		try {
-			const content = fs.readFileSync(filePath, "utf-8");
+			const content = contentOverride ?? fs.readFileSync(filePath, "utf-8");
 			this.dbg(`File content length: ${content.length}`);
 
 			// Check cache first
@@ -469,6 +470,7 @@ export class TreeSitterClient {
 		filePath: string,
 		languageId: string,
 		options: { maxResults?: number } = {},
+		contentOverride?: string,
 	): Promise<StructuralMatch[]> {
 		if (!this.initialized) {
 			const ok = await this.init();
@@ -493,6 +495,7 @@ export class TreeSitterClient {
 			queryDef.id,
 			compiled.postFilter,
 			compiled.postFilterParams,
+			contentOverride,
 		);
 
 		const maxResults = options.maxResults ?? 50;
@@ -727,8 +730,9 @@ export class TreeSitterClient {
 		postFilter?: string,
 		// biome-ignore lint/suspicious/noExplicitAny: Post filter params
 		postFilterParams?: any,
+		contentOverride?: string,
 	): Promise<StructuralMatch[]> {
-		const tree = await this.parseFile(filePath, languageId);
+		const tree = await this.parseFile(filePath, languageId, contentOverride);
 		if (!tree) return [];
 
 		const matches: StructuralMatch[] = [];

package/commands/booboo.ts

@@ -369,33 +369,13 @@ export async function handleBooboo(
 	// Runner 3: Semantic similarity
 	await tracker.run("semantic similarity (Amain)", async () => {
 		try {
-			const { glob } = await import("glob");
-			const sourceFiles = await glob("**/*.ts", {
-				cwd: targetPath,
-				ignore: [
-					"**/node_modules/**",
-					"**/*.test.ts",
-					"**/*.test.tsx",
-					"**/*.spec.ts",
-					"**/*.spec.tsx",
-					"**/*.poc.test.ts",
-					"**/*.poc.test.tsx",
-					"**/test-utils.ts",
-					"**/test-*.ts",
-					"**/__tests__/**",
-					"**/tests/**",
-					"**/dist/**",
-				],
-			});
+			const absoluteFiles = collectSourceFiles(targetPath, {
+				extensions: [".ts"],
+			}).filter(shouldIncludeFile);
 
-			if (sourceFiles.length === 0) {
+			if (absoluteFiles.length === 0) {
 				return { findings: 0, status: "done" };
 			}
-
-			// Filter out test files using centralized exclusion
-			const absoluteFiles = sourceFiles
-				.map((f) => path.join(targetPath, f))
-				.filter(shouldIncludeFile);
 			const index = await buildProjectIndex(targetPath, absoluteFiles);
 			const topPairs = findTopSimilarPairs(index, 10);
 

package/index.ts

@@ -13,7 +13,6 @@ import {
 	getLatencyReports,
 	resetDispatchBaselines,
 } from "./clients/dispatch/integration.js";
-import { extractFunctions } from "./clients/dispatch/runners/similarity.js";
 import { resetFormatService } from "./clients/format-service.js";
 import { evaluateGitGuard, isGitCommitOrPushAttempt } from "./clients/git-guard.js";
 import { ensureTool } from "./clients/installer/index.js";
@@ -60,6 +59,11 @@ function dbg(msg: string) {
 let _verbose = false;
 const runtime = new RuntimeCoordinator();
 const _lspConfigInitializedCwds = new Set<string>();
+const LSP_TOOLCALL_NAV_TOUCH_BUDGET_MS = Math.max(
+	0,
+	Number.parseInt(process.env.PI_LENS_TOOLCALL_NAV_TOUCH_MS ?? "700", 10) ||
+		700,
+);
 
 function log(msg: string) {
 	if (_verbose) console.error(`[pi-lens] ${msg}`);
@@ -506,7 +510,8 @@ pi.on("session_start", async (event, ctx) => {
 			testRunnerClient,
 			goClient,
 			rustClient,
-			ensureTool,
+			ensureTool: async (name: string) =>
+				(await import("./clients/installer/index.js")).ensureTool(name),
 			cleanStaleTsBuildInfo,
 			resetDispatchBaselines,
 			resetLSPService,
@@ -576,8 +581,17 @@ pi.on("tool_call", async (event, ctx) => {
 	if (shouldAutoTouch) {
 		try {
 			const fileContent = nodeFs.readFileSync(filePath, "utf-8");
+			const maxClientWaitMs =
+				toolName === "lsp_navigation" ? LSP_TOOLCALL_NAV_TOUCH_BUDGET_MS : undefined;
 			void getLSPService()
-				.touchFile(filePath, fileContent, false, `tool_call:${toolName}`)
+				.touchFile(
+					filePath,
+					fileContent,
+					false,
+					`tool_call:${toolName}`,
+					false,
+					maxClientWaitMs,
+				)
 				.catch((err) => dbg(`lsp auto-touch failed for ${filePath}: ${err}`));
 		} catch {
 			// Best effort only; never block tool calls.
@@ -594,6 +608,9 @@ pi.on("tool_call", async (event, ctx) => {
 		const baseline = complexityClient.analyzeFile(filePath);
 		if (baseline) {
 			runtime.complexityBaselines.set(filePath, baseline);
+			const { captureSnapshot } = await import(
+				"./clients/metrics-history.js"
+			);
 			captureSnapshot(filePath, {
 				maintainabilityIndex: baseline.maintainabilityIndex,
 				cognitiveComplexity: baseline.cognitiveComplexity,
@@ -659,6 +676,8 @@ pi.on("tool_call", async (event, ctx) => {
 						ts.ScriptTarget.Latest,
 						true,
 					);
+					const { extractFunctions } = await import("./clients/dispatch/runners/similarity.js");
+					const { findSimilarFunctions } = await import("./clients/project-index.js");
 					const newFunctions = extractFunctions(sourceFile, newContent);
 					const simWarnings: string[] = [];
 					let simHintsTruncated = false;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "3.8.24",
+	"version": "3.8.26",
 	"type": "module",
 	"description": "Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo",
 	"repository": {