pi-lens 3.8.38 → 3.8.40

package/CHANGELOG.md

@@ -4,6 +4,57 @@ All notable changes to pi-lens will be documented in this file.
 
 ## [Unreleased]
 
+## [3.8.40] - 2026-05-04
+
+### Added
+
+- **60+ SonarCloud BLOCKER tree-sitter rules** — comprehensive BLOCKER severity rules across 13 languages:
+  - **Java (11 rules)**: no-exit-methods, no-threads-in-constructors, switch-fall-through, no-wait-notify-on-thread, no-double-checked-locking, no-future-keywords, no-field-shadowing, junit-call-super, no-octal-values, short-circuit-logic, infinite-loop, infinite-recursion, name-capitalization-conflict, mockito-initialized, resources-closed, unnecessary-bit-ops-java
+  - **TypeScript (5 rules)**: infinite-loop, self-assignment, duplicate-function-arg, empty-switch-case, default-not-last, switch-case-termination
+  - **JavaScript (1 rule)**: switch-case-termination-js (replaces switch-fall-through-js)
+  - **PL/SQL (7 rules)**: forallsave-exceptions, not-null-initialization, end-loop-semicolon, raise-application-error-codes, no-synchronize, lock-table, nchar-nvarchar2-bytes, delete-update-where, fetch-bulk-collect-limit
+  - **Python (8 rules)**: send-file-mimetype, no-super-torchscript, return-in-init, yield-return-outside-function, notimplemented-boolean-context, exit-signature-check, return-in-generator, iter-return-iterator, in-operator-unsupported
+  - **C++ (5 rules)**: unnecessary-bit-ops, noexcept-functions, no-auto-ptr, no-memset-sensitive-data, no-scoped-lock-without-args, no-confused-move-forward
+  - **PHP (2 rules)**: this-in-static-context, no-exit-die
+  - **C (3 rules)**: case-range-multiple-values, goto-label-order, goto-into-block
+  - **C# (5 rules)**: is-with-this, no-operator-eq-reference, no-dangerous-get-handle, no-thread-resume-suspend, async-await-identifiers
+  - **Kotlin (1 rule)**: prepared-statement-indices
+  - **ABAP (1 rule)**: delete-where
+  - **COBOL (2 rules)**: alter-statement, lock-table-cobol
+  - **CSS (1 rule)**: calc-spacing
+- **rule-catalog.json** updated with all 60+ new rule registrations
+
+### Fixed
+
+- **Read-guard: false `file_modified` blocks after own edits** — `ReadGuard` was blocking the second edit to a file because the model's first write changed the file's mtime, making `FileTime.hasChanged()` return `true` on the next `checkEdit`. Added `recordWritten(filePath)` to `ReadGuard` and wired it into the `tool_result` handler (post-write, file already on disk), so the FileTime stamp stays in sync with the model's own writes. Eliminates the spurious `file_modified` blocks that appeared on every multi-edit file in a session.
+
+- **LSP: parallel-turn root-resolution timeouts** — `NearestRoot` performed a fresh `fs.stat` directory walk on every call with no caching. When Claude Code edited multiple files simultaneously (e.g. a 4-file turn), all pipelines raced `NearestRoot` concurrently, saturating Windows filesystem I/O and triggering the 750ms `lsp_client_wait_timeout` on all but the first. `NearestRoot` now maintains per-instance result and in-flight caches keyed by resolved directory: successful roots are cached for the session lifetime; concurrent calls for the same directory share one walk promise. Only successful roots are cached so a `package.json` created mid-session is still detected on the next call.
+
+- **Memory: `lastAnalyzedStateByFile` cleared each turn** — module-level Map in `runtime-tool-result.ts` accumulated dead entries across turns (entries from previous turns can never match the new `turnIndex`). Now cleared at `turn_start` alongside `runtime.beginTurn()`, keeping the map bounded to files touched in the current turn only. (refs #50)
+- **Memory: `recentTouches` stale entry eviction** — `LSPService.recentTouches` grew unboundedly across a session with one entry per unique file path. Entries older than `TOUCH_DEBOUNCE_MS` are already ignored by `shouldSkipTouch`; a threshold-based sweep (triggered when size > 200) now removes them. (refs #50)
+- **Memory: orphaned LSP child processes on Windows** — `clientShutdown` only called `process.kill()` which on Windows terminates the direct child but leaves grandchildren (e.g. `tsserver.js`) as orphaned OS processes each holding 300–600MB. Both the normal shutdown and crash paths now go through a shared `killProcessTree` helper: on Windows it runs `taskkill /F /T` via absolute `SystemRoot` path and awaits completion before returning; on other platforms it sends `SIGTERM`. The SIGKILL fallback timer is also skipped on Windows since `taskkill /F` already force-terminates. (refs #50)
+- **Memory: file-time session state not cleared on session reset** — `clearAllSessions()` from `file-time.ts` is now called during `handleSessionStart`, clearing stale file timestamp state that previously accumulated across session switches. (refs #50)
+- **Memory: pending ast-grep warn timers not cancelled on session reset** — `resetDispatchBaselines()` left active `astGrepWarnDebounceTimers` running into a cleared session context. Now explicitly cancelled and cleared on reset. (refs #50)
+- **Security: `taskkill` spawned via absolute path** — both the normal shutdown and crash paths now resolve `taskkill.exe` through `process.env.SystemRoot` instead of relying on PATH, eliminating the SonarCloud PATH-injection hotspot.
+- **LSP: shutdown cannot hang indefinitely** — `client.shutdown()` now bounds the graceful `shutdown` request and proceeds to `exit`/process-tree kill if a server stops responding.
+- **LSP: test cleanup stop helper hardened on Windows** — `stopLSP()` now uses the absolute `taskkill.exe` path, handles already-exited processes, and avoids orphaning grandchildren by killing the process tree before the direct child on Windows.
+
+- **booboo project root detection** — `resolveProjectRoot` now walks up to the nearest ancestor with a root marker (`package.json`, `tsconfig.json`, `.git`, etc.), then falls back to walking down one level if exactly one immediate subdirectory has a root marker. Fixes scans running against the wrong directory in nested-project layouts (e.g. `pi-models/pi-models/`).
+
+- **Switch-case false positives eliminated** — replaced naive `switch-fall-through` rules with `switch-case-termination` rules that properly recognize `return`, `throw`, and `continue` as valid case terminators. Reduced false positive hits from 174 to 0.
+- **Self-assignment false positives fixed** — changed from `post_filter: same_identifier` to inline `#eq?` predicate so `wave = nextWave` is no longer flagged as self-assignment
+
+## [3.8.39] - 2026-05-02
+
+### Fixed
+
+- **Context injection now prepends guidance before the user prompt** — pi-lens previously appended session guidance after the user's message; provider bridges that treat the last message as the active user action would demote the real request. Guidance is now prepended so the user's prompt stays last. (PR #48 by @tifandotme)
+- **jscpd no longer runs on YAML/JSON/Markdown files** — `getFilesForJscpd` now filters to source code extensions only, preventing multi-second delays at `turn_end` when editing rule YAMLs or config files.
+- **ReDoS S5852 final (gleam/zig parsers)** — rewrote `gleamRe` and `zigRe` as line-by-line parsers, eliminating the multiline flag that SonarCloud continued to flag despite `[ \t]*` substitution.
+- **SonarCloud MAJOR code smells (batch 1 & 2)** — `readonly` members, `void` operator removals, nested ternaries, nested template literals, optional chains, duplicate branches, and redundant type alias across 15+ files.
+- **Type-narrow `severityMap` for `Diagnostic.severity` union** — properly satisfies the union type for diagnostic severity mapping.
+- **9 tree-sitter query bugs in new rule files** — predicate outside outermost parens (`cpp/no-auto-ptr`); false-positive `post_filter` gate added (`cpp/no-confused-move-forward`); leaf-node child match removed (`php/this-in-static-context`); invalid node name `class_hereditary` replaced (`java/no-field-shadowing`); field order corrected (`java/no-wait-notify-on-thread`); duplicate `modifiers` blocks merged (`java/spring-session-attributes-setcomplete`); invalid anonymous-node field label removed (`csharp/is-with-this`); inline alternation replaced with two patterns (`python/in-operator-unsupported`); adjacent sibling requirement removed, delegated to `post_filter` (`python/return-in-generator`).
+
 ## [3.8.38] - 2026-05-02
 
 ### Added
@@ -1123,7 +1174,6 @@ All runtime-applicable TypeScript ast-grep rules now have JavaScript equivalents
 - **Rust performance core (`pi-lens-core`)** — Optional Rust binary for CPU-intensive operations.
   All features fall back to TypeScript automatically if the binary is not available (it is **not**
   built automatically on `npm install` — run `npm run rust:build` once if you have Rust installed).
-
   - **File scanning** — ripgrep’s `ignore` crate for `.gitignore`-aware project scanning
   - **Similarity detection** — parallel 57×72 state-matrix index, persisted to
     `.pi-lens/rust-index.json` between invocations (fixes in-memory cache that reset on every
@@ -1177,7 +1227,6 @@ All runtime-applicable TypeScript ast-grep rules now have JavaScript equivalents
   - Removed `clients/interviewer-templates.ts` (240 lines)
   - Removed initialization from `index.ts`
 - **Deleted deprecated commands** — All were superseded by `/lens-booboo`:
-
   - `/lens-booboo-fix` command (fix-from-booboo.ts, 430 lines) — showed warning to use `/lens-booboo`
   - `/lens-fix-simplified` command (fix-simplified.ts, 770 lines) — never registered, unused
   - `/lens-rate` command (rate.ts, 340 lines) — showed warning to use `/lens-booboo`
@@ -1196,7 +1245,6 @@ All runtime-applicable TypeScript ast-grep rules now have JavaScript equivalents
   - Broken runner tests (7 files) — thin CLI wrappers with wrong imports
   - Trivial utility tests (5 files) — file extension parsing, string sanitization
 - **Added meaningful integration tests**:
-
   - `tests/clients/dispatch/dispatcher-flow.test.ts` — Runner registration, execution, delta mode, conditional runners
   - `tests/extension-hooks.test.ts` — pi API: tool/command/flag registration, event handlers
   - `tests/mocks/runner-factory.ts` — Mock runners for testing without real CLI tools
@@ -1532,7 +1580,6 @@ Migrated 20 critical security rules to NAPI (fast native execution):
 Three new lint runners with full test coverage:
 
 - **Spellcheck runner** (`clients/dispatch/runners/spellcheck.ts`): Markdown spellchecking
-
   - Uses `typos-cli` (Rust-based, fast, low false positives)
   - Checks `.md` and `.mdx` files
   - Priority 30, runs after code quality checks
@@ -1540,7 +1587,6 @@ Three new lint runners with full test coverage:
   - Install: `cargo install typos-cli`
 
 - **Oxlint runner** (`clients/dispatch/runners/oxlint.ts`): Fast JS/TS linting
-
   - Uses `oxlint` from Oxc project (Rust-based, ~100x faster than ESLint)
   - Zero-config by default
   - JSON output with fix suggestions

package/README.md

@@ -41,7 +41,7 @@ At `session_start`, pi-lens:
 - applies language-aware startup defaults for tool preinstall
 - warms caches and optional indexes (with overlap/session guardrails)
 - emits missing-tool install hints for detected languages when relevant
-- injects session guidance through internal context (non-user channel) to reduce acknowledgement-only first responses
+- prepends session guidance before the user's prompt so provider bridges keep the real prompt active
 - opens `warmFiles` (if configured in `.pi-lens/lsp.json`) to seed lazy-indexing language servers like clangd before the first symbol query
 
 For one-shot print sessions (for example `pi --print ...`), pi-lens auto-uses a quick startup path that skips heavy bootstrap work to reduce startup latency. Override with `PI_LENS_STARTUP_MODE=full|minimal|quick`.

package/clients/biome-client.ts

@@ -263,9 +263,10 @@ export class BiomeClient {
 		const content = fs.readFileSync(absolutePath, "utf-8");
 
 		try {
-			// Single invocation: check --write applies safe formatting + lint fixes.
-			// No pre-flight checkFile() needed — content diff tells us if anything changed.
-			const result = this.spawnBiome(["check", "--write", absolutePath]);
+			// lint --write applies safe lint fixes only — no formatting.
+			// Formatting is deferred to agent_end to avoid mid-turn file modifications
+			// that trigger read-guard "file modified since read" blocks.
+			const result = this.spawnBiome(["lint", "--write", absolutePath]);
 
 			if (result.error) {
 				return {
@@ -325,7 +326,7 @@ export class BiomeClient {
 		try {
 			const before = await fs.promises.readFile(absolutePath, "utf-8");
 			const result = await this.spawnBiomeAsync([
-				"check",
+				"lint",
 				"--write",
 				absolutePath,
 			]);

package/clients/cache-manager.ts

@@ -307,10 +307,13 @@ export class CacheManager {
 
 	/**
 	 * Get files that need jscpd re-scan (any edit).
+	 * Only returns source code files jscpd can meaningfully analyse.
 	 */
 	getFilesForJscpd(cwd: string): string[] {
 		const state = this.readTurnState(cwd);
-		return Object.keys(state.files);
+		return Object.keys(state.files).filter((f) =>
+			/\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|rb|java|cs|php|cpp|c|h|hpp|swift|kt)$/.test(f),
+		);
 	}
 
 	/**

package/clients/dispatch/fact-scheduler.ts

@@ -61,7 +61,8 @@ export function scheduleProviders(providers: FactProvider[]): FactProvider[] {
         }
       }
     }
-    wave = nextWave.sort((a, b) => a.id.localeCompare(b.id));
+    nextWave.sort((a, b) => a.id.localeCompare(b.id));
+    wave = nextWave;
   }
 
   if (result.length < providers.length) {

package/clients/dispatch/fact-store.ts

@@ -1,7 +1,5 @@
 import { normalizeMapKey } from "../path-utils.js";
 
-type FactValue = unknown;
-
 export interface ReadonlyFactStore {
   getFileFact<T>(filePath: string, factId: string): T | undefined;
   hasFileFact(filePath: string, factId: string): boolean;
@@ -10,8 +8,8 @@ export interface ReadonlyFactStore {
 }
 
 export class FactStore implements ReadonlyFactStore {
-  private readonly fileFacts = new Map<string, Map<string, FactValue>>();
-  private readonly sessionFacts = new Map<string, FactValue>();
+  private readonly fileFacts = new Map<string, Map<string, unknown>>();
+  private readonly sessionFacts = new Map<string, unknown>();
 
   // All file-keyed methods normalize the path internally via normalizeMapKey().
   // Callers always pass raw/resolved paths — normalization is not their concern.
@@ -20,7 +18,7 @@ export class FactStore implements ReadonlyFactStore {
     return this.fileFacts.get(normalizeMapKey(filePath))?.get(factId) as T | undefined;
   }
 
-  setFileFact(filePath: string, factId: string, value: FactValue): void {
+  setFileFact(filePath: string, factId: string, value: unknown): void {
     const key = normalizeMapKey(filePath);
     let facts = this.fileFacts.get(key);
     if (!facts) {
@@ -51,7 +49,7 @@ export class FactStore implements ReadonlyFactStore {
     return this.sessionFacts.get(factId) as T | undefined;
   }
 
-  setSessionFact(factId: string, value: FactValue): void {
+  setSessionFact(factId: string, value: unknown): void {
     this.sessionFacts.set(factId, value);
   }
 

package/clients/dispatch/integration.ts

@@ -358,6 +358,8 @@ export function resetDispatchBaselines(): void {
 	primaryFilesThisTurn.clear();
 	cascadeDiagnosticBaselines.clear();
 	cascadeSessionStats = { runs: 0, diagnosticsSurfaced: 0, coldSnapshotTouches: 0 };
+	for (const timer of astGrepWarnDebounceTimers.values()) clearTimeout(timer);
+	astGrepWarnDebounceTimers.clear();
 }
 
 let cascadeSessionStats = { runs: 0, diagnosticsSurfaced: 0, coldSnapshotTouches: 0 };
@@ -479,7 +481,7 @@ export async function computeCascadeForFile(
 		.filter((n) => !primaryFilesThisTurn.has(normalizeMapKey(n)))
 		.sort((a, b) => {
 			const rank = (p: string) =>
-				importerSet.has(p) ? 0 : callerSet.has(p) ? 1 : 2;
+				importerSet.has(p) ? 0 : (callerSet.has(p) ? 1 : 2);
 			return rank(a) - rank(b);
 		})
 		.slice(0, MAX_FILES);
@@ -584,10 +586,7 @@ export async function computeCascadeForFile(
 				// write sequence. A new write (higher writeSeq) invalidates the cache entry.
 				const cached =
 					writeSeq != null ? neighborTouchCache.get(cacheKey) : undefined;
-				if (
-					cached != null &&
-					cached.turnSeq === turnSeq
-				) {
+				if (cached?.turnSeq === turnSeq) {
 					producedLspData = true;
 					const durationMs = Date.now() - neighborStart;
 					logCascade({

package/clients/dispatch/rules/quality-rules.ts

@@ -149,21 +149,16 @@ export const noBooleanParamsRule: FactRule = {
 					ts.isIdentifier(param.name) ? param.name.text : "";
 				if (BOOLEAN_PREFIX_OK.test(name)) continue;
 
-				let isBoolean = false;
-				if (param.type.kind === ts.SyntaxKind.BooleanKeyword) {
-					isBoolean = true;
-				} else if (
-					ts.isUnionTypeNode(param.type) &&
-					param.type.types.every(
-						(t) =>
-							t.kind === ts.SyntaxKind.BooleanKeyword ||
-							(ts.isLiteralTypeNode(t) &&
-								(t.literal.kind === ts.SyntaxKind.TrueKeyword ||
-									t.literal.kind === ts.SyntaxKind.FalseKeyword)),
-					)
-				) {
-					isBoolean = true;
-				}
+				const isBoolean =
+					param.type.kind === ts.SyntaxKind.BooleanKeyword ||
+					(ts.isUnionTypeNode(param.type) &&
+						param.type.types.every(
+							(t) =>
+								t.kind === ts.SyntaxKind.BooleanKeyword ||
+								(ts.isLiteralTypeNode(t) &&
+									(t.literal.kind === ts.SyntaxKind.TrueKeyword ||
+										t.literal.kind === ts.SyntaxKind.FalseKeyword)),
+						));
 
 				if (!isBoolean) continue;
 				const { line, character } = sf.getLineAndCharacterOfPosition(param.getStart(sf));

package/clients/dispatch/runners/biome-check.ts

@@ -134,7 +134,7 @@ const biomeCheckJsonRunner: RunnerDefinition = {
 				diagnostics: [
 					{
 						id: "biome:parse-error:1",
-						message: `Biome JSON parse failed: ${parsed.parseError}${preview ? ` (output preview: ${preview})` : ""}`,
+						message: "Biome JSON parse failed: " + parsed.parseError + (preview ? " (output preview: " + preview + ")" : ""),
 						filePath: ctx.filePath,
 						line: 1,
 						column: 1,

package/clients/dispatch/runners/eslint.ts

@@ -125,7 +125,7 @@ const eslintRunner: RunnerDefinition = {
 				diagnostics: [
 					{
 						id: "eslint:parse-error:1",
-						message: `ESLint JSON parse failed: ${parsed.parseError}${preview ? ` (output preview: ${preview})` : ""}`,
+						message: "ESLint JSON parse failed: " + parsed.parseError + (preview ? " (output preview: " + preview + ")" : ""),
 						filePath: ctx.filePath,
 						line: 1,
 						column: 1,

package/clients/dispatch/runners/lsp.ts

@@ -212,11 +212,7 @@ const lspRunner: RunnerDefinition = {
 		);
 
 		const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
-		const resultSemantic = hasErrors
-			? "blocking"
-			: diagnostics.length > 0
-				? "warning"
-				: "none";
+		const resultSemantic = hasErrors ? "blocking" : (diagnostics.length > 0 ? "warning" : "none");
 
 		return {
 			status: hasErrors ? "failed" : "succeeded",

package/clients/dispatch/runners/psscriptanalyzer.ts

@@ -86,7 +86,7 @@ function parsePSAnalyzerOutput(raw: string, filePath: string): Diagnostic[] {
 		.map((item) => {
 			const sev = (item.Severity ?? "Warning").toLowerCase();
 			const severity: "error" | "warning" | "info" =
-				sev === "error" || sev === "parseerror" ? "error" : sev === "information" ? "info" : "warning";
+				(sev === "error" || sev === "parseerror") ? "error" : (sev === "information" ? "info" : "warning");
 			const rule = item.RuleName ?? "PSScriptAnalyzer";
 			return {
 				id: `psscriptanalyzer-${rule}-${item.Line}`,

package/clients/dispatch/runners/similarity.ts

@@ -394,10 +394,7 @@ function getArrowSignature(
 		| import("typescript").ArrowFunction
 		| import("typescript").FunctionExpression,
 ): string {
-	const params = node.parameters
-		.map((p) => (tsModule.isIdentifier(p.name) ? p.name.text : "param"))
-		.join(", ");
-	return `(${params})`;
+	return getSignature(tsModule, node as unknown as import("typescript").FunctionDeclaration);
 }
 
 // ============================================================================

package/clients/dispatch/utils/lsp-diagnostics.ts

@@ -16,16 +16,10 @@ export function convertLspDiagnostics(
 	return diags
 		.filter((d) => d.range?.start?.line !== undefined)
 		.map((d, idx) => {
-			const severity =
-				d.severity === 1
-					? "error"
-					: d.severity === 2
-						? "warning"
-						: d.severity === 4
-							? "hint"
-							: "info";
+			const severityMap: Record<number, "error" | "warning" | "hint"> = { 1: "error", 2: "warning", 4: "hint" };
+			const severity: "error" | "warning" | "info" | "hint" = severityMap[d.severity] ?? "info";
 			const semantic =
-				d.severity === 1 ? "blocking" : d.severity === 2 ? "warning" : "none";
+				d.severity === 1 ? "blocking" : (d.severity === 2 ? "warning" : "none");
 			const code = String(d.code ?? "unknown");
 			const source = options.source ?? d.source ?? tool;
 			const hasSuggestion = options.fixSuggestionByIndex?.has(idx) ?? false;

package/clients/formatters.ts

@@ -54,7 +54,7 @@ async function tryLazyInstallFormatterTool(
 		const ok = !res.error && res.status === 0;
 		if (!ok) {
 			console.error(
-				`[format] lazy-install rubocop failed: ${res.error?.message ?? res.stderr ?? `exit ${res.status}`}`,
+				`[format] lazy-install rubocop failed: ${res.error?.message ?? res.stderr ?? "exit " + res.status}`,
 			);
 		}
 		return ok;
@@ -67,7 +67,7 @@ async function tryLazyInstallFormatterTool(
 	const ok = !res.error && res.status === 0;
 	if (!ok) {
 		console.error(
-			`[format] lazy-install rustfmt failed: ${res.error?.message ?? res.stderr ?? `exit ${res.status}`}`,
+			`[format] lazy-install rustfmt failed: ${res.error?.message ?? res.stderr ?? "exit " + res.status}`,
 		);
 	}
 	return ok;
@@ -919,11 +919,16 @@ export async function getFormattersForFile(
 
 	const enabled = selected ? [selected] : [];
 
-	const selectionReason = selected
-		? (formatterPolicy
-			? (candidateFormatters.some((f) => hasExplicitFormatterConfig(f.name, cwd)) ? "explicit-config" : "smart-default")
-			: "detect")
-		: "none";
+	let selectionReason: string;
+	if (!selected) {
+		selectionReason = "none";
+	} else if (!formatterPolicy) {
+		selectionReason = "detect";
+	} else {
+		selectionReason = candidateFormatters.some((f) => hasExplicitFormatterConfig(f.name, cwd))
+			? "explicit-config"
+			: "smart-default";
+	}
 	logLatency({
 		type: "phase",
 		phase: "formatter_selected",

package/clients/lsp/client.ts

@@ -8,9 +8,9 @@
  * - Request/response handling
  */
 
-import { existsSync } from "node:fs";
 import { spawn as nodeSpawn } from "node:child_process";
 import { EventEmitter } from "node:events";
+import { existsSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import type { MessageConnection } from "vscode-jsonrpc";
 import {
@@ -252,6 +252,10 @@ const PULL_DIAGNOSTICS_RETRY_INTERVAL_MS = positiveIntFromEnv(
 	"PI_LENS_LSP_PULL_RETRY_INTERVAL_MS",
 	250,
 );
+const SHUTDOWN_REQUEST_TIMEOUT_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_SHUTDOWN_TIMEOUT_MS",
+	1000,
+);
 
 const LSP_CRASH_CODES = new Set([
 	"ERR_STREAM_DESTROYED",
@@ -340,6 +344,33 @@ function disposeClientConnection(state: LSPClientState): void {
 	}
 }
 
+async function killProcessTree(
+	proc: { kill(signal?: NodeJS.Signals | number): boolean },
+	pid: number,
+): Promise<void> {
+	if (process.platform === "win32" && pid > 0) {
+		await new Promise<void>((resolve) => {
+			try {
+				// Absolute path avoids PATH-resolution: SystemRoot is set by Windows itself.
+				const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
+				const killer = nodeSpawn(taskkill, ["/F", "/T", "/PID", String(pid)], {
+					shell: false,
+					windowsHide: true,
+				});
+				killer.once("close", () => resolve());
+				killer.once("error", () => resolve());
+			} catch {
+				resolve();
+			}
+		});
+		return;
+	}
+
+	try {
+		proc.kill("SIGTERM");
+	} catch {}
+}
+
 function mergeDiagnosticLists(
 	push: LSPDiagnostic[] | undefined,
 	pull: LSPDiagnostic[] | undefined,
@@ -483,9 +514,7 @@ function setupIncomingHandlers(
 	);
 	state.connection.onRequest(
 		"client/unregisterCapability",
-		async (params: {
-			unregisterations?: Array<{ id: string }>;
-		}) => {
+		async (params: { unregisterations?: Array<{ id: string }> }) => {
 			for (const unreg of params?.unregisterations ?? []) {
 				if (unreg.id) {
 					state.dynamicRegistrations.delete(unreg.id);
@@ -715,9 +744,12 @@ async function clientShutdown(state: LSPClientState): Promise<void> {
 	state.openDocuments.clear();
 	state.diagnosticEmitter.removeAllListeners();
 	try {
-		await safeSendRequest(state.connection, "shutdown", {});
+		await withTimeout(
+			safeSendRequest(state.connection, "shutdown", {}),
+			SHUTDOWN_REQUEST_TIMEOUT_MS,
+		);
 	} catch {
-		/* ignore */
+		/* ignore — proceed to exit/kill so shutdown cannot hang the session */
 	}
 	try {
 		await safeSendNotification(state.connection, "exit", {});
@@ -725,7 +757,10 @@ async function clientShutdown(state: LSPClientState): Promise<void> {
 		/* ignore */
 	}
 	disposeClientConnection(state);
-	state.lspProcess.process.kill();
+	const pid = state.lspProcess.pid;
+	// On Windows, killing the direct child first can orphan grandchildren before
+	// taskkill can traverse the tree. Kill the full tree first and wait briefly.
+	await killProcessTree(state.lspProcess.process, pid);
 }
 
 async function navRequest<T>(
@@ -902,17 +937,11 @@ export async function createLSPClient(options: {
 		// Hard-kill the hung process so it doesn't become a zombie.
 		// SIGTERM alone is unreliable on Windows for cmd.exe/PowerShell trees.
 		const pid = lspProcess.pid;
-		lspProcess.process.kill("SIGTERM");
-		if (process.platform === "win32" && pid > 0) {
-			try {
-				nodeSpawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
-					shell: false,
-					windowsHide: true,
-				});
-			} catch {}
-		}
+		void killProcessTree(lspProcess.process, pid);
 		setTimeout(() => {
-			if (!lspProcess.process.killed) lspProcess.process.kill("SIGKILL");
+			if (!lspProcess.process.killed && process.platform !== "win32") {
+				lspProcess.process.kill("SIGKILL");
+			}
 		}, 2000);
 		throw err;
 	} finally {
@@ -940,7 +969,8 @@ export async function createLSPClient(options: {
 		);
 	}
 
-	state.workspaceDiagnosticsSupport = detectWorkspaceDiagnosticsSupport(initResult);
+	state.workspaceDiagnosticsSupport =
+		detectWorkspaceDiagnosticsSupport(initResult);
 	state.operationSupport = detectOperationSupport(initResult);
 	state.staticDiagnosticsMode = state.workspaceDiagnosticsSupport.mode;
 
@@ -1247,19 +1277,24 @@ async function withTimeout<T>(
 	promise: Promise<T>,
 	timeoutMs: number,
 ): Promise<T> {
+	let timeout: ReturnType<typeof setTimeout> | undefined;
 	// Suppress unhandled rejection if `promise` rejects AFTER the timeout
 	// wins the race — Promise.race settles on the first result but the
 	// losing promises still run, and any later rejection would be uncaught.
 	promise.catch(() => {});
-	return Promise.race([
-		promise,
-		new Promise<T>((_, reject) =>
-			setTimeout(
-				() => reject(new Error(`Timeout after ${timeoutMs}ms`)),
-				timeoutMs,
-			),
-		),
-	]);
+	try {
+		return await Promise.race([
+			promise,
+			new Promise<T>((_, reject) => {
+				timeout = setTimeout(
+					() => reject(new Error(`Timeout after ${timeoutMs}ms`)),
+					timeoutMs,
+				);
+			}),
+		]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
 }
 
 function positiveIntFromEnv(name: string, fallback: number): number {

package/clients/lsp/index.ts

@@ -135,13 +135,13 @@ export interface LSPTouchFileOptions {
 
 export class LSPService {
 	private state: LSPState;
-	private workspaceProbeLogged = new Set<string>();
-	private warmStartLogged = new Set<string>();
-	private optionalFailureLogged = new Set<string>();
-	private optionalDisabled = new Set<string>();
+	private readonly workspaceProbeLogged = new Set<string>();
+	private readonly warmStartLogged = new Set<string>();
+	private readonly optionalFailureLogged = new Set<string>();
+	private readonly optionalDisabled = new Set<string>();
 	/** Consecutive failure counts for exponential backoff circuit breaker */
-	private failureCounts = new Map<string, number>();
-	private recentTouches = new Map<
+	private readonly failureCounts = new Map<string, number>();
+	private readonly recentTouches = new Map<
 		string,
 		{ fingerprint: string; touchedAt: number; clientScope: "primary" | "all" }
 	>();
@@ -197,11 +197,22 @@ export class LSPService {
 		clientScope: "primary" | "all",
 	): void {
 		const key = `${normalizeMapKey(filePath)}:${clientScope}`;
+		const now = Date.now();
 		this.recentTouches.set(key, {
 			fingerprint: this.fingerprintContent(content),
-			touchedAt: Date.now(),
+			touchedAt: now,
 			clientScope,
 		});
+		// Trim entries that are already past the debounce window — shouldSkipTouch
+		// ignores them anyway, so they serve no purpose. Only sweep when the map
+		// exceeds the threshold to avoid iterating on every call.
+		if (this.recentTouches.size > 200) {
+			for (const [k, v] of this.recentTouches) {
+				if (now - v.touchedAt > TOUCH_DEBOUNCE_MS) {
+					this.recentTouches.delete(k);
+				}
+			}
+		}
 	}
 
 	/**
@@ -309,7 +320,7 @@ export class LSPService {
 			if (!root) continue;
 			const key = `${server.id}:${normalizeMapKey(root)}`;
 			const existing = this.state.clients.get(key);
-			if (existing && existing.isAlive()) {
+			if (existing?.isAlive()) {
 				return { client: existing, info: server };
 			}
 		}
@@ -392,9 +403,7 @@ export class LSPService {
 		}
 	}
 
-	private shouldAllowInstall(filePath: string, root: string): boolean {
-		void filePath;
-		void root;
+	private shouldAllowInstall(_filePath: string, _root: string): boolean {
 		return process.env.PI_LENS_DISABLE_LSP_INSTALL !== "1";
 	}