pi-lens 3.8.39 → 3.8.40

package/CHANGELOG.md

@@ -4,6 +4,46 @@ 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
@@ -12,6 +52,7 @@ All notable changes to pi-lens will be documented in this file.
 - **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
@@ -1133,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
@@ -1187,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`
@@ -1206,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
@@ -1542,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
@@ -1550,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/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/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 };

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

@@ -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);
+				}
+			}
+		}
 	}
 
 	/**

package/clients/lsp/launch.ts

@@ -402,7 +402,19 @@ function _attachErrorHandler(
 	proc.on("error", (err) => {
 		if (logContext) {
 			logSessionStart(
-				"lsp process " + context + ": spawn-error command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + " error=" + err.message + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
+				"lsp process " +
+					context +
+					": spawn-error command=" +
+					logContext.command +
+					" args=" +
+					JSON.stringify(logContext.args) +
+					" cwd=" +
+					logContext.cwd +
+					" pid=" +
+					(logContext.pid ?? 0) +
+					" error=" +
+					err.message +
+					(stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
 			);
 		}
 
@@ -422,12 +434,37 @@ function _attachErrorHandler(
 		if (code !== 0 && code !== null) {
 			if (logContext) {
 				logSessionStart(
-					"lsp process " + context + ": closed code=" + code + (signal ? " signal=" + signal : "") + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
+					"lsp process " +
+						context +
+						": closed code=" +
+						code +
+						(signal ? " signal=" + signal : "") +
+						" command=" +
+						logContext.command +
+						" args=" +
+						JSON.stringify(logContext.args) +
+						" cwd=" +
+						logContext.cwd +
+						" pid=" +
+						(logContext.pid ?? 0) +
+						(stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
 				);
 			}
 		} else if (signal && logContext) {
 			logSessionStart(
-				"lsp process " + context + ": closed signal=" + signal + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
+				"lsp process " +
+					context +
+					": closed signal=" +
+					signal +
+					" command=" +
+					logContext.command +
+					" args=" +
+					JSON.stringify(logContext.args) +
+					" cwd=" +
+					logContext.cwd +
+					" pid=" +
+					(logContext.pid ?? 0) +
+					(stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
 			);
 		}
 	});
@@ -451,7 +488,7 @@ export async function launchLSP(
 	command: string,
 	args: string[] = [],
 	options: SpawnOptions & {
-		startupFailureWindowMs?: number,
+		startupFailureWindowMs?: number;
 	} = {},
 ): Promise<LSPProcess> {
 	const cwd = String(options.cwd ?? process.cwd());
@@ -467,7 +504,9 @@ export async function launchLSP(
 	// - If already absolute, use as-is
 	// - If it's a simple command (no path separators), let system find it via PATH
 	// - Otherwise, resolve relative to cwd
-	const isRelativePath = !path.isAbsolute(command) && (command.includes(path.sep) || command.includes("/"));
+	const isRelativePath =
+		!path.isAbsolute(command) &&
+		(command.includes(path.sep) || command.includes("/"));
 	const explicitCommand = isRelativePath ? path.resolve(cwd, command) : command;
 	const resolvedCommand =
 		!path.isAbsolute(command) &&
@@ -645,7 +684,7 @@ export async function launchLSP(
 					return DEFAULT_STARTUP_FAILURE_WINDOW_MS;
 				}
 			})();
-				
+
 			// Give shell-backed Windows launches a slightly longer window because
 			// npm/cmd shims can fail asynchronously after the initial spawn succeeds.
 			setTimeout(() => {
@@ -803,38 +842,72 @@ export async function launchViaPython(
  * Stop an LSP process gracefully
  */
 export async function stopLSP(handle: LSPProcess): Promise<void> {
+	if (handle.process.exitCode !== null || handle.process.signalCode !== null) {
+		return;
+	}
+
 	return new Promise((resolve) => {
-		// Send SIGTERM first
-		handle.process.kill("SIGTERM");
-
-		// Force kill after timeout
-		const timeout = setTimeout(() => {
-			if (!handle.process.killed) {
-				if (isWindows && handle.pid > 0) {
-					// SIGKILL is unreliable for cmd.exe/PowerShell child trees on Windows.
-					// taskkill /F /T kills the process and all its children.
-					try {
-						nodeSpawn("taskkill", ["/F", "/T", "/PID", String(handle.pid)], {
-							shell: false,
-							windowsHide: true,
-						});
-					} catch {
-						handle.process.kill("SIGKILL");
-					}
-				} else {
+		let settled = false;
+		let forceTimeout: ReturnType<typeof setTimeout> | undefined;
+		let giveUpTimeout: ReturnType<typeof setTimeout> | undefined;
+
+		const done = () => {
+			if (settled) return;
+			settled = true;
+			if (forceTimeout) clearTimeout(forceTimeout);
+			if (giveUpTimeout) clearTimeout(giveUpTimeout);
+			handle.process.off("exit", done);
+			handle.process.off("error", done);
+			resolve();
+		};
+
+		handle.process.once("exit", done);
+		handle.process.once("error", done);
+
+		const killWindowsTree = (): boolean => {
+			if (!isWindows || handle.pid <= 0) return false;
+			try {
+				// Absolute path avoids PATH-resolution substitution on Windows.
+				const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
+				const killer = nodeSpawn(
+					taskkill,
+					["/F", "/T", "/PID", String(handle.pid)],
+					{
+						shell: false,
+						windowsHide: true,
+					},
+				);
+				killer.once("error", done);
+				return true;
+			} catch {
+				return false;
+			}
+		};
+
+		try {
+			// On Windows, kill the tree first; killing the direct child can orphan
+			// grandchildren (e.g. tsserver.js behind a cmd/npm shim).
+			if (!killWindowsTree()) {
+				handle.process.kill("SIGTERM");
+			}
+		} catch {
+			done();
+			return;
+		}
+
+		forceTimeout = setTimeout(() => {
+			if (settled) return;
+			try {
+				if (!killWindowsTree()) {
 					handle.process.kill("SIGKILL");
 				}
+			} catch {
+				done();
+				return;
 			}
+			// If the process had already exited before listeners were attached, no
+			// exit event will arrive. Resolve rather than hanging test cleanup forever.
+			giveUpTimeout = setTimeout(done, 500);
 		}, 5000);
-
-		handle.process.on("exit", () => {
-			clearTimeout(timeout);
-			resolve();
-		});
-
-		handle.process.on("error", () => {
-			clearTimeout(timeout);
-			resolve();
-		});
 	});
 }