@oh-my-pi/pi-coding-agent 17.3.4 → 17.3.7

package/src/extensibility/extensions/wrapper.ts

@@ -14,6 +14,7 @@ import type { Settings } from "../../config/settings";
 import type { Theme } from "../../modes/theme/theme";
 import { type ApprovalMode, formatApprovalPrompt, resolveApproval, truncateForPrompt } from "../../tools/approval";
 import { defaultLoadModeForToolName } from "../../tools/essential-tools";
+import { withFileMutationSession } from "../../tools/file-write-fallback";
 import { normalizeToolEventInput, resolveToolEventInput } from "../tool-event-input";
 import { applyToolProxy } from "../tool-proxy";
 import type { ExtensionRunner } from "./runner";
@@ -205,15 +206,18 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		let effectiveParams = params;
 		if (!loopEmittedToolCall && this.runner.hasHandlers("tool_call")) {
 			try {
-				const callResult = (await this.runner.emitToolCall({
-					type: "tool_call",
-					toolName: this.tool.name,
-					toolCallId,
-					input: normalizeToolEventInput(
-						this.tool.name,
-						resolveToolEventInput(this.tool, toolEventArgs(params, context)),
-					),
-				})) as ToolCallEventResult | undefined;
+				const callResult = (await this.runner.emitToolCall(
+					{
+						type: "tool_call",
+						toolName: this.tool.name,
+						toolCallId,
+						input: normalizeToolEventInput(
+							this.tool.name,
+							resolveToolEventInput(this.tool, toolEventArgs(params, context)),
+						),
+					},
+					signal,
+				)) as ToolCallEventResult | undefined;
 
 				if (callResult?.block) {
 					const reason = callResult.reason || "Tool execution was blocked by an extension";
@@ -265,7 +269,10 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 
 		if (approvalCheck.required) {
 			const scheduledCall = context?.toolCall?.toolCalls[context.toolCall.index];
-			if (scheduledCall?.id === toolCallId && scheduledCall.name === this.tool.name) {
+			if (
+				scheduledCall?.id === toolCallId &&
+				(scheduledCall.name === this.tool.name || scheduledCall.name === this.tool.customWireName)
+			) {
 				await untilAborted(signal, () => this.runner.waitForToolApprovalPreview(toolCallId));
 			}
 
@@ -343,7 +350,15 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		let executionError: Error | undefined;
 
 		try {
-			result = await this.tool.execute(toolCallId, effectiveParams, signal, onUpdate, context);
+			// A denied file write or delete inside this tool can be brokered to an
+			// extension handler, and that registry is PROCESS-WIDE — so the session is
+			// named here, the one place where every tool's execution and the runner
+			// that owns the handlers are both in scope (`sdk.ts` wraps the whole tool
+			// registry with this class whenever a runner exists). Inert with no
+			// fallback registered: no scope is entered.
+			result = await withFileMutationSession(this.runner.sessionId, () =>
+				this.tool.execute(toolCallId, effectiveParams, signal, onUpdate, context),
+			);
 		} catch (err) {
 			executionError = err instanceof Error ? err : new Error(String(err));
 			result = {

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -134,6 +134,10 @@ export const getModels = getBundledModels;
  *
  * Legacy `/compat` callers pass {@link SimpleStreamOptions}; routing through
  * `streamSimple` preserves option normalization before provider dispatch.
+ *
+ * Transient-failure retry (overload, rate-limit, 5xx) is the **caller's
+ * responsibility**. Oneshot callers that collect the full result before acting
+ * should wrap with `retryTransientCompletion` from `@oh-my-pi/pi-ai`.
  */
 export function streamSimpleOpenAIResponses(
 	model: Model<"openai-responses">,

package/src/extensibility/plugins/marketplace/manager.ts

@@ -11,6 +11,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 
 import { isEnoent, logger, pathIsWithin } from "@oh-my-pi/pi-utils";
+import { expandTilde } from "../../../tools/path-utils";
 import { normalizePluginRuntimeConfig } from "../runtime-config";
 import type { PluginRuntimeConfig } from "../types";
 
@@ -107,12 +108,11 @@ export class MarketplaceManager {
 		}
 
 		const sourceType = classifySource(source);
-		const normalizedSource =
-			sourceType === "local"
-				? path.resolve(source.startsWith("~/") ? path.join(os.homedir(), source.slice(2)) : source)
-				: source;
+		const normalizedSource = sourceType === "local" ? path.resolve(expandTilde(source)) : source;
 
-		const catalogPath = path.join(this.#opts.marketplacesCacheDir, catalog.name, "marketplace.json");
+		const catalogPath = path.resolve(
+			expandTilde(path.join(this.#opts.marketplacesCacheDir, catalog.name, "marketplace.json")),
+		);
 
 		// Persist the fetched catalog so subsequent reads don't require re-fetching.
 		await Bun.write(catalogPath, `${JSON.stringify(catalog, null, 2)}\n`);
@@ -174,11 +174,13 @@ export class MarketplaceManager {
 			await promoteCloneToCache(clonePath, this.#opts.marketplacesCacheDir, catalog.name);
 		}
 
-		// Overwrite cached catalog
-		await Bun.write(existing.catalogPath, `${JSON.stringify(catalog, null, 2)}\n`);
+		// Overwrite the cached catalog and migrate legacy home-relative registry entries.
+		const catalogPath = path.resolve(expandTilde(existing.catalogPath));
+		await Bun.write(catalogPath, `${JSON.stringify(catalog, null, 2)}\n`);
 
 		const updatedEntry: MarketplaceRegistryEntry = {
 			...existing,
+			catalogPath,
 			updatedAt: new Date().toISOString(),
 		};
 
@@ -893,14 +895,13 @@ export class MarketplaceManager {
 	}
 
 	async #readCatalog(entry: MarketplaceRegistryEntry): Promise<MarketplaceCatalog> {
+		const catalogPath = path.resolve(expandTilde(entry.catalogPath));
 		try {
-			const content = await Bun.file(entry.catalogPath).text();
-			return parseMarketplaceCatalog(content, entry.catalogPath);
+			const content = await Bun.file(catalogPath).text();
+			return parseMarketplaceCatalog(content, catalogPath);
 		} catch (err) {
 			if (isEnoent(err)) {
-				throw new Error(
-					`Marketplace catalog not found at ${entry.catalogPath}. Try: /marketplace update ${entry.name}`,
-				);
+				throw new Error(`Marketplace catalog not found at ${catalogPath}. Try: /marketplace update ${entry.name}`);
 			}
 			throw err;
 		}
@@ -918,14 +919,10 @@ export class MarketplaceManager {
 	 */
 	#resolveMarketplaceRoot(entry: MarketplaceRegistryEntry): string {
 		if (entry.sourceType === "local") {
-			// expandHome already happened in fetcher; resolve to ensure absolute.
-			const expanded = entry.sourceUri.startsWith("~/")
-				? path.join(os.homedir(), entry.sourceUri.slice(2))
-				: entry.sourceUri;
-			return path.resolve(expanded);
+			return path.resolve(expandTilde(entry.sourceUri));
 		}
 		// For git/github/url sources, the catalog lives at <cloneDir>/marketplace.json
 		// under marketplacesCacheDir/<name>/; parent = <marketplacesCacheDir>/<name>/
-		return path.dirname(entry.catalogPath);
+		return path.dirname(path.resolve(expandTilde(entry.catalogPath)));
 	}
 }

package/src/irc/bus.ts

@@ -276,7 +276,7 @@ export class IrcBus {
 		if (liveness) {
 			const { registry, senderId } = liveness;
 			const hasRunningSender = (from?: string): boolean =>
-				registry.listVisibleTo(senderId).some(ref => ref.status === "running" && (!from || ref.id === from));
+				registry.listVisibleTo(senderId).some(ref => registry.isRunning(ref) && (!from || ref.id === from));
 			const check = filter.from ? () => hasRunningSender(filter.from) : () => hasRunningSender();
 			unsubscribeLiveness = registry.onChange(() => {
 				if (!check()) {

package/src/launch/broker.ts

@@ -8,7 +8,7 @@ import { hostHasInheritableConsole } from "../eval/py/spawn-options";
 import { truncateHead, truncateHeadBytes, truncateTail, truncateTailBytes } from "../session/streaming-output";
 import { workerEnvFromParent } from "../subprocess/worker-client";
 import { daemonBrokerEndpoint } from "./paths";
-import { hasLiveDaemonProjectPresence } from "./presence";
+import { hasLiveDaemonProjectPresence, pruneDeadDaemonRuntimeDirs } from "./presence";
 import {
 	DAEMON_IDLE_GRACE_ENV,
 	DAEMON_PROJECT_DIR_ENV,
@@ -1384,6 +1384,13 @@ export async function startDaemonBrokerFromEnvironment(options: DaemonBrokerStar
 	const lease = await acquireBrokerLease(runtimeDir);
 	if (!lease) return;
 	setProcessName("omp daemon broker");
+	// Reclaim sibling daemon scopes left behind by dead brokers (issue #8674).
+	// Detached and non-throwing so it never delays clients connecting to us.
+	void pruneDeadDaemonRuntimeDirs(runtimeDir).catch(error => {
+		logger.warn("Daemon runtime prune failed", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+	});
 	const token = (await Bun.file(path.join(runtimeDir, TOKEN_FILE)).text()).trim();
 	if (!token) throw new Error("Daemon broker token is empty");
 	const broker = new DaemonBroker(projectDir, runtimeDir, token, idleGraceMs, restartBackoffBaseMs);

package/src/launch/presence.ts

@@ -1,9 +1,19 @@
+import type { Dirent } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { isEisdir, isEnoent, postmortem } from "@oh-my-pi/pi-utils";
+import { isEisdir, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
 import { daemonRuntimeDir } from "./paths";
 
 const CLIENTS_DIR = "clients";
+const BROKER_PID_FILE = "broker.pid";
+const GLOBAL_DAEMON_DIR = "global";
+/**
+ * Grace before a dead daemon runtime dir becomes prune-eligible. Guards against
+ * deleting a scope whose owning omp process is mid-startup (token written, broker
+ * not yet spawned, presence not yet registered). The leak this reclaims is a
+ * weeks-scale accumulation, so a few minutes of slack costs nothing.
+ */
+const DAEMON_RUNTIME_STALE_GRACE_MS = 5 * 60_000;
 
 /** Handle keeping one omp process registered in a project daemon scope. */
 export interface DaemonProjectPresence {
@@ -80,3 +90,69 @@ export async function hasLiveDaemonProjectPresence(runtimeDir: string): Promise<
 	}
 	return live;
 }
+
+/** Whether a runtime dir's recorded broker PID is still alive. */
+async function hasLiveDaemonBroker(runtimeDir: string): Promise<boolean> {
+	let raw: unknown;
+	try {
+		raw = await Bun.file(path.join(runtimeDir, BROKER_PID_FILE)).json();
+	} catch {
+		return false; // Missing or malformed broker.pid => no owning broker.
+	}
+	if (typeof raw !== "object" || raw === null || !("pid" in raw) || typeof raw.pid !== "number") {
+		return false;
+	}
+	try {
+		process.kill(raw.pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Remove sibling project daemon runtime directories whose broker is dead and
+ * whose client-presence set is empty, reclaiming the disk that short-lived
+ * project directories leave behind (issue #8674).
+ *
+ * Best-effort and non-throwing: a scope is deleted only when its `broker.pid`
+ * is absent/dead, no live client presence remains, and it has been untouched
+ * for {@link DAEMON_RUNTIME_STALE_GRACE_MS}. The caller's own `currentRuntimeDir`
+ * and the machine-global daemon container are always skipped.
+ */
+export async function pruneDeadDaemonRuntimeDirs(currentRuntimeDir: string): Promise<void> {
+	const root = path.dirname(currentRuntimeDir);
+	if (path.basename(root) === GLOBAL_DAEMON_DIR) return;
+	const current = path.resolve(currentRuntimeDir);
+	let entries: Dirent[];
+	try {
+		entries = await fs.readdir(root, { withFileTypes: true });
+	} catch (error) {
+		if (!isEnoent(error)) {
+			logger.warn("Failed to scan daemon runtime root for pruning", {
+				root,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+		return;
+	}
+	const now = Date.now();
+	for (const entry of entries) {
+		if (!entry.isDirectory() || entry.name === GLOBAL_DAEMON_DIR) continue;
+		const dir = path.join(root, entry.name);
+		if (path.resolve(dir) === current) continue;
+		try {
+			const stat = await fs.stat(dir);
+			if (now - stat.mtimeMs < DAEMON_RUNTIME_STALE_GRACE_MS) continue;
+			if (await hasLiveDaemonBroker(dir)) continue;
+			if (await hasLiveDaemonProjectPresence(dir)) continue;
+			await fs.rm(dir, { recursive: true, force: true });
+		} catch (error) {
+			if (isEnoent(error)) continue;
+			logger.warn("Failed to prune dead daemon runtime dir", {
+				dir,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+}

package/src/lsp/client.ts

@@ -62,13 +62,32 @@ export function setIdleTimeout(ms: number | null | undefined): void {
 	}
 }
 
+/**
+ * Whether a client may be reaped by the idle checker.
+ *
+ * A client with in-flight requests is *busy*, never idle. `lastActivity` is
+ * stamped when a request is written, not while it is outstanding, so a single
+ * request that runs longer than the idle timeout used to look like silence:
+ * the checker tore the client down mid-flight and `shutdownClientInstance`
+ * rejected the caller's still-pending promise with "LSP client shutdown"
+ * (issue #8390). Requests that settle refresh `lastActivity`, so a client
+ * becomes eligible again only after the final one lands and the full idle
+ * window then elapses.
+ *
+ * Exported for tests; the idle checker is the only production caller.
+ */
+export function isIdleClient(client: LspClient, now: number, timeoutMs: number): boolean {
+	if (client.pendingRequests.size > 0) return false;
+	return now - client.lastActivity > timeoutMs;
+}
+
 function startIdleChecker(): void {
 	if (idleCheckInterval) return;
 	idleCheckInterval = setInterval(() => {
 		if (!idleTimeoutMs) return;
 		const now = Date.now();
 		for (const [key, client] of Array.from(clients.entries())) {
-			if (now - client.lastActivity > idleTimeoutMs) {
+			if (isIdleClient(client, now, idleTimeoutMs)) {
 				void shutdownClient(key);
 			}
 		}
@@ -746,7 +765,13 @@ function commandBasename(command: string): string {
 	return separator === -1 ? command : command.slice(separator + 1);
 }
 
-function isRustAnalyzerClient(client: LspClient): boolean {
+/**
+ * True when this client speaks the rust-analyzer protocol, detected by the
+ * command basename (`rust-analyzer[.exe]`) of the configured or resolved
+ * binary. Callers use it to gate rust-analyzer-only requests such as
+ * `rust-analyzer/reloadWorkspace` (see {@link reloadServer}).
+ */
+export function isRustAnalyzerClient(client: LspClient): boolean {
 	return (
 		commandBasename(client.config.command) === "rust-analyzer" ||
 		(client.config.resolvedCommand ? commandBasename(client.config.resolvedCommand) === "rust-analyzer" : false)
@@ -1456,15 +1481,22 @@ export async function sendRequest(
 		}
 	}
 
-	// Register pending request with timeout wrapper
+	// Register pending request with timeout wrapper.
+	// Settling stamps `lastActivity`: the idle window must be measured from when
+	// the exchange finished, not from when it started. Without this a request
+	// that outlives the timeout would leave the client instantly reapable the
+	// moment it lands, so the next idle sweep would kill a server that had just
+	// answered (issue #8390).
 	client.pendingRequests.set(id, {
 		resolve: result => {
 			if (timeout) clearTimeout(timeout);
+			client.lastActivity = Date.now();
 			cleanup();
 			resolve(result);
 		},
 		reject: err => {
 			if (timeout) clearTimeout(timeout);
+			client.lastActivity = Date.now();
 			cleanup();
 			reject(err);
 		},

package/src/lsp/clients/biome-client.ts

@@ -14,14 +14,21 @@ interface BiomeJsonOutput {
 	diagnostics: BiomeDiagnostic[];
 }
 
+/**
+ * A single diagnostic from Biome's `--reporter=json` output (Biome 2.x).
+ *
+ * Positions are 1-indexed `{ line, column }` pairs; the path is a plain string
+ * relative to the CLI's cwd. Older releases used byte-offset `span`s, which
+ * this client no longer parses.
+ */
 interface BiomeDiagnostic {
 	category: string; // e.g., "lint/correctness/noUnusedVariables"
-	severity: "error" | "warning" | "info" | "hint";
-	description: string;
+	severity: string; // "error" | "warning" | "info" | "hint"
+	message: string;
 	location?: {
-		path?: { file: string };
-		span?: [number, number]; // [startOffset, endOffset] in bytes
-		sourceCode?: string;
+		path?: string;
+		start?: { line: number; column: number };
+		end?: { line: number; column: number };
 	};
 }
 
@@ -29,43 +36,6 @@ interface BiomeDiagnostic {
 // Helpers
 // =============================================================================
 
-/**
- * Convert byte offsets to line:column positions in a single pass over the source.
- */
-function offsetsToPositions(source: string, offsets: number[]): Map<number, { line: number; column: number }> {
-	const sorted = [...new Set(offsets)].sort((a, b) => a - b);
-	const result = new Map<number, { line: number; column: number }>();
-	let line = 1;
-	let column = 1;
-	let byteIndex = 0;
-	let next = 0;
-
-	for (const ch of source) {
-		if (next >= sorted.length) break;
-		const cp = ch.codePointAt(0) as number;
-		const byteLen = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
-		while (next < sorted.length && byteIndex + byteLen > sorted[next]) {
-			result.set(sorted[next], { line, column });
-			next++;
-		}
-		if (ch === "\n") {
-			line++;
-			column = 1;
-		} else {
-			column++;
-		}
-		byteIndex += byteLen;
-	}
-
-	// Offsets at or past end-of-file map to the final position.
-	while (next < sorted.length) {
-		result.set(sorted[next], { line, column });
-		next++;
-	}
-
-	return result;
-}
-
 /**
  * Parse Biome severity to LSP DiagnosticSeverity.
  */
@@ -176,8 +146,6 @@ export class BiomeClient implements LinterClient {
 	 * Parse Biome's JSON output into LSP Diagnostics.
 	 */
 	#parseJsonOutput(jsonOutput: string, targetFile: string): Diagnostic[] {
-		const diagnostics: Diagnostic[] = [];
-
 		let parsed: BiomeJsonOutput;
 		try {
 			parsed = JSON.parse(jsonOutput);
@@ -186,61 +154,36 @@ export class BiomeClient implements LinterClient {
 				cwd: this.cwd,
 				file: targetFile,
 			});
-			return diagnostics;
+			return [];
 		}
 
+		const emitted = parsed.diagnostics ?? [];
 		const target = path.resolve(targetFile);
-		const relevant: BiomeDiagnostic[] = [];
-		// Batch all span offsets per source text so each source is scanned once
-		// instead of twice per diagnostic.
-		const offsetsBySource = new Map<string, number[]>();
-		for (const diag of parsed.diagnostics ?? []) {
-			const location = diag.location;
-			if (!location?.path?.file) continue;
-
-			// Resolve file path
-			const diagFile = path.isAbsolute(location.path.file)
-				? location.path.file
-				: path.join(this.cwd, location.path.file);
-
-			// Only include diagnostics for the target file
-			if (path.resolve(diagFile) !== target) {
-				continue;
-			}
+		const diagnostics: Diagnostic[] = [];
+		// Biome's JSON reporter is experimental and may reshape its output in
+		// patch releases. Track whether any diagnostic carried a usable location
+		// so a schema drift surfaces as a warning instead of a silent empty list.
+		let sawUsableLocation = false;
 
-			relevant.push(diag);
-			if (location.span && location.sourceCode) {
-				const offsets = offsetsBySource.get(location.sourceCode);
-				if (offsets) offsets.push(location.span[0], location.span[1]);
-				else offsetsBySource.set(location.sourceCode, [location.span[0], location.span[1]]);
-			}
-		}
+		for (const diag of emitted) {
+			const location = diag.location;
+			const filePath = location?.path;
+			if (!filePath) continue;
+			sawUsableLocation = true;
 
-		const positionsBySource = new Map<string, Map<number, { line: number; column: number }>>();
-		for (const [source, offsets] of offsetsBySource) {
-			positionsBySource.set(source, offsetsToPositions(source, offsets));
-		}
+			// Biome reports paths relative to its cwd.
+			const diagFile = path.isAbsolute(filePath) ? filePath : path.join(this.cwd, filePath);
 
-		for (const diag of relevant) {
-			const location = diag.location;
-			let startLine = 1;
-			let startColumn = 1;
-			let endLine = 1;
-			let endColumn = 1;
+			// Only include diagnostics for the target file.
+			if (path.resolve(diagFile) !== target) continue;
 
-			if (location?.span && location.sourceCode) {
-				const positions = positionsBySource.get(location.sourceCode);
-				const startPos = positions?.get(location.span[0]);
-				const endPos = positions?.get(location.span[1]);
-				if (startPos) {
-					startLine = startPos.line;
-					startColumn = startPos.column;
-				}
-				if (endPos) {
-					endLine = endPos.line;
-					endColumn = endPos.column;
-				}
-			}
+			// Biome positions are 1-indexed; LSP ranges are 0-indexed.
+			const start = location.start;
+			const end = location.end ?? start;
+			const startLine = start?.line ?? 1;
+			const startColumn = start?.column ?? 1;
+			const endLine = end?.line ?? startLine;
+			const endColumn = end?.column ?? startColumn;
 
 			diagnostics.push({
 				range: {
@@ -248,12 +191,23 @@ export class BiomeClient implements LinterClient {
 					end: { line: endLine - 1, character: endColumn - 1 },
 				},
 				severity: parseSeverity(diag.severity),
-				message: diag.description,
+				message: diag.message,
 				source: "biome",
 				code: diag.category,
 			});
 		}
 
+		// Non-empty output whose diagnostics all lacked a recognizable location
+		// means the reporter schema changed out from under us — warn loudly
+		// instead of masking the regression as "no lint issues".
+		if (emitted.length > 0 && !sawUsableLocation) {
+			warnBiomeOnce(
+				`schema:${this.cwd}`,
+				"Biome diagnostics had no recognizable location; reporter schema may have changed",
+				{ cwd: this.cwd, file: targetFile, count: emitted.length },
+			);
+		}
+
 		return diagnostics;
 	}
 

package/src/lsp/servers.ts

@@ -4,6 +4,7 @@ import {
 	getActiveClients,
 	getActiveOrPendingClient,
 	getOrCreateClient,
+	isRustAnalyzerClient,
 	type LspServerStatus,
 	notifySaved,
 	sendNotification,
@@ -256,17 +257,22 @@ export function isMethodNotFoundError(err: unknown): boolean {
 
 export async function reloadServer(client: LspClient, serverName: string, signal?: AbortSignal): Promise<string> {
 	throwIfAborted(signal);
-	// rust-analyzer exposes a real reload request. Every other server rejects it
-	// with method-not-found — that alone justifies the generic fallback. A caller
-	// cancel or tool timeout must propagate, never be mistaken for an unsupported
-	// method and swallowed into a bogus "Restarted" (issue #6369).
-	try {
-		await sendRequest(client, "rust-analyzer/reloadWorkspace", null, signal);
-		return `Reloaded ${serverName}`;
-	} catch (err) {
-		throwIfAborted(signal);
-		if (!isMethodNotFoundError(err)) throw err;
-		// Method not supported — fall through to the generic reload.
+	// rust-analyzer exposes a real reload request. Only rust-analyzer implements
+	// it, so gate the request on the binary (or registered name) rather than
+	// probing every server: some servers (Roslyn) crash the whole process on an
+	// unknown method instead of replying with method-not-found — killing the
+	// server `lsp reload` was meant to refresh (issue #8571, dotnet/roslyn#84890).
+	// A caller cancel or tool timeout must propagate, never be mistaken for an
+	// unsupported method and swallowed into a bogus "Restarted" (issue #6369).
+	if (isRustAnalyzerClient(client) || serverName === "rust-analyzer") {
+		try {
+			await sendRequest(client, "rust-analyzer/reloadWorkspace", undefined, signal);
+			return `Reloaded ${serverName}`;
+		} catch (err) {
+			throwIfAborted(signal);
+			if (!isMethodNotFoundError(err)) throw err;
+			// Method not supported — fall through to the generic reload.
+		}
 	}
 	// workspace/didChangeConfiguration is a notification per spec; sending it
 	// as a request hangs until the tool deadline on servers that route it to

package/src/lsp/tool.ts

@@ -21,6 +21,7 @@ import {
 	ensureFileOpen,
 	getActiveClients,
 	getOrCreateClient,
+	isRustAnalyzerClient,
 	type LspServerStatus,
 	refreshFile,
 	sendNotification,
@@ -1075,10 +1076,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 		try {
 			const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 			const targetFile = resolvedFile;
-			const isRustAnalyzerServer =
-				serverName === "rust-analyzer" ||
-				path.basename(serverConfig.command) === "rust-analyzer" ||
-				(serverConfig.resolvedCommand ? path.basename(serverConfig.resolvedCommand) === "rust-analyzer" : false);
+			const isRustAnalyzerServer = isRustAnalyzerClient(client) || serverName === "rust-analyzer";
 			const needsProjectIndex =
 				targetFile !== null && PROJECT_INDEXED_ACTIONS.has(action) && isProjectAwareLspServer(serverConfig);
 			const rustWorkspaceWait =

package/src/lsp/workspace-diagnostics.ts

@@ -114,6 +114,17 @@ async function detectProjectType(cwd: string, signal?: AbortSignal): Promise<Pro
 	return { type: "unknown", description: "Unknown project type" };
 }
 
+/** Interpret an empty checker result without mistaking a crash for a clean workspace. */
+export function interpretEmptyDiagnosticsResult(
+	exitCode: number,
+	signalCode: string | null,
+	command: readonly string[],
+): string {
+	if (exitCode === 0) return "No issues found";
+	const detail = signalCode ? `was killed by ${signalCode}` : `exited with code ${exitCode}`;
+	return `Failed to run ${command.join(" ")}: the checker ${detail} without reporting anything, so the workspace was not verified`;
+}
+
 /** Run workspace diagnostics command and parse output */
 export async function runWorkspaceDiagnostics(
 	cwd: string,
@@ -146,11 +157,22 @@ export async function runWorkspaceDiagnostics(
 				new Response(proc.stdout).text(),
 				new Response(proc.stderr).text(),
 			]);
-			await proc.exited;
+			const exitCode = await proc.exited;
 			throwIfAborted(signal);
 			const combined = (stdout + stderr).trim();
 			if (!combined) {
-				return { output: "No issues found", projectType };
+				// A checker that exits non-zero without writing a single byte never
+				// inspected the workspace: it failed to start (missing toolchain),
+				// crashed, or was killed (OOM). Reporting "No issues found" there
+				// tells the agent the workspace is clean when nothing actually
+				// checked it. A non-zero exit *with* output is the normal way
+				// tsc/cargo/pyright report diagnostics and still falls through to
+				// the branch below. Mirrors the exit-status gate
+				// `resolveGoWorkspaceDiagnosticsCommand` already applies above.
+				return {
+					output: interpretEmptyDiagnosticsResult(exitCode, proc.signalCode, projectType.command),
+					projectType,
+				};
 			}
 			// Limit output length
 			const lines = combined.split("\n");