@oh-my-pi/pi-coding-agent 1.340.0 → 1.341.0

package/src/core/settings-manager.ts

@@ -51,12 +51,23 @@ export interface MCPSettings {
 	enableProjectConfig?: boolean; // default: true (load .mcp.json from project root)
 }
 
+export interface LspSettings {
+	formatOnWrite?: boolean; // default: true (format files using LSP after write tool writes code files)
+	diagnosticsOnWrite?: boolean; // default: true (return LSP diagnostics after write tool writes code files)
+	diagnosticsOnEdit?: boolean; // default: false (return LSP diagnostics after edit tool edits code files)
+}
+
+export interface EditSettings {
+	fuzzyMatch?: boolean; // default: true (accept high-confidence fuzzy matches for whitespace/indentation)
+}
+
 export interface Settings {
 	lastChangelogVersion?: string;
-	defaultProvider?: string;
-	defaultModel?: string;
+	/** Model roles map: { default: "provider/modelId", small: "provider/modelId", ... } */
+	modelRoles?: Record<string, string>;
 	defaultThinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 	queueMode?: "all" | "one-at-a-time";
+	interruptMode?: "immediate" | "wait";
 	theme?: string;
 	compaction?: CompactionSettings;
 	branchSummary?: BranchSummarySettings;
@@ -72,6 +83,8 @@ export interface Settings {
 	exa?: ExaSettings;
 	bashInterceptor?: BashInterceptorSettings;
 	mcp?: MCPSettings;
+	lsp?: LspSettings;
+	edit?: EditSettings;
 }
 
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -200,28 +213,29 @@ export class SettingsManager {
 		this.save();
 	}
 
-	getDefaultProvider(): string | undefined {
-		return this.settings.defaultProvider;
-	}
-
-	getDefaultModel(): string | undefined {
-		return this.settings.defaultModel;
+	/**
+	 * Get model for a role. Returns "provider/modelId" string or undefined.
+	 */
+	getModelRole(role: string): string | undefined {
+		return this.settings.modelRoles?.[role];
 	}
 
-	setDefaultProvider(provider: string): void {
-		this.globalSettings.defaultProvider = provider;
-		this.save();
-	}
-
-	setDefaultModel(modelId: string): void {
-		this.globalSettings.defaultModel = modelId;
+	/**
+	 * Set model for a role. Model should be "provider/modelId" format.
+	 */
+	setModelRole(role: string, model: string): void {
+		if (!this.globalSettings.modelRoles) {
+			this.globalSettings.modelRoles = {};
+		}
+		this.globalSettings.modelRoles[role] = model;
 		this.save();
 	}
 
-	setDefaultModelAndProvider(provider: string, modelId: string): void {
-		this.globalSettings.defaultProvider = provider;
-		this.globalSettings.defaultModel = modelId;
-		this.save();
+	/**
+	 * Get all model roles.
+	 */
+	getModelRoles(): Record<string, string> {
+		return { ...this.settings.modelRoles };
 	}
 
 	getQueueMode(): "all" | "one-at-a-time" {
@@ -233,6 +247,15 @@ export class SettingsManager {
 		this.save();
 	}
 
+	getInterruptMode(): "immediate" | "wait" {
+		return this.settings.interruptMode || "immediate";
+	}
+
+	setInterruptMode(mode: "immediate" | "wait"): void {
+		this.globalSettings.interruptMode = mode;
+		this.save();
+	}
+
 	getTheme(): string | undefined {
 		return this.settings.theme;
 	}
@@ -474,4 +497,52 @@ export class SettingsManager {
 		this.globalSettings.mcp.enableProjectConfig = enabled;
 		this.save();
 	}
+
+	getLspFormatOnWrite(): boolean {
+		return this.settings.lsp?.formatOnWrite ?? true;
+	}
+
+	setLspFormatOnWrite(enabled: boolean): void {
+		if (!this.globalSettings.lsp) {
+			this.globalSettings.lsp = {};
+		}
+		this.globalSettings.lsp.formatOnWrite = enabled;
+		this.save();
+	}
+
+	getLspDiagnosticsOnWrite(): boolean {
+		return this.settings.lsp?.diagnosticsOnWrite ?? true;
+	}
+
+	setLspDiagnosticsOnWrite(enabled: boolean): void {
+		if (!this.globalSettings.lsp) {
+			this.globalSettings.lsp = {};
+		}
+		this.globalSettings.lsp.diagnosticsOnWrite = enabled;
+		this.save();
+	}
+
+	getLspDiagnosticsOnEdit(): boolean {
+		return this.settings.lsp?.diagnosticsOnEdit ?? false;
+	}
+
+	setLspDiagnosticsOnEdit(enabled: boolean): void {
+		if (!this.globalSettings.lsp) {
+			this.globalSettings.lsp = {};
+		}
+		this.globalSettings.lsp.diagnosticsOnEdit = enabled;
+		this.save();
+	}
+
+	getEditFuzzyMatch(): boolean {
+		return this.settings.edit?.fuzzyMatch ?? true;
+	}
+
+	setEditFuzzyMatch(enabled: boolean): void {
+		if (!this.globalSettings.edit) {
+			this.globalSettings.edit = {};
+		}
+		this.globalSettings.edit.fuzzyMatch = enabled;
+		this.save();
+	}
 }

package/src/core/title-generator.ts

@@ -0,0 +1,94 @@
+/**
+ * Generate session titles using a smol, fast model.
+ */
+
+import type { Model } from "@oh-my-pi/pi-ai";
+import { completeSimple } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "./model-registry.js";
+import { findSmolModel } from "./model-resolver.js";
+
+const TITLE_SYSTEM_PROMPT = `Generate a very short title (3-6 words) for a coding session based on the user's first message. The title should capture the main task or topic. Output ONLY the title, nothing else. No quotes, no punctuation at the end.
+
+Examples:
+- "Fix TypeScript compilation errors"
+- "Add user authentication"
+- "Refactor database queries"
+- "Debug payment webhook"
+- "Update React components"`;
+
+const MAX_INPUT_CHARS = 2000;
+
+/**
+ * Find the best available model for title generation.
+ * Uses the configured smol model if set, otherwise auto-discovers using priority chain.
+ *
+ * @param registry Model registry
+ * @param savedSmolModel Optional saved smol model from settings (provider/modelId format)
+ */
+export async function findTitleModel(registry: ModelRegistry, savedSmolModel?: string): Promise<Model<any> | null> {
+	const model = await findSmolModel(registry, savedSmolModel);
+	return model ?? null;
+}
+
+/**
+ * Generate a title for a session based on the first user message.
+ *
+ * @param firstMessage The first user message
+ * @param registry Model registry
+ * @param savedSmolModel Optional saved smol model from settings (provider/modelId format)
+ */
+export async function generateSessionTitle(
+	firstMessage: string,
+	registry: ModelRegistry,
+	savedSmolModel?: string,
+): Promise<string | null> {
+	const model = await findTitleModel(registry, savedSmolModel);
+	if (!model) return null;
+
+	const apiKey = await registry.getApiKey(model);
+	if (!apiKey) return null;
+
+	// Truncate message if too long
+	const truncatedMessage =
+		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}...` : firstMessage;
+
+	try {
+		const response = await completeSimple(
+			model,
+			{
+				systemPrompt: TITLE_SYSTEM_PROMPT,
+				messages: [{ role: "user", content: truncatedMessage, timestamp: Date.now() }],
+			},
+			{
+				apiKey,
+				maxTokens: 30,
+			},
+		);
+
+		// Extract title from response text content
+		let title = "";
+		for (const content of response.content) {
+			if (content.type === "text") {
+				title += content.text;
+			}
+		}
+		title = title.trim();
+
+		if (!title || title.length > 60) {
+			return null;
+		}
+
+		// Clean up: remove quotes, trailing punctuation
+		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Set the terminal title using ANSI escape sequences.
+ */
+export function setTerminalTitle(title: string): void {
+	// OSC 2 sets the window title
+	process.stdout.write(`\x1b]2;${title}\x07`);
+}

package/src/core/tools/bash.ts

@@ -66,8 +66,7 @@ Usage notes:
     - If the commands are independent and can run in parallel, make multiple bash tool calls in a single message. For example, if you need to run "git status" and "git diff", send a single message with two bash tool calls in parallel.
     - If the commands depend on each other and must run sequentially, use a single bash call with '&&' to chain them together (e.g., \`git add . && git commit -m "message" && git push\`). For instance, if one operation must complete before another starts (like mkdir before cp, Write before Bash for git operations, or git add before git commit), run these operations sequentially instead.
     - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
-    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)
-  - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it.`,
+    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)`,
 		parameters: bashSchema,
 		execute: async (
 			_toolCallId: string,

package/src/core/tools/edit-diff.ts

@@ -271,7 +271,7 @@ export function formatEditMatchError(
 		? options.fuzzyMatches && options.fuzzyMatches > 1
 			? `Found ${options.fuzzyMatches} high-confidence matches. Provide more context to make it unique.`
 			: `Closest match was below the ${thresholdPercent}% similarity threshold.`
-		: "Hint: Use fuzzy=true to accept high-confidence matches.";
+		: "Fuzzy matching is disabled. Enable 'Edit fuzzy match' in settings to accept high-confidence matches.";
 
 	return [
 		options.allowFuzzy
@@ -409,7 +409,7 @@ export async function computeEditDiff(
 	oldText: string,
 	newText: string,
 	cwd: string,
-	fuzzy = false,
+	fuzzy = true,
 ): Promise<EditDiffResult | EditDiffError> {
 	const absolutePath = resolveToCwd(path, cwd);
 

package/src/core/tools/edit.ts

@@ -12,6 +12,7 @@ import {
 	restoreLineEndings,
 	stripBom,
 } from "./edit-diff.js";
+import type { FileDiagnosticsResult } from "./lsp/index.js";
 import { resolveToCwd } from "./path-utils.js";
 
 const editSchema = Type.Object({
@@ -27,9 +28,21 @@ export interface EditToolDetails {
 	diff: string;
 	/** Line number of the first change in the new file (for editor navigation) */
 	firstChangedLine?: number;
+	/** Whether LSP diagnostics were retrieved */
+	hasDiagnostics?: boolean;
+	/** Diagnostic result (if available) */
+	diagnostics?: FileDiagnosticsResult;
 }
 
-export function createEditTool(cwd: string): AgentTool<typeof editSchema> {
+export interface EditToolOptions {
+	/** Whether to accept high-confidence fuzzy matches for whitespace/indentation (default: true) */
+	fuzzyMatch?: boolean;
+	/** Callback to get LSP diagnostics after editing a file */
+	getDiagnostics?: (absolutePath: string) => Promise<FileDiagnosticsResult>;
+}
+
+export function createEditTool(cwd: string, options: EditToolOptions = {}): AgentTool<typeof editSchema> {
+	const allowFuzzy = options.fuzzyMatch ?? true;
 	return {
 		name: "edit",
 		label: "Edit",
@@ -108,7 +121,7 @@ Usage:
 						const normalizedNewText = normalizeToLF(newText);
 
 						const matchOutcome = findEditMatch(normalizedContent, normalizedOldText, {
-							allowFuzzy: true,
+							allowFuzzy,
 							similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
 						});
 
@@ -131,7 +144,7 @@ Usage:
 							reject(
 								new Error(
 									formatEditMatchError(path, normalizedOldText, matchOutcome.closest, {
-										allowFuzzy: true,
+										allowFuzzy,
 										similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
 										fuzzyMatches: matchOutcome.fuzzyMatches,
 									}),
@@ -179,14 +192,39 @@ Usage:
 						}
 
 						const diffResult = generateDiffString(normalizedContent, normalizedNewContent);
+
+						// Get LSP diagnostics if callback provided
+						let diagnosticsResult: FileDiagnosticsResult | undefined;
+						if (options.getDiagnostics) {
+							try {
+								diagnosticsResult = await options.getDiagnostics(absolutePath);
+							} catch {
+								// Ignore diagnostics errors - don't fail the edit
+							}
+						}
+
+						// Build result text
+						let resultText = `Successfully replaced text in ${path}.`;
+
+						// Append diagnostics if available and there are issues
+						if (diagnosticsResult?.available && diagnosticsResult.diagnostics.length > 0) {
+							resultText += `\n\nLSP Diagnostics (${diagnosticsResult.summary}):\n`;
+							resultText += diagnosticsResult.diagnostics.map((d) => `  ${d}`).join("\n");
+						}
+
 						resolve({
 							content: [
 								{
 									type: "text",
-									text: `Successfully replaced text in ${path}.`,
+									text: resultText,
 								},
 							],
-							details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine },
+							details: {
+								diff: diffResult.diff,
+								firstChangedLine: diffResult.firstChangedLine,
+								hasDiagnostics: diagnosticsResult?.available ?? false,
+								diagnostics: diagnosticsResult,
+							},
 						});
 					} catch (error: any) {
 						// Clean up abort handler

package/src/core/tools/grep.ts

@@ -68,10 +68,11 @@ export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
 
 Usage:
 - ALWAYS use grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a bash command. The grep tool has been optimized for correct permissions and access.
+- Searches recursively by default - no need for -r flag
 - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
-- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+- Filter files with glob parameter (e.g., "*.ts", "**/*.spec.ts") or type parameter (e.g., "ts", "py", "rust") - equivalent to grep's --include
 - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
-- Use task tool for open-ended searches requiring multiple rounds
+- Pagination: Use headLimit to limit results (like \`| head -N\`), offset to skip first N results
 - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
 - Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, use \`multiline: true\``,
 		parameters: grepSchema,

package/src/core/tools/index.ts

@@ -1,13 +1,25 @@
 export { type AskToolDetails, askTool, createAskTool } from "./ask.js";
 export { type BashToolDetails, bashTool, createBashTool } from "./bash.js";
-export { createEditTool, editTool } from "./edit.js";
+export { createEditTool, type EditToolOptions, editTool } from "./edit.js";
 // Exa MCP tools (22 tools)
 export { exaTools } from "./exa/index.js";
 export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types.js";
 export { createFindTool, type FindToolDetails, findTool } from "./find.js";
 export { createGrepTool, type GrepToolDetails, grepTool } from "./grep.js";
 export { createLsTool, type LsToolDetails, lsTool } from "./ls.js";
-export { createLspTool, type LspToolDetails, lspTool } from "./lsp/index.js";
+export {
+	createLspTool,
+	type FileDiagnosticsResult,
+	type FileFormatResult,
+	formatFile,
+	getDiagnosticsForFile,
+	getLspStatus,
+	type LspServerStatus,
+	type LspToolDetails,
+	type LspWarmupResult,
+	lspTool,
+	warmupLspServers,
+} from "./lsp/index.js";
 export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./notebook.js";
 export { createReadTool, type ReadToolDetails, readTool } from "./read.js";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index.js";
@@ -31,7 +43,7 @@ export {
 	webSearchLinkedinTool,
 	webSearchTool,
 } from "./web-search/index.js";
-export { createWriteTool, writeTool } from "./write.js";
+export { createWriteTool, type WriteToolDetails, type WriteToolOptions, writeTool } from "./write.js";
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { askTool, createAskTool } from "./ask.js";
@@ -41,7 +53,7 @@ import { createEditTool, editTool } from "./edit.js";
 import { createFindTool, findTool } from "./find.js";
 import { createGrepTool, grepTool } from "./grep.js";
 import { createLsTool, lsTool } from "./ls.js";
-import { createLspTool, lspTool } from "./lsp/index.js";
+import { createLspTool, formatFile, getDiagnosticsForFile, lspTool } from "./lsp/index.js";
 import { createNotebookTool, notebookTool } from "./notebook.js";
 import { createReadTool, readTool } from "./read.js";
 import { createTaskTool, taskTool } from "./task/index.js";
@@ -57,16 +69,47 @@ export interface SessionContext {
 	getSessionFile: () => string | null;
 }
 
+/** Options for creating coding tools */
+export interface CodingToolsOptions {
+	/** Whether to fetch LSP diagnostics after write tool writes files (default: true) */
+	lspDiagnosticsOnWrite?: boolean;
+	/** Whether to fetch LSP diagnostics after edit tool edits files (default: false) */
+	lspDiagnosticsOnEdit?: boolean;
+	/** Whether to format files using LSP after write tool writes (default: true) */
+	lspFormatOnWrite?: boolean;
+	/** Whether to accept high-confidence fuzzy matches in edit tool (default: true) */
+	editFuzzyMatch?: boolean;
+}
+
 // Factory function type
-type ToolFactory = (cwd: string, sessionContext?: SessionContext) => Tool;
+type ToolFactory = (cwd: string, sessionContext?: SessionContext, options?: CodingToolsOptions) => Tool;
 
 // Tool definitions: static tools and their factory functions
 const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
 	ask: { tool: askTool, create: createAskTool },
 	read: { tool: readTool, create: createReadTool },
 	bash: { tool: bashTool, create: createBashTool },
-	edit: { tool: editTool, create: createEditTool },
-	write: { tool: writeTool, create: createWriteTool },
+	edit: {
+		tool: editTool,
+		create: (cwd, _ctx, options) => {
+			const enableDiagnostics = options?.lspDiagnosticsOnEdit ?? false;
+			return createEditTool(cwd, {
+				fuzzyMatch: options?.editFuzzyMatch ?? true,
+				getDiagnostics: enableDiagnostics ? (absolutePath) => getDiagnosticsForFile(absolutePath, cwd) : undefined,
+			});
+		},
+	},
+	write: {
+		tool: writeTool,
+		create: (cwd, _ctx, options) => {
+			const enableFormat = options?.lspFormatOnWrite ?? true;
+			const enableDiagnostics = options?.lspDiagnosticsOnWrite ?? true;
+			return createWriteTool(cwd, {
+				formatOnWrite: enableFormat ? (absolutePath) => formatFile(absolutePath, cwd) : undefined,
+				getDiagnostics: enableDiagnostics ? (absolutePath) => getDiagnosticsForFile(absolutePath, cwd) : undefined,
+			});
+		},
+	},
 	grep: { tool: grepTool, create: createGrepTool },
 	find: { tool: findTool, create: createFindTool },
 	ls: { tool: lsTool, create: createLsTool },
@@ -116,10 +159,16 @@ export const allTools = Object.fromEntries(Object.entries(toolDefs).map(([name,
  * @param cwd - Working directory for tools
  * @param hasUI - Whether UI is available (includes ask tool if true)
  * @param sessionContext - Optional session context for tools that need it
+ * @param options - Options for tool configuration
  */
-export function createCodingTools(cwd: string, hasUI = false, sessionContext?: SessionContext): Tool[] {
+export function createCodingTools(
+	cwd: string,
+	hasUI = false,
+	sessionContext?: SessionContext,
+	options?: CodingToolsOptions,
+): Tool[] {
 	const names = hasUI ? [...baseCodingToolNames, ...uiToolNames] : baseCodingToolNames;
-	return names.map((name) => toolDefs[name].create(cwd, sessionContext));
+	return names.map((name) => toolDefs[name].create(cwd, sessionContext, options));
 }
 
 /**
@@ -127,20 +176,31 @@ export function createCodingTools(cwd: string, hasUI = false, sessionContext?: S
  * @param cwd - Working directory for tools
  * @param hasUI - Whether UI is available (includes ask tool if true)
  * @param sessionContext - Optional session context for tools that need it
+ * @param options - Options for tool configuration
  */
-export function createReadOnlyTools(cwd: string, hasUI = false, sessionContext?: SessionContext): Tool[] {
+export function createReadOnlyTools(
+	cwd: string,
+	hasUI = false,
+	sessionContext?: SessionContext,
+	options?: CodingToolsOptions,
+): Tool[] {
 	const names = hasUI ? [...baseReadOnlyToolNames, ...uiToolNames] : baseReadOnlyToolNames;
-	return names.map((name) => toolDefs[name].create(cwd, sessionContext));
+	return names.map((name) => toolDefs[name].create(cwd, sessionContext, options));
 }
 
 /**
  * Create all tools configured for a specific working directory.
  * @param cwd - Working directory for tools
  * @param sessionContext - Optional session context for tools that need it
+ * @param options - Options for tool configuration
  */
-export function createAllTools(cwd: string, sessionContext?: SessionContext): Record<ToolName, Tool> {
+export function createAllTools(
+	cwd: string,
+	sessionContext?: SessionContext,
+	options?: CodingToolsOptions,
+): Record<ToolName, Tool> {
 	return Object.fromEntries(
-		Object.entries(toolDefs).map(([name, def]) => [name, def.create(cwd, sessionContext)]),
+		Object.entries(toolDefs).map(([name, def]) => [name, def.create(cwd, sessionContext, options)]),
 	) as Record<ToolName, Tool>;
 }
 

package/src/core/tools/lsp/client.ts

@@ -17,20 +17,32 @@ import { detectLanguageId, fileToUri } from "./utils.js";
 
 const clients = new Map<string, LspClient>();
 
-// Idle timeout: shutdown clients after 5 minutes of inactivity
-const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+// Idle timeout configuration (disabled by default)
+let idleTimeoutMs: number | null = null;
+let idleCheckInterval: Timer | null = null;
 const IDLE_CHECK_INTERVAL_MS = 60 * 1000;
 
-// Background task to shutdown idle clients
-let idleCheckInterval: Timer | null = null;
+/**
+ * Configure the idle timeout for LSP clients.
+ * @param ms - Timeout in milliseconds, or null/undefined to disable
+ */
+export function setIdleTimeout(ms: number | null | undefined): void {
+	idleTimeoutMs = ms ?? null;
+
+	if (idleTimeoutMs && idleTimeoutMs > 0) {
+		startIdleChecker();
+	} else {
+		stopIdleChecker();
+	}
+}
 
 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 > IDLE_TIMEOUT_MS) {
-				console.log(`[LSP] Shutting down idle client: ${key}`);
+			if (now - client.lastActivity > idleTimeoutMs) {
 				shutdownClient(key);
 			}
 		}
@@ -98,6 +110,12 @@ const CLIENT_CAPABILITIES = {
 				properties: ["edit"],
 			},
 		},
+		formatting: {
+			dynamicRegistration: false,
+		},
+		rangeFormatting: {
+			dynamicRegistration: false,
+		},
 		publishDiagnostics: {
 			relatedInformation: true,
 			versionSupport: false,
@@ -357,7 +375,8 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string): Prom
 	}
 
 	const args = config.args ?? [];
-	const proc = Bun.spawn([config.command, ...args], {
+	const command = config.resolvedCommand ?? config.command;
+	const proc = Bun.spawn([command, ...args], {
 		cwd,
 		stdin: "pipe",
 		stdout: "pipe",
@@ -379,16 +398,9 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string): Prom
 	};
 	clients.set(key, client);
 
-	// Start idle checker if not already running
-	startIdleChecker();
-
 	// Register crash recovery - remove client on process exit
 	proc.exited.then(() => {
-		console.log(`[LSP] Process exited: ${key}`);
 		clients.delete(key);
-		if (clients.size === 0) {
-			stopIdleChecker();
-		}
 	});
 
 	// Start background message reader
@@ -497,10 +509,6 @@ export function shutdownClient(key: string): void {
 	// Kill process
 	client.process.kill();
 	clients.delete(key);
-
-	if (clients.size === 0) {
-		stopIdleChecker();
-	}
 }
 
 // =============================================================================
@@ -570,8 +578,6 @@ export async function sendNotification(client: LspClient, method: string, params
  * Shutdown all LSP clients.
  */
 export function shutdownAll(): void {
-	stopIdleChecker();
-
 	for (const client of Array.from(clients.values())) {
 		// Reject all pending requests
 		for (const pending of Array.from(client.pendingRequests.values())) {
@@ -587,6 +593,25 @@ export function shutdownAll(): void {
 	clients.clear();
 }
 
+/** Status of an LSP server */
+export interface LspServerStatus {
+	name: string;
+	status: "connecting" | "ready" | "error";
+	fileTypes: string[];
+	error?: string;
+}
+
+/**
+ * Get status of all active LSP clients.
+ */
+export function getActiveClients(): LspServerStatus[] {
+	return Array.from(clients.values()).map((client) => ({
+		name: client.config.command,
+		status: "ready" as const,
+		fileTypes: client.config.fileTypes,
+	}));
+}
+
 // =============================================================================
 // Process Cleanup
 // =============================================================================