pi-lens 3.8.19 → 3.8.21

package/clients/runtime-context.ts

@@ -25,3 +25,29 @@ export function consumeTurnEndFindings(
 		],
 	};
 }
+
+export function consumeSessionStartGuidance(
+	cacheManager: CacheManager,
+	cwd: string,
+): { messages: Array<{ role: "system"; content: string }> } | undefined {
+	const guidance = cacheManager.readCache<{ content: string }>(
+		"session-start-guidance",
+		cwd,
+	);
+	if (!guidance?.data?.content) return;
+
+	cacheManager.writeCache(
+		"session-start-guidance",
+		null as unknown as { content: string },
+		cwd,
+	);
+
+	return {
+		messages: [
+			{
+				role: "system",
+				content: `[pi-lens] Session guidance:\n\n${guidance.data.content}`,
+			},
+		],
+	};
+}

package/clients/runtime-coordinator.ts

@@ -3,6 +3,7 @@ import type { FileComplexity } from "./complexity-client.js";
 import type { RuleScanResult } from "./rules-scanner.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import type { ProjectIndex } from "./project-index.js";
+import { normalizeMapKey } from "./path-utils.js";
 
 export interface ErrorDebtBaseline {
 	testsPassed: boolean;
@@ -10,11 +11,13 @@ export interface ErrorDebtBaseline {
 }
 
 export class RuntimeCoordinator {
-	private _projectRoot = process.cwd();
+	private _projectRoot = normalizeMapKey(process.cwd());
+	private _sessionGeneration = 0;
 	private _errorDebtBaseline: ErrorDebtBaseline | null = null;
 	private _pipelineCrashCounts = new Map<string, number>();
 	private _cachedExports = new Map<string, string>();
 	private _cachedProjectIndex: ProjectIndex | null = null;
+	private _startupScansInFlight = new Map<string, number>();
 	private _lastCascadeOutput = "";
 	private _complexityBaselines = new Map<string, FileComplexity>();
 	private _fixedThisTurn = new Set<string>();
@@ -30,10 +33,12 @@ export class RuntimeCoordinator {
 	private _gitGuardSummary = "";
 
 	resetForSession(): void {
+		this._sessionGeneration += 1;
 		this._complexityBaselines.clear();
 		this._pipelineCrashCounts.clear();
 		this._cachedExports.clear();
 		this._cachedProjectIndex = null;
+		this._startupScansInFlight.clear();
 		this._lastCascadeOutput = "";
 		this._fixedThisTurn.clear();
 		this._telemetrySessionId =
@@ -111,6 +116,29 @@ export class RuntimeCoordinator {
 		return this._turnIndex;
 	}
 
+	get sessionGeneration(): number {
+		return this._sessionGeneration;
+	}
+
+	isCurrentSession(generation: number): boolean {
+		return this._sessionGeneration === generation;
+	}
+
+	markStartupScanInFlight(name: string, generation: number): void {
+		this._startupScansInFlight.set(name, generation);
+	}
+
+	clearStartupScanInFlight(name: string, generation: number): void {
+		const owner = this._startupScansInFlight.get(name);
+		if (owner === generation) {
+			this._startupScansInFlight.delete(name);
+		}
+	}
+
+	isStartupScanInFlight(name: string): boolean {
+		return this._startupScansInFlight.has(name);
+	}
+
 	formatPipelineCrashNotice(filePath: string, err: unknown): string {
 		const key = path.resolve(filePath);
 		const count = (this._pipelineCrashCounts.get(key) ?? 0) + 1;
@@ -140,7 +168,7 @@ export class RuntimeCoordinator {
 	}
 
 	set projectRoot(value: string) {
-		this._projectRoot = value;
+		this._projectRoot = normalizeMapKey(value);
 	}
 
 	get errorDebtBaseline(): ErrorDebtBaseline | null {

package/clients/runtime-session.ts

@@ -6,9 +6,17 @@ import type { BiomeClient } from "./biome-client.js";
 import type { CacheManager } from "./cache-manager.js";
 import type { DependencyChecker } from "./dependency-checker.js";
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
+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 {
+	detectProjectLanguageProfile,
+	getDefaultStartupTools,
+	hasLanguage,
+	isLanguageConfigured,
+} from "./language-profile.js";
+import { canRunStartupHeavyScans } from "./language-policy.js";
 import type { MetricsClient } from "./metrics-client.js";
 import {
 	buildProjectIndex,
@@ -16,11 +24,11 @@ import {
 	loadIndex,
 	saveIndex,
 } from "./project-index.js";
-import { scanProjectRules } from "./rules-scanner.js";
 import type { RuffClient } from "./ruff-client.js";
+import { scanProjectRules } from "./rules-scanner.js";
 import type { RuntimeCoordinator } from "./runtime-coordinator.js";
 import type { RustClient } from "./rust-client.js";
-import { getKnipIgnorePatterns } from "./file-utils.js";
+import { safeSpawn } from "./safe-spawn.js";
 import { getSourceFiles } from "./scan-utils.js";
 import { resolveStartupScanContext } from "./startup-scan.js";
 import type { TestRunnerClient } from "./test-runner-client.js";
@@ -54,7 +62,43 @@ interface SessionStartDeps {
 	resetLSPService: () => void;
 }
 
-export async function handleSessionStart(deps: SessionStartDeps): Promise<void> {
+function isCommandAvailable(command: string, args: string[] = ["--version"]): boolean {
+	const result = safeSpawn(command, args, { timeout: 5000 });
+	return !result.error && result.status === 0;
+}
+
+function getLanguageInstallHints(
+	languageProfile: ReturnType<typeof detectProjectLanguageProfile>,
+): string[] {
+	const hints: string[] = [];
+	const hasStrongSignal = (
+		kind: "go" | "rust" | "ruby",
+		minCount = 3,
+	): boolean => {
+		if (!hasLanguage(languageProfile, kind)) return false;
+		if (isLanguageConfigured(languageProfile, kind)) return true;
+		return (languageProfile.counts[kind] ?? 0) >= minCount;
+	};
+
+	if (hasStrongSignal("go") && !isCommandAvailable("gopls")) {
+		hints.push("Go detected: install gopls (`go install golang.org/x/tools/gopls@latest`).");
+	}
+	if (hasStrongSignal("rust") && !isCommandAvailable("rust-analyzer")) {
+		hints.push(
+			"Rust detected: install rust-analyzer (`rustup component add rust-analyzer`).",
+		);
+	}
+	if (hasStrongSignal("ruby") && !isCommandAvailable("ruby-lsp")) {
+		hints.push("Ruby detected: install ruby-lsp (`gem install ruby-lsp`).");
+	}
+
+	return hints;
+}
+
+export async function handleSessionStart(
+	deps: SessionStartDeps,
+): Promise<void> {
+	const sessionStartMs = Date.now();
 	const {
 		ctxCwd,
 		getFlag,
@@ -100,6 +144,13 @@ export async function handleSessionStart(deps: SessionStartDeps): Promise<void>
 		delete process.env.PI_LENS_AUTO_INSTALL;
 	}
 
+	if (getFlag("no-lsp-install")) {
+		process.env.PI_LENS_DISABLE_LSP_INSTALL = "1";
+		dbg("session_start: LSP install disabled (PI_LENS_DISABLE_LSP_INSTALL=1)");
+	} else {
+		delete process.env.PI_LENS_DISABLE_LSP_INSTALL;
+	}
+
 	const tools: string[] = [];
 	if (getFlag("lens-lsp") && !getFlag("no-lsp")) {
 		tools.push("LSP Service");
@@ -126,34 +177,76 @@ export async function handleSessionStart(deps: SessionStartDeps): Promise<void>
 		}
 	}
 
-	if (getFlag("lens-lsp") && !getFlag("no-lsp")) {
-		dbg("session_start: pre-installing TypeScript LSP...");
-		ensureTool("typescript-language-server")
-			.then((toolPath) => {
-				if (toolPath) {
-					dbg(`session_start: TypeScript LSP ready at ${toolPath}`);
-				} else {
-					console.error("[lens] TypeScript LSP installation failed");
-				}
-			})
-			.catch((err) => {
-				console.error("[lens] TypeScript LSP pre-install error:", err);
-			});
-	}
-
+	const hasWorkspaceCwd = typeof ctxCwd === "string" && ctxCwd.length > 0;
 	const cwd = ctxCwd ?? process.cwd();
 	const startupScan = resolveStartupScanContext(cwd);
 	const scanRoot = startupScan.projectRoot ?? cwd;
-	const analysisRoot = scanRoot;
-	runtime.projectRoot = scanRoot;
+	const useScanRootForSignals =
+		startupScan.canWarmCaches || startupScan.reason === "too-many-source-files";
+	const analysisRoot = useScanRootForSignals ? scanRoot : cwd;
+	runtime.projectRoot = cwd;
+	const languageProfile = detectProjectLanguageProfile(analysisRoot);
 	dbg(`session_start cwd: ${cwd}`);
 	dbg(
 		`session_start scan root: ${scanRoot} (warmCaches=${startupScan.canWarmCaches}${startupScan.reason ? `, reason=${startupScan.reason}` : ""})`,
 	);
-	if (analysisRoot !== cwd) {
+	dbg(`session_start analysis root: ${analysisRoot}`);
+	dbg(`session_start workspace root: ${runtime.projectRoot}`);
+	dbg(
+		`session_start language profile: ${languageProfile.detectedKinds.join(", ") || "none"}`,
+	);
+	dbg(
+		`session_start language counts: ${JSON.stringify(languageProfile.counts)} configured=${JSON.stringify(languageProfile.configured)}`,
+	);
+	dbg(`session_start workspace cwd available: ${hasWorkspaceCwd}`);
+	if (useScanRootForSignals && analysisRoot !== cwd) {
 		dbg(`session_start: monorepo analysis root override -> ${analysisRoot}`);
 	}
 
+	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;
+	});
+
+	if (startupDefaults.length > 0) {
+		dbg(`session_start: pre-install defaults -> ${startupDefaults.join(", ")}`);
+		for (const tool of startupDefaults) {
+			const startedAt = Date.now();
+			dbg(`session_start preinstall ${tool}: start`);
+			ensureTool(tool)
+				.then((toolPath) => {
+					if (toolPath) {
+						dbg(`session_start: ${tool} ready at ${toolPath}`);
+						dbg(
+							`session_start preinstall ${tool}: success (${Date.now() - startedAt}ms)`,
+						);
+					} else {
+						dbg(`session_start: ${tool} installation unavailable`);
+						dbg(
+							`session_start preinstall ${tool}: unavailable (${Date.now() - startedAt}ms)`,
+						);
+					}
+				})
+				.catch((err) => {
+					dbg(`session_start: ${tool} pre-install error: ${err}`);
+					dbg(
+						`session_start preinstall ${tool}: error (${Date.now() - startedAt}ms)`,
+					);
+				});
+		}
+	} else {
+		dbg("session_start: no language defaults selected for pre-install");
+	}
+
 	{
 		const pkgPath = path.join(analysisRoot, "package.json");
 		try {
@@ -174,9 +267,7 @@ export async function handleSessionStart(deps: SessionStartDeps): Promise<void>
 						if (p) dbg(`session_start: prettier ready at ${p}`);
 						else dbg("session_start: prettier install failed silently");
 					})
-					.catch((err) =>
-						dbg(`session_start: prettier install error: ${err}`),
-					);
+					.catch((err) => dbg(`session_start: prettier install error: ${err}`));
 			}
 		} catch {
 			// no package.json at cwd root
@@ -196,14 +287,17 @@ export async function handleSessionStart(deps: SessionStartDeps): Promise<void>
 	dbg(`session_start tools: ${tools.join(", ")}`);
 
 	const startupNotes: string[] = [];
-	startupNotes.push(
-		"📌 pi-lens active — fix any errors you find (including pre-existing). Prefer: lsp_navigation for definitions/references, ast_grep_search for code patterns, grep for text/TODO search.",
+	const agentStartupGuidance: string[] = [];
+	agentStartupGuidance.push(
+		"📌 pi-lens active — as you work on this project, fix any errors you encounter (including pre-existing). Prefer: lsp_navigation for definitions/references, ast_grep_search for code patterns, grep for text/TODO search.",
 	);
 
 	runtime.projectRulesScan = scanProjectRules(analysisRoot);
 	if (runtime.projectRulesScan.hasCustomRules) {
 		const ruleCount = runtime.projectRulesScan.rules.length;
-		const sources = [...new Set(runtime.projectRulesScan.rules.map((r) => r.source))];
+		const sources = [
+			...new Set(runtime.projectRulesScan.rules.map((r) => r.source)),
+		];
 		dbg(
 			`session_start: found ${ruleCount} project rule(s) from ${sources.join(", ")}`,
 		);
@@ -214,102 +308,196 @@ export async function handleSessionStart(deps: SessionStartDeps): Promise<void>
 		dbg("session_start: no project rules found");
 	}
 
-	const todoResult = todoScanner.scanDirectory(analysisRoot);
-	dbg(
-		`session_start TODO scan: ${todoResult.items.length} items (baseline stored)`,
-	);
-	cacheManager.writeCache("todo-baseline", { items: todoResult.items }, analysisRoot);
+	if (hasWorkspaceCwd) {
+		const installHints = getLanguageInstallHints(languageProfile);
+		dbg(`session_start tooling hints count: ${installHints.length}`);
+		if (installHints.length > 0) {
+			startupNotes.push(`🧰 Tooling hints: ${installHints.join(" ")}`);
+		}
+	} else {
+		dbg("session_start: skipping tooling hints (workspace cwd unavailable)");
+	}
+
+	if (agentStartupGuidance.length > 0) {
+		cacheManager.writeCache(
+			"session-start-guidance",
+			{ content: agentStartupGuidance.join("\n") },
+			analysisRoot,
+		);
+	}
+
+	const sessionGeneration = runtime.sessionGeneration;
+	const runStartupTask = (name: string, task: () => Promise<void>): void => {
+		const startedAt = Date.now();
+		dbg(`session_start task ${name}: start`);
+		runtime.markStartupScanInFlight(name, sessionGeneration);
+		void task()
+			.then(() => {
+				dbg(`session_start task ${name}: success (${Date.now() - startedAt}ms)`);
+			})
+			.catch((err) => {
+				dbg(`session_start: ${name} background scan failed: ${err}`);
+				dbg(`session_start task ${name}: failed (${Date.now() - startedAt}ms)`);
+			})
+			.finally(() => {
+				runtime.clearStartupScanInFlight(name, sessionGeneration);
+				dbg(`session_start task ${name}: end`);
+			});
+	};
+
+	// Fire off heavy scans as background tasks — don't block session start.
+	// Each consumer already handles the "not ready yet" case gracefully
+	// (cachedExports.size > 0, cachedProjectIndex != null, cache miss paths).
 
 	if (!startupScan.canWarmCaches) {
-		dbg(`session_start: skipping heavy scans (${startupScan.reason ?? "unknown"})`);
+		dbg(
+			`session_start: skipping heavy scans (${startupScan.reason ?? "unknown"})`,
+		);
+		dbg(`session_start: skipping TODO scan (${startupScan.reason ?? "unknown"})`);
 	} else {
-		if (await knipClient.ensureAvailable()) {
-			const cached = cacheManager.readCache<ReturnType<KnipClient["analyze"]>>(
-				"knip",
-				analysisRoot,
-			);
-			if (cached) {
-				dbg(
-					`session_start Knip: cache hit (${Math.round((Date.now() - new Date(cached.meta.timestamp).getTime()) / 1000)}s ago)`,
-				);
-			} else {
-				const startMs = Date.now();
-				const knipResult = knipClient.analyze(
-					analysisRoot,
-					getKnipIgnorePatterns(),
-				);
-				cacheManager.writeCache("knip", knipResult, analysisRoot, {
-					scanDurationMs: Date.now() - startMs,
-				});
-				dbg("session_start Knip scan done");
-			}
-		} else {
-			dbg("session_start Knip: not available");
+		const canRunJsTsHeavyScans = canRunStartupHeavyScans(
+			languageProfile,
+			"jsts",
+		);
+		const scanNames = ["todo"];
+		if (canRunJsTsHeavyScans) {
+			scanNames.push("knip", "jscpd", "ast-grep exports", "project index");
 		}
+		dbg(
+			`session_start: launching background scans (${scanNames.join(", ")})`,
+		);
 
-		if (await jscpdClient.ensureAvailable()) {
-			const cached = cacheManager.readCache<ReturnType<JscpdClient["scan"]>>(
-				"jscpd",
+		runStartupTask("todo", async () => {
+			if (!runtime.isCurrentSession(sessionGeneration)) return;
+			const todoResult = todoScanner.scanDirectory(analysisRoot);
+			if (!runtime.isCurrentSession(sessionGeneration)) return;
+			dbg(
+				`session_start TODO scan: ${todoResult.items.length} items (baseline stored)`,
+			);
+			cacheManager.writeCache(
+				"todo-baseline",
+				{ items: todoResult.items },
 				analysisRoot,
 			);
-			if (cached) {
-				dbg("session_start jscpd: cache hit");
-			} else {
-				const startMs = Date.now();
-				const jscpdResult = jscpdClient.scan(analysisRoot);
-				cacheManager.writeCache("jscpd", jscpdResult, analysisRoot, {
-					scanDurationMs: Date.now() - startMs,
-				});
-				dbg("session_start jscpd scan done");
-			}
+		});
+
+		if (!canRunJsTsHeavyScans) {
+			dbg(
+				"session_start: skipping JS/TS startup scans (requires JS/TS language + project config)",
+			);
 		} else {
-			dbg("session_start jscpd: not available");
-		}
+			// Knip — dead code / unused exports
+			runStartupTask("knip", async () => {
+				if (await knipClient.ensureAvailable()) {
+					if (!runtime.isCurrentSession(sessionGeneration)) return;
+					const cached = cacheManager.readCache<
+						ReturnType<KnipClient["analyze"]>
+					>("knip", analysisRoot);
+					if (cached) {
+						if (!runtime.isCurrentSession(sessionGeneration)) return;
+						dbg(
+							`session_start Knip: cache hit (${Math.round((Date.now() - new Date(cached.meta.timestamp).getTime()) / 1000)}s ago)`,
+						);
+					} else {
+						const startMs = Date.now();
+						const knipResult = knipClient.analyze(
+							analysisRoot,
+							getKnipIgnorePatterns(),
+						);
+						if (!runtime.isCurrentSession(sessionGeneration)) return;
+						cacheManager.writeCache("knip", knipResult, analysisRoot, {
+							scanDurationMs: Date.now() - startMs,
+						});
+						dbg(`session_start Knip scan done (${Date.now() - startMs}ms)`);
+					}
+				} else {
+					if (!runtime.isCurrentSession(sessionGeneration)) return;
+					dbg("session_start Knip: not available");
+				}
+			});
 
-		if (await astGrepClient.ensureAvailable()) {
-			const exports = await astGrepClient.scanExports(analysisRoot, "typescript");
-			dbg(`session_start exports scan: ${exports.size} functions found`);
-			for (const [name, file] of exports) {
-				runtime.cachedExports.set(name, file);
-			}
-		}
+			// jscpd — duplicate code detection
+			runStartupTask("jscpd", async () => {
+				if (await jscpdClient.ensureAvailable()) {
+					if (!runtime.isCurrentSession(sessionGeneration)) return;
+					const cached = cacheManager.readCache<ReturnType<JscpdClient["scan"]>>(
+						"jscpd",
+						analysisRoot,
+					);
+					if (cached) {
+						if (!runtime.isCurrentSession(sessionGeneration)) return;
+						dbg("session_start jscpd: cache hit");
+					} else {
+						const startMs = Date.now();
+						const jscpdResult = jscpdClient.scan(analysisRoot);
+						if (!runtime.isCurrentSession(sessionGeneration)) return;
+						cacheManager.writeCache("jscpd", jscpdResult, analysisRoot, {
+							scanDurationMs: Date.now() - startMs,
+						});
+						dbg(`session_start jscpd scan done (${Date.now() - startMs}ms)`);
+					}
+				} else {
+					if (!runtime.isCurrentSession(sessionGeneration)) return;
+					dbg("session_start jscpd: not available");
+				}
+			});
 
-		try {
-			const existing = await loadIndex(analysisRoot);
-			if (
-				existing &&
-				existing.entries.size > 0 &&
-				(await isIndexFresh(analysisRoot))
-			) {
-				runtime.cachedProjectIndex = existing;
-				dbg(
-					`session_start: loaded fresh project index (${existing.entries.size} entries)`,
-				);
-			} else {
-				const sourceFiles = getSourceFiles(analysisRoot, true);
-				const tsFiles = sourceFiles.filter(
-					(f) => f.endsWith(".ts") || f.endsWith(".tsx"),
-				);
-				if (tsFiles.length > 0 && tsFiles.length <= 500) {
-					runtime.cachedProjectIndex = await buildProjectIndex(
+			// ast-grep — export scan for duplicate detection
+			runStartupTask("ast-grep-exports", async () => {
+				if (await astGrepClient.ensureAvailable()) {
+					if (!runtime.isCurrentSession(sessionGeneration)) return;
+					const exports = await astGrepClient.scanExports(
 						analysisRoot,
-						tsFiles,
+						"typescript",
 					);
-					await saveIndex(runtime.cachedProjectIndex, analysisRoot);
+					if (!runtime.isCurrentSession(sessionGeneration)) return;
+					dbg(`session_start exports scan: ${exports.size} functions found`);
+					for (const [name, file] of exports) {
+						runtime.cachedExports.set(name, file);
+					}
+				}
+			});
+
+			// Project index — structural similarity detection
+			runStartupTask("project-index", async () => {
+				const existing = await loadIndex(analysisRoot);
+				if (!runtime.isCurrentSession(sessionGeneration)) return;
+				if (
+					existing &&
+					existing.entries.size > 0 &&
+					(await isIndexFresh(analysisRoot))
+				) {
+					if (!runtime.isCurrentSession(sessionGeneration)) return;
+					runtime.cachedProjectIndex = existing;
 					dbg(
-						`session_start: built project index (${runtime.cachedProjectIndex.entries.size} entries from ${tsFiles.length} files)`,
+						`session_start: loaded fresh project index (${existing.entries.size} entries)`,
 					);
 				} else {
-					dbg(`session_start: skipped project index (${tsFiles.length} files)`);
+					const sourceFiles = getSourceFiles(analysisRoot, true);
+					const tsFiles = sourceFiles.filter(
+						(f) => f.endsWith(".ts") || f.endsWith(".tsx"),
+					);
+					if (tsFiles.length > 0 && tsFiles.length <= 500) {
+						runtime.cachedProjectIndex = await buildProjectIndex(
+							analysisRoot,
+							tsFiles,
+						);
+						if (!runtime.isCurrentSession(sessionGeneration)) return;
+						await saveIndex(runtime.cachedProjectIndex, analysisRoot);
+						dbg(
+							`session_start: built project index (${runtime.cachedProjectIndex.entries.size} entries from ${tsFiles.length} files)`,
+						);
+					} else {
+						if (!runtime.isCurrentSession(sessionGeneration)) return;
+						dbg(`session_start: skipped project index (${tsFiles.length} files)`);
+					}
 				}
-			}
-		} catch (err) {
-			dbg(`session_start: project index build failed: ${err}`);
+			});
 		}
 	}
 
 	dbg(
-		`session_start: scans complete (${startupNotes.length} startup note(s)), cached for commands`,
+		`session_start: background scans launched (${startupNotes.length} startup note(s))`,
 	);
 
 	const errorDebtEnabled = getFlag("error-debt");
@@ -368,4 +556,6 @@ export async function handleSessionStart(deps: SessionStartDeps): Promise<void>
 	if (startupNotes.length > 0) {
 		notify(startupNotes.join("\n"), "info");
 	}
+
+	dbg(`session_start total: ${Date.now() - sessionStartMs}ms`);
 }

package/clients/runtime-tool-result.ts

@@ -1,6 +1,7 @@
 import * as nodeFs from "node:fs";
-import { FileTimeError, createFileTime } from "./file-time.js";
+import { createFileTime } from "./file-time.js";
 import { getFormatService } from "./format-service.js";
+import { resolveLanguageRootForFile } from "./language-profile.js";
 import { logLatency } from "./latency-logger.js";
 import { runPipeline } from "./pipeline.js";
 import type { BiomeClient } from "./biome-client.js";
@@ -101,19 +102,16 @@ export async function handleToolResult(
 	}
 
 	const sessionFileTime = createFileTime("default");
-	try {
-		sessionFileTime.assert(filePath);
-	} catch (err: unknown) {
-		if (err instanceof FileTimeError) {
-			dbg(`⚠️ FileTime warning: ${err.message}`);
-		}
-	}
+	// tool_result is emitted after write/edit has already been applied.
+	// Asserting pre-write stamps here produces false positives on rapid edits.
 	sessionFileTime.read(filePath);
 
 	const toolResultStart = Date.now();
 	dbg(`tool_result: tracking turn state for ${event.toolName} on ${filePath}`);
 
-	const cwd = runtime.projectRoot;
+	const workspaceRoot = runtime.projectRoot;
+	const cwd = resolveLanguageRootForFile(filePath, workspaceRoot);
+	dbg(`tool_result: resolved dispatch cwd ${cwd} for ${filePath}`);
 	if (event.model || event.provider || event.sessionId || event.session?.id) {
 		runtime.setTelemetryIdentity({
 			model: event.model,
@@ -183,7 +181,7 @@ export async function handleToolResult(
 		result = await runPipeline(
 			{
 				filePath,
-				cwd: runtime.projectRoot,
+				cwd,
 				toolName: event.toolName,
 				modifiedRanges,
 				telemetry: {