my-pi 0.0.9 → 0.0.10

package/dist/{api-Dcq2JalY.js → api-7LVj6kUV.js}

@@ -3,7 +3,7 @@ import { cpSync, existsSync, globSync, mkdirSync, readFileSync, readdirSync, ren
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { Type } from "@sinclair/typebox";
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { Container, SettingsList, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { readFile } from "node:fs/promises";
@@ -824,6 +824,18 @@ ${task || "Continue from where the previous session left off."}
 }
 //#endregion
 //#region src/lsp/client.ts
+var LspClientStartError = class extends Error {
+	command;
+	args;
+	code;
+	constructor(message, options) {
+		super(message, options.cause ? { cause: options.cause } : void 0);
+		this.name = "LspClientStartError";
+		this.command = options.command;
+		this.args = options.args;
+		this.code = options.code;
+	}
+};
 var LspClient = class extends EventEmitter {
 	#proc = null;
 	#options;
@@ -833,6 +845,7 @@ var LspClient = class extends EventEmitter {
 	#initialized = false;
 	#open_docs = /* @__PURE__ */ new Map();
 	#diagnostics_by_uri = /* @__PURE__ */ new Map();
+	#diagnostic_waiters = /* @__PURE__ */ new Set();
 	constructor(options) {
 		super();
 		this.#options = options;
@@ -846,10 +859,29 @@ var LspClient = class extends EventEmitter {
 			],
 			env: process.env
 		});
+		let start_reject = null;
+		const start_failure = new Promise((_, reject) => {
+			start_reject = reject;
+		});
+		const reject_start = (error) => {
+			if (!start_reject) return false;
+			const reject = start_reject;
+			start_reject = null;
+			reject(error);
+			return true;
+		};
+		const start_error = (message, cause, code) => new LspClientStartError(message, {
+			command: this.#options.command,
+			args: this.#options.args,
+			cause,
+			code
+		});
 		this.#proc.on("error", (err) => {
-			this.emit("error", err);
+			const wrapped = start_error(`Failed to spawn ${this.#options.command}`, err, error_code(err));
+			if (!reject_start(wrapped)) this.#emit_error(wrapped);
 		});
 		this.#proc.on("close", () => {
+			if (!this.#initialized) reject_start(start_error(`LSP server ${this.#options.command} closed before initialization`));
 			for (const pending of this.#pending.values()) {
 				clearTimeout(pending.timer);
 				pending.reject(/* @__PURE__ */ new Error("LSP server closed"));
@@ -863,29 +895,35 @@ var LspClient = class extends EventEmitter {
 			this.#buffer = Buffer.concat([this.#buffer, chunk]);
 			this.#drain_buffer();
 		});
-		await this.#request("initialize", {
-			processId: process.pid,
-			rootUri: this.#options.root_uri,
-			capabilities: {
-				textDocument: {
-					publishDiagnostics: { relatedInformation: true },
-					hover: { contentFormat: ["markdown", "plaintext"] },
-					definition: { linkSupport: false },
-					references: {},
-					documentSymbol: { hierarchicalDocumentSymbolSupport: true }
+		try {
+			await Promise.race([this.#request("initialize", {
+				processId: process.pid,
+				rootUri: this.#options.root_uri,
+				capabilities: {
+					textDocument: {
+						publishDiagnostics: { relatedInformation: true },
+						hover: { contentFormat: ["markdown", "plaintext"] },
+						definition: { linkSupport: false },
+						references: {},
+						documentSymbol: { hierarchicalDocumentSymbolSupport: true }
+					},
+					workspace: {
+						workspaceFolders: true,
+						symbol: {}
+					}
 				},
-				workspace: {
-					workspaceFolders: true,
-					symbol: {}
-				}
-			},
-			workspaceFolders: [{
-				uri: this.#options.root_uri,
-				name: "workspace"
-			}]
-		});
-		this.#notify("initialized", {});
-		this.#initialized = true;
+				workspaceFolders: [{
+					uri: this.#options.root_uri,
+					name: "workspace"
+				}]
+			}), start_failure]);
+			this.#notify("initialized", {});
+			this.#initialized = true;
+			start_reject = null;
+		} catch (error) {
+			await this.stop();
+			throw error;
+		}
 	}
 	is_ready() {
 		return this.#initialized;
@@ -945,23 +983,25 @@ var LspClient = class extends EventEmitter {
 	get_diagnostics(uri) {
 		return this.#diagnostics_by_uri.get(uri) ?? [];
 	}
-	get_all_diagnostics() {
-		return new Map(this.#diagnostics_by_uri);
-	}
 	async wait_for_diagnostics(uri, timeout_ms = 1500) {
 		if (this.#diagnostics_by_uri.has(uri)) return this.get_diagnostics(uri);
 		return new Promise((resolve) => {
-			const handler = (event_uri) => {
-				if (event_uri !== uri) return;
+			let active = true;
+			const cleanup = () => {
+				if (!active) return;
+				active = false;
 				this.off("diagnostics", handler);
 				clearTimeout(timer);
+				this.#diagnostic_waiters.delete(cleanup);
 				resolve(this.get_diagnostics(uri));
 			};
-			const timer = setTimeout(() => {
-				this.off("diagnostics", handler);
-				resolve(this.get_diagnostics(uri));
-			}, timeout_ms);
+			const handler = (event_uri) => {
+				if (event_uri !== uri) return;
+				cleanup();
+			};
+			const timer = setTimeout(cleanup, timeout_ms);
 			this.on("diagnostics", handler);
+			this.#diagnostic_waiters.add(cleanup);
 		});
 	}
 	async stop() {
@@ -974,6 +1014,7 @@ var LspClient = class extends EventEmitter {
 			pending.reject(/* @__PURE__ */ new Error("LSP client stopped"));
 		}
 		this.#pending.clear();
+		for (const cleanup of Array.from(this.#diagnostic_waiters)) cleanup();
 		if (this.#proc) {
 			this.#proc.kill();
 			this.#proc = null;
@@ -1022,6 +1063,9 @@ var LspClient = class extends EventEmitter {
 		const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "ascii");
 		this.#proc.stdin.write(Buffer.concat([header, body]));
 	}
+	#emit_error(error) {
+		if (this.listenerCount("error") > 0) this.emit("error", error);
+	}
 	#drain_buffer() {
 		while (true) {
 			const header_end = this.#buffer.indexOf("\r\n\r\n");
@@ -1039,14 +1083,15 @@ var LspClient = class extends EventEmitter {
 			try {
 				this.#handle_message(JSON.parse(body.toString("utf8")));
 			} catch (error) {
-				this.emit("error", error);
+				this.#emit_error(error);
 			}
 		}
 	}
 	#handle_message(message) {
-		if (message.id != null && this.#pending.has(Number(message.id))) {
-			const pending = this.#pending.get(Number(message.id));
-			this.#pending.delete(Number(message.id));
+		const numeric_id = typeof message.id === "number" ? message.id : typeof message.id === "string" && /^-?\d+$/.test(message.id) ? Number(message.id) : null;
+		if (numeric_id != null && this.#pending.has(numeric_id)) {
+			const pending = this.#pending.get(numeric_id);
+			this.#pending.delete(numeric_id);
 			clearTimeout(pending.timer);
 			if (message.error) pending.reject(/* @__PURE__ */ new Error(`LSP error ${message.error.code}: ${message.error.message}`));
 			else pending.resolve(message.result);
@@ -1090,6 +1135,9 @@ function normalize_document_symbol_result(result) {
 function file_path_to_uri(file_path) {
 	return pathToFileURL(file_path).href;
 }
+function error_code(error) {
+	return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
 //#endregion
 //#region src/lsp/servers.ts
 const EXTENSION_LANGUAGES = {
@@ -1113,44 +1161,74 @@ const LANGUAGE_SERVERS = {
 	typescript: {
 		language: "typescript",
 		command: "typescript-language-server",
-		args: ["--stdio"]
+		args: ["--stdio"],
+		install_hint: "Install TypeScript LSP with: pnpm add -D typescript typescript-language-server"
 	},
 	python: {
 		language: "python",
 		command: "pylsp",
-		args: []
+		args: [],
+		install_hint: "Install Python LSP with: pip install python-lsp-server"
 	},
 	rust: {
 		language: "rust",
 		command: "rust-analyzer",
-		args: []
+		args: [],
+		install_hint: "Install Rust Analyzer and ensure the rust-analyzer binary is on PATH."
 	},
 	go: {
 		language: "go",
 		command: "gopls",
-		args: ["serve"]
+		args: ["serve"],
+		install_hint: "Install Go LSP with: go install golang.org/x/tools/gopls@latest"
 	},
 	ruby: {
 		language: "ruby",
 		command: "solargraph",
-		args: ["stdio"]
+		args: ["stdio"],
+		install_hint: "Install Ruby LSP with: gem install solargraph"
 	},
 	java: {
 		language: "java",
 		command: "jdtls",
-		args: []
+		args: [],
+		install_hint: "Install Eclipse JDT Language Server and ensure the jdtls binary is on PATH."
 	},
 	lua: {
 		language: "lua",
 		command: "lua-language-server",
-		args: []
+		args: [],
+		install_hint: "Install Lua LSP and ensure the lua-language-server binary is on PATH."
 	},
 	svelte: {
 		language: "svelte",
 		command: "svelteserver",
-		args: ["--stdio"]
+		args: ["--stdio"],
+		install_hint: "Install Svelte LSP with: pnpm add -D svelte-language-server (or volta install svelte-language-server)"
 	}
 };
+const WORKSPACE_MARKERS = [
+	"svelte.config.js",
+	"svelte.config.ts",
+	"tsconfig.json",
+	"jsconfig.json",
+	"package.json",
+	"pyproject.toml",
+	"Cargo.toml",
+	"go.mod",
+	"Gemfile",
+	"pom.xml",
+	"build.gradle",
+	"build.gradle.kts"
+];
+const REPOSITORY_MARKERS = [
+	"pnpm-workspace.yaml",
+	"package-lock.json",
+	"yarn.lock",
+	"bun.lockb",
+	"bun.lock",
+	".git"
+];
 function detect_language(file_path) {
 	return EXTENSION_LANGUAGES[extname(file_path).toLowerCase()];
 }
@@ -1177,6 +1255,17 @@ function get_server_config(language, cwd = process.cwd()) {
 function language_id_for_file(file_path) {
 	return detect_language(file_path);
 }
+function find_workspace_root(file_path, fallback = process.cwd()) {
+	const start = resolve(dirname(file_path));
+	const project_root = find_nearest_marker_directory(start, WORKSPACE_MARKERS);
+	if (project_root) return project_root;
+	const repo_root = find_nearest_marker_directory(start, REPOSITORY_MARKERS);
+	if (repo_root) return repo_root;
+	return resolve(fallback);
+}
+function find_nearest_marker_directory(start, markers) {
+	for (const dir of ancestor_directories(start)) if (markers.some((marker) => existsSync(join(dir, marker)))) return dir;
+}
 function ancestor_directories(start) {
 	const dirs = [];
 	let current = resolve(start);
@@ -1193,60 +1282,129 @@ function resolve_local_binary(directory, command) {
 }
 //#endregion
 //#region src/extensions/lsp.ts
+var LspToolError = class extends Error {
+	details;
+	constructor(details) {
+		super(details.message);
+		this.name = "LspToolError";
+		this.details = details;
+	}
+};
+var LspStartupCancelledError = class extends Error {
+	constructor(language, workspace_root) {
+		super(`Startup cancelled for ${language} LSP in ${workspace_root}`);
+		this.name = "LspStartupCancelledError";
+	}
+};
+const SYMBOL_KIND_LABELS = {
+	2: "module",
+	3: "namespace",
+	5: "class",
+	6: "method",
+	7: "property",
+	8: "field",
+	9: "constructor",
+	11: "interface",
+	12: "function",
+	13: "variable",
+	14: "constant",
+	23: "struct",
+	24: "event"
+};
+const SYMBOL_KIND_NAMES = Object.values(SYMBOL_KIND_LABELS);
+const SYMBOL_KIND_SCHEMA = Type.Union(SYMBOL_KIND_NAMES.map((name) => Type.Literal(name)));
 function create_lsp_extension(options = {}) {
 	const create_client = options.create_client ?? ((client_options) => new LspClient(client_options));
 	const read_file = options.read_file ?? ((path) => readFile(path, "utf-8"));
 	return async function lsp(pi) {
 		const cwd = options.cwd?.() ?? process.cwd();
-		const root_uri = file_path_to_uri(cwd);
-		const clients_by_language = /* @__PURE__ */ new Map();
-		const failed_languages = /* @__PURE__ */ new Map();
+		const clients_by_server = /* @__PURE__ */ new Map();
+		const failed_servers = /* @__PURE__ */ new Map();
+		const starting_servers = /* @__PURE__ */ new Map();
 		const resolve_abs = (file) => isAbsolute(file) ? file : resolve(cwd, file);
+		const server_key = (language, workspace_root) => `${language}\u0000${workspace_root}`;
+		const make_tool_result = (text, details = {}) => ({
+			content: [{
+				type: "text",
+				text
+			}],
+			details
+		});
+		const make_tool_error = (details) => make_tool_result(format_tool_error(details), {
+			ok: false,
+			error: details
+		});
 		const clear_language_state = async (language) => {
-			if (language) {
-				const state = clients_by_language.get(language);
-				if (state) {
-					await state.client.stop();
-					clients_by_language.delete(language);
-				}
-				failed_languages.delete(language);
+			const states = language ? Array.from(clients_by_server.entries()).filter(([, state]) => state.language === language) : Array.from(clients_by_server.entries());
+			const starting = language ? Array.from(starting_servers.entries()).filter(([key]) => key.startsWith(`${language}\u0000`)) : Array.from(starting_servers.entries());
+			for (const [key, startup] of starting) {
+				startup.cancelled = true;
+				starting_servers.delete(key);
+			}
+			await Promise.allSettled(states.map(([, state]) => state.client.stop()));
+			for (const [key] of states) clients_by_server.delete(key);
+			if (!language) {
+				failed_servers.clear();
 				return;
 			}
-			await Promise.allSettled(Array.from(clients_by_language.values()).map((state) => state.client.stop()));
-			clients_by_language.clear();
-			failed_languages.clear();
+			for (const [key, failure] of failed_servers.entries()) if (failure.language === language) failed_servers.delete(key);
 		};
 		const get_or_start_client = async (file_path) => {
 			const language = detect_language(file_path);
 			if (!language) return void 0;
-			const existing = clients_by_language.get(language);
+			const workspace_root = find_workspace_root(file_path, cwd);
+			const key = server_key(language, workspace_root);
+			const existing = clients_by_server.get(key);
 			if (existing) return existing;
-			if (failed_languages.has(language)) throw new Error(failed_languages.get(language));
-			const server_config = get_server_config(language, cwd);
+			const failed = failed_servers.get(key);
+			if (failed) throw new LspToolError(failed);
+			const in_flight = starting_servers.get(key);
+			if (in_flight) return in_flight.promise;
+			const server_config = get_server_config(language, workspace_root);
 			if (!server_config) return void 0;
-			const client = create_client({
-				command: server_config.command,
-				args: server_config.args,
-				root_uri,
-				language_id_for_uri: (uri) => language_id_for_file(uri)
-			});
+			const root_uri = file_path_to_uri(workspace_root);
+			const startup = {
+				cancelled: false,
+				promise: Promise.resolve(void 0)
+			};
+			const start_promise = (async () => {
+				const client = create_client({
+					command: server_config.command,
+					args: server_config.args,
+					root_uri,
+					language_id_for_uri: (uri) => language_id_for_file(uri)
+				});
+				try {
+					await client.start();
+				} catch (error) {
+					if (startup.cancelled) throw new LspStartupCancelledError(language, workspace_root);
+					const failure = to_lsp_tool_error(file_path, language, workspace_root, server_config.command, server_config.install_hint, error);
+					failed_servers.set(key, failure);
+					throw new LspToolError(failure);
+				}
+				if (startup.cancelled) {
+					await Promise.allSettled([client.stop()]);
+					throw new LspStartupCancelledError(language, workspace_root);
+				}
+				const state = {
+					client,
+					language,
+					workspace_root,
+					root_uri,
+					command: server_config.command,
+					install_hint: server_config.install_hint
+				};
+				clients_by_server.set(key, state);
+				failed_servers.delete(key);
+				return state;
+			})();
+			startup.promise = start_promise;
+			starting_servers.set(key, startup);
 			try {
-				await client.start();
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				const failure = `Failed to start ${server_config.command} for ${language}: ${message}. Install the language server and ensure it is available.`;
-				failed_languages.set(language, failure);
-				throw new Error(failure);
+				return await start_promise;
+			} finally {
+				if (starting_servers.get(key) === startup) starting_servers.delete(key);
 			}
-			const state = {
-				client,
-				language,
-				root_uri,
-				command: server_config.command
-			};
-			clients_by_language.set(language, state);
-			failed_languages.delete(language);
-			return state;
 		};
 		const open_file = async (state, abs_path) => {
 			const text = await read_file(abs_path);
@@ -1264,6 +1422,52 @@ function create_lsp_extension(options = {}) {
 				state
 			};
 		};
+		const resolve_file_state = async (file) => {
+			const abs = resolve_abs(file);
+			try {
+				const result = await get_file_state(abs);
+				if (!result) return {
+					ok: false,
+					error: {
+						kind: "unsupported_language",
+						file: abs,
+						message: `No language server configured for ${abs}`
+					}
+				};
+				return {
+					ok: true,
+					result
+				};
+			} catch (error) {
+				if (error instanceof LspToolError) return {
+					ok: false,
+					error: error.details
+				};
+				return {
+					ok: false,
+					error: {
+						kind: "tool_execution_failed",
+						file: abs,
+						message: error instanceof Error ? error.message : String(error)
+					}
+				};
+			}
+		};
+		const with_file_state = async (file, run) => {
+			const resolved = await resolve_file_state(file);
+			if (!resolved.ok) return make_tool_error(resolved.error);
+			const { result } = resolved;
+			try {
+				return make_tool_result(await run(result), {
+					ok: true,
+					language: result.state.language,
+					command: result.state.command,
+					workspace_root: result.state.workspace_root
+				});
+			} catch (error) {
+				return make_tool_error(to_lsp_tool_error(result.abs, result.state.language, result.state.workspace_root, result.state.command, result.state.install_hint, error));
+			}
+		};
 		pi.registerTool(defineTool({
 			name: "lsp_diagnostics",
 			label: "LSP: diagnostics",
@@ -1272,25 +1476,86 @@ function create_lsp_extension(options = {}) {
 				file: Type.String({ description: "Path to the file to check (relative to cwd or absolute)." }),
 				wait_ms: Type.Optional(Type.Number({ description: "Max ms to wait for diagnostics after opening the file. Default 1500." }))
 			}),
-			execute: async (_id, params) => {
-				const result = await get_file_state(params.file);
-				if (!result) return {
-					content: [{
-						type: "text",
-						text: `No language server configured for ${resolve_abs(params.file)}`
-					}],
-					details: {}
-				};
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
 				const diagnostics = await result.state.client.wait_for_diagnostics(result.uri, params.wait_ms ?? 1500);
-				return {
-					content: [{
-						type: "text",
-						text: format_diagnostics(result.abs, diagnostics)
-					}],
-					details: {}
-				};
+				return format_diagnostics(result.abs, diagnostics);
+			})
+		}));
+		pi.registerTool(defineTool({
+			name: "lsp_diagnostics_many",
+			label: "LSP: diagnostics many",
+			description: "Get language server diagnostics for multiple files in one call. Useful for package-level sweeps and summarization.",
+			parameters: Type.Object({
+				files: Type.Array(Type.String(), {
+					minItems: 1,
+					maxItems: 100,
+					description: "Files to check (relative to cwd or absolute)."
+				}),
+				wait_ms: Type.Optional(Type.Number({ description: "Max ms to wait for diagnostics after opening each file. Default 1500." }))
+			}),
+			execute: async (_id, params) => {
+				const results = await Promise.all(params.files.map((file) => resolve_file_state(file)));
+				const wait_ms = params.wait_ms ?? 1500;
+				const lines_with_stats = await Promise.all(results.map(async (resolved) => {
+					if (!resolved.ok) return {
+						line: format_tool_error(resolved.error),
+						diagnostics: 0,
+						error: true
+					};
+					const diagnostics = await resolved.result.state.client.wait_for_diagnostics(resolved.result.uri, wait_ms);
+					return {
+						line: format_diagnostics(resolved.result.abs, diagnostics),
+						diagnostics: diagnostics.length,
+						error: false
+					};
+				}));
+				let diagnostic_count = 0;
+				let clean_count = 0;
+				let error_count = 0;
+				const lines = [];
+				for (const entry of lines_with_stats) {
+					lines.push(entry.line);
+					if (entry.error) error_count += 1;
+					else {
+						diagnostic_count += entry.diagnostics;
+						if (entry.diagnostics === 0) clean_count += 1;
+					}
+				}
+				return make_tool_result([`Checked ${params.files.length} file(s): ${diagnostic_count} diagnostic(s), ${clean_count} clean, ${error_count} error(s)`, ...lines].join("\n\n"), {
+					ok: error_count === 0,
+					checked: params.files.length,
+					diagnostic_count,
+					clean_count,
+					error_count
+				});
 			}
 		}));
+		pi.registerTool(defineTool({
+			name: "lsp_find_symbol",
+			label: "LSP: find symbol",
+			description: "Find symbols in a file by name or detail text using document symbols. Supports exact matching, kind filters, and top-level-only mode.",
+			parameters: Type.Object({
+				file: Type.String(),
+				query: Type.String({ description: "Substring to match against symbol names/details." }),
+				max_results: Type.Optional(Type.Number({ description: "Max number of matches to return. Default 20." })),
+				top_level_only: Type.Optional(Type.Boolean({ description: "Only match top-level symbols. Default false." })),
+				exact_match: Type.Optional(Type.Boolean({ description: "Match whole symbol names/details exactly instead of substring matching. Default false." })),
+				kinds: Type.Optional(Type.Array(SYMBOL_KIND_SCHEMA, {
+					minItems: 1,
+					maxItems: SYMBOL_KIND_NAMES.length,
+					description: "Restrict matches to these symbol kinds."
+				}))
+			}),
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				const matches = find_symbol_matches(await result.state.client.document_symbols(result.uri), params.query, {
+					max_results: params.max_results ?? 20,
+					top_level_only: params.top_level_only ?? false,
+					exact_match: params.exact_match ?? false,
+					kinds: new Set(params.kinds ?? [])
+				});
+				return format_symbol_matches(result.abs, params.query, matches);
+			})
+		}));
 		pi.registerTool(defineTool({
 			name: "lsp_hover",
 			label: "LSP: hover",
@@ -1300,26 +1565,12 @@ function create_lsp_extension(options = {}) {
 				line: Type.Number({ description: "Zero-based line number." }),
 				character: Type.Number({ description: "Zero-based character offset." })
 			}),
-			execute: async (_id, params) => {
-				const result = await get_file_state(params.file);
-				if (!result) return {
-					content: [{
-						type: "text",
-						text: `No language server configured for ${resolve_abs(params.file)}`
-					}],
-					details: {}
-				};
-				return {
-					content: [{
-						type: "text",
-						text: format_hover(await result.state.client.hover(result.uri, {
-							line: params.line,
-							character: params.character
-						}))
-					}],
-					details: {}
-				};
-			}
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				return format_hover(await result.state.client.hover(result.uri, {
+					line: params.line,
+					character: params.character
+				}));
+			})
 		}));
 		pi.registerTool(defineTool({
 			name: "lsp_definition",
@@ -1330,26 +1581,12 @@ function create_lsp_extension(options = {}) {
 				line: Type.Number(),
 				character: Type.Number()
 			}),
-			execute: async (_id, params) => {
-				const result = await get_file_state(params.file);
-				if (!result) return {
-					content: [{
-						type: "text",
-						text: `No language server configured for ${resolve_abs(params.file)}`
-					}],
-					details: {}
-				};
-				return {
-					content: [{
-						type: "text",
-						text: format_locations(await result.state.client.definition(result.uri, {
-							line: params.line,
-							character: params.character
-						}), "No definition found.")
-					}],
-					details: {}
-				};
-			}
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				return format_locations(await result.state.client.definition(result.uri, {
+					line: params.line,
+					character: params.character
+				}), "No definition found.");
+			})
 		}));
 		pi.registerTool(defineTool({
 			name: "lsp_references",
@@ -1361,50 +1598,22 @@ function create_lsp_extension(options = {}) {
 				character: Type.Number(),
 				include_declaration: Type.Optional(Type.Boolean())
 			}),
-			execute: async (_id, params) => {
-				const result = await get_file_state(params.file);
-				if (!result) return {
-					content: [{
-						type: "text",
-						text: `No language server configured for ${resolve_abs(params.file)}`
-					}],
-					details: {}
-				};
-				return {
-					content: [{
-						type: "text",
-						text: format_locations(await result.state.client.references(result.uri, {
-							line: params.line,
-							character: params.character
-						}, params.include_declaration ?? true), "No references found.")
-					}],
-					details: {}
-				};
-			}
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
+				return format_locations(await result.state.client.references(result.uri, {
+					line: params.line,
+					character: params.character
+				}, params.include_declaration ?? true), "No references found.");
+			})
 		}));
 		pi.registerTool(defineTool({
 			name: "lsp_document_symbols",
 			label: "LSP: document symbols",
 			description: "List symbols in a file (functions, classes, variables) using the language server.",
 			parameters: Type.Object({ file: Type.String() }),
-			execute: async (_id, params) => {
-				const result = await get_file_state(params.file);
-				if (!result) return {
-					content: [{
-						type: "text",
-						text: `No language server configured for ${resolve_abs(params.file)}`
-					}],
-					details: {}
-				};
+			execute: async (_id, params) => with_file_state(params.file, async (result) => {
 				const symbols = await result.state.client.document_symbols(result.uri);
-				return {
-					content: [{
-						type: "text",
-						text: format_document_symbols(result.abs, symbols)
-					}],
-					details: {}
-				};
-			}
+				return format_document_symbols(result.abs, symbols);
+			})
 		}));
 		pi.registerCommand("lsp", {
 			description: "Show or manage language server state",
@@ -1433,7 +1642,7 @@ function create_lsp_extension(options = {}) {
 				return null;
 			},
 			handler: async (args, ctx) => {
-				await handle_lsp_command(args, ctx, cwd, clients_by_language, failed_languages, clear_language_state);
+				await handle_lsp_command(args, ctx, cwd, clients_by_server, failed_servers, clear_language_state);
 			}
 		});
 		pi.on("session_shutdown", async () => {
@@ -1442,12 +1651,12 @@ function create_lsp_extension(options = {}) {
 	};
 }
 var lsp_default = create_lsp_extension();
-async function handle_lsp_command(args, ctx, cwd, clients_by_language, failed_languages, clear_language_state) {
+async function handle_lsp_command(args, ctx, cwd, clients_by_server, failed_servers, clear_language_state) {
 	const [subcommand = "status", target] = args.trim() ? args.trim().split(/\s+/, 2) : [];
 	switch (subcommand) {
 		case "status":
 		case "list":
-			ctx.ui.notify(format_status_lines(cwd, clients_by_language, failed_languages).join("\n"));
+			ctx.ui.notify(format_status_lines(cwd, clients_by_server, failed_servers).join("\n"));
 			return;
 		case "restart":
 			if (!target || target === "all") {
@@ -1465,24 +1674,62 @@ async function handle_lsp_command(args, ctx, cwd, clients_by_language, failed_la
 		default: ctx.ui.notify(`Unknown subcommand: ${subcommand}. Use: status, list, restart`, "warning");
 	}
 }
-function format_status_lines(cwd, clients_by_language, failed_languages) {
+function format_status_lines(cwd, clients_by_server, failed_servers) {
 	const lines = [];
+	const active_languages = /* @__PURE__ */ new Set();
+	const running_states = Array.from(clients_by_server.values()).sort((a, b) => a.language.localeCompare(b.language) || a.workspace_root.localeCompare(b.workspace_root));
+	for (const running of running_states) {
+		active_languages.add(running.language);
+		lines.push(`${running.language}: running (ready=${running.client.is_ready()}) — ${running.command} [workspace ${running.workspace_root}]`);
+	}
+	const failures = Array.from(failed_servers.values()).sort((a, b) => (a.language ?? "").localeCompare(b.language ?? "") || (a.workspace_root ?? "").localeCompare(b.workspace_root ?? ""));
+	for (const failure of failures) {
+		if (failure.language) active_languages.add(failure.language);
+		const workspace = failure.workspace_root ? ` [workspace ${failure.workspace_root}]` : "";
+		const language = failure.language ?? "unknown";
+		lines.push(`${language}: failed — ${failure.message}${workspace}`);
+	}
 	for (const language of list_supported_languages()) {
-		const running = clients_by_language.get(language);
-		if (running) {
-			lines.push(`${language}: running (ready=${running.client.is_ready()}) — ${running.command}`);
-			continue;
-		}
-		const failed = failed_languages.get(language);
-		if (failed) {
-			lines.push(`${language}: failed — ${failed}`);
-			continue;
-		}
+		if (active_languages.has(language)) continue;
 		const config = get_server_config(language, cwd);
 		if (config) lines.push(`${language}: idle — ${config.command}`);
 	}
 	return lines.length > 0 ? lines : ["No language servers configured for this project."];
 }
+function to_lsp_tool_error(file, language, workspace_root, command, install_hint, error) {
+	if (error instanceof LspToolError) return error.details;
+	if (error instanceof LspClientStartError) {
+		const missing_binary = error.code === "ENOENT";
+		return {
+			kind: "server_start_failed",
+			file,
+			language,
+			workspace_root,
+			command,
+			install_hint,
+			code: error.code,
+			message: missing_binary ? `command "${command}" not found` : error.message
+		};
+	}
+	return {
+		kind: "tool_execution_failed",
+		file,
+		language,
+		workspace_root,
+		command,
+		install_hint,
+		message: error instanceof Error ? error.message : String(error),
+		code: typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0
+	};
+}
+function format_tool_error(details) {
+	if (details.kind === "unsupported_language") return details.message;
+	const lines = [details.language ? `${details.language} LSP unavailable for ${details.file}` : `LSP request failed for ${details.file}`, `Reason: ${details.message}`];
+	if (details.command) lines.push(`Command: ${details.command}`);
+	if (details.workspace_root) lines.push(`Workspace: ${details.workspace_root}`);
+	if (details.install_hint) lines.push(`Hint: ${details.install_hint}`);
+	return lines.join("\n");
+}
 function severity_label(severity) {
 	switch (severity) {
 		case 1: return "error";
@@ -1522,6 +1769,47 @@ function format_document_symbols(file, symbols) {
 	append_symbol_lines(lines, symbols, 1);
 	return lines.join("\n");
 }
+function find_symbol_matches(symbols, query, options) {
+	const normalized = query.trim().toLowerCase();
+	if (!normalized) return [];
+	const matches = [];
+	const matches_query = (symbol) => {
+		const values = [symbol.name, symbol.detail ?? ""].map((value) => value.trim().toLowerCase());
+		return options.exact_match ? values.some((value) => value === normalized) : values.some((value) => value.includes(normalized));
+	};
+	const matches_kind = (symbol) => {
+		if (options.kinds.size === 0) return true;
+		return options.kinds.has(symbol_kind_label(symbol.kind));
+	};
+	const visit = (entries, depth) => {
+		for (const symbol of entries) {
+			if (matches_kind(symbol) && matches_query(symbol)) {
+				matches.push({
+					symbol,
+					depth
+				});
+				if (matches.length >= options.max_results) return;
+			}
+			if (!options.top_level_only && symbol.children?.length) {
+				visit(symbol.children, depth + 1);
+				if (matches.length >= options.max_results) return;
+			}
+		}
+	};
+	visit(symbols, 1);
+	return matches;
+}
+function format_symbol_matches(file, query, matches) {
+	if (matches.length === 0) return `${file}: no symbols matching "${query}"`;
+	const lines = [`${file}: ${matches.length} symbol match(es) for "${query}"`];
+	for (const { symbol, depth } of matches) {
+		const indent = "  ".repeat(depth);
+		const detail = symbol.detail ? ` — ${symbol.detail}` : "";
+		const range = `${symbol.range.start.line + 1}:${symbol.range.start.character + 1}`;
+		lines.push(`${indent}${symbol_kind_label(symbol.kind)} ${symbol.name}${detail} @ ${range}`);
+	}
+	return lines.join("\n");
+}
 function append_symbol_lines(lines, symbols, depth) {
 	for (const symbol of symbols) {
 		const indent = "  ".repeat(depth);
@@ -1532,21 +1820,7 @@ function append_symbol_lines(lines, symbols, depth) {
 	}
 }
 function symbol_kind_label(kind) {
-	return {
-		2: "module",
-		3: "namespace",
-		5: "class",
-		6: "method",
-		7: "property",
-		8: "field",
-		9: "constructor",
-		11: "interface",
-		12: "function",
-		13: "variable",
-		14: "constant",
-		23: "struct",
-		24: "event"
-	}[kind] ?? "symbol";
+	return SYMBOL_KIND_LABELS[kind] ?? "symbol";
 }
 function file_url_to_path_or_value(uri) {
 	try {
@@ -1817,56 +2091,93 @@ function load_mcp_config(cwd) {
 }
 //#endregion
 //#region src/extensions/mcp.ts
+function remove_server_tools_from_active(pi, tool_names) {
+	const tool_set = new Set(tool_names);
+	pi.setActiveTools(pi.getActiveTools().filter((tool) => !tool_set.has(tool)));
+}
+function format_server_status(state) {
+	switch (state.status) {
+		case "connected": return state.enabled ? "enabled" : "disabled";
+		case "connecting": return state.enabled ? "connecting" : "connecting, disabled";
+		case "failed": return state.enabled ? "failed" : "failed, disabled";
+		default: return state.enabled ? "not connected yet" : "disabled";
+	}
+}
 async function mcp(pi) {
-	const cwd = process.cwd();
-	const servers = /* @__PURE__ */ new Map();
-	const configs = load_mcp_config(cwd);
-	const results = await Promise.allSettled(configs.map(async (config) => {
-		const client = new McpClient(config);
-		await client.connect();
-		return {
-			config,
-			client,
-			mcp_tools: await client.listTools()
-		};
-	}));
-	for (const result of results) {
-		if (result.status === "rejected") {
-			console.error(`MCP server failed: ${result.reason}`);
-			continue;
+	const configs = load_mcp_config(process.cwd());
+	const servers = new Map(configs.map((config) => [config.name, {
+		config,
+		tool_names: [],
+		enabled: true,
+		status: "disconnected"
+	}]));
+	const registered_tool_names = /* @__PURE__ */ new Set();
+	const connect_server = async (state) => {
+		if (state.status === "connected") return;
+		if (state.connect_promise) {
+			await state.connect_promise;
+			return;
 		}
-		const { config, client, mcp_tools } = result.value;
-		const tool_names = [];
-		for (const mcp_tool of mcp_tools) {
-			const tool_name = `mcp__${config.name}__${mcp_tool.name}`;
-			tool_names.push(tool_name);
-			pi.registerTool(defineTool({
-				name: tool_name,
-				label: `${config.name}: ${mcp_tool.name}`,
-				description: mcp_tool.description || mcp_tool.name,
-				parameters: mcp_tool.inputSchema || {
-					type: "object",
-					properties: {}
-				},
-				execute: async (_id, params) => {
-					const result = await client.callTool(mcp_tool.name, params);
-					return {
-						content: [{
-							type: "text",
-							text: result?.content?.map((c) => c.text || "").join("\n") || JSON.stringify(result)
-						}],
-						details: {}
-					};
+		state.connect_promise = (async () => {
+			state.status = "connecting";
+			state.error = void 0;
+			const client = new McpClient(state.config);
+			try {
+				await client.connect();
+				state.client = client;
+				const mcp_tools = await client.listTools();
+				const tool_names = [];
+				for (const mcp_tool of mcp_tools) {
+					const tool_name = `mcp__${state.config.name}__${mcp_tool.name}`;
+					tool_names.push(tool_name);
+					if (registered_tool_names.has(tool_name)) continue;
+					registered_tool_names.add(tool_name);
+					pi.registerTool(defineTool({
+						name: tool_name,
+						label: `${state.config.name}: ${mcp_tool.name}`,
+						description: mcp_tool.description || mcp_tool.name,
+						parameters: mcp_tool.inputSchema || {
+							type: "object",
+							properties: {}
+						},
+						execute: async (_id, params) => {
+							const result = await state.client.callTool(mcp_tool.name, params);
+							return {
+								content: [{
+									type: "text",
+									text: result?.content?.map((c) => c.text || "").join("\n") || JSON.stringify(result)
+								}],
+								details: {}
+							};
+						}
+					}));
 				}
-			}));
-		}
-		servers.set(config.name, {
-			config,
-			client,
-			tool_names,
-			enabled: true
-		});
-	}
+				state.tool_names = tool_names;
+				state.status = "connected";
+				if (!state.enabled) remove_server_tools_from_active(pi, state.tool_names);
+			} catch (error) {
+				state.status = "failed";
+				state.error = error instanceof Error ? error.message : String(error);
+				state.client = void 0;
+				await client.disconnect().catch(() => {});
+				console.error(`MCP server failed (${state.config.name}): ${state.error}`);
+				throw error;
+			} finally {
+				state.connect_promise = void 0;
+			}
+		})();
+		await state.connect_promise;
+	};
+	const connect_all_servers = async (options = {}) => {
+		await Promise.allSettled(Array.from(servers.values()).filter((state) => state.enabled).filter((state) => options.include_failed || state.status !== "failed").map((state) => connect_server(state)));
+	};
+	pi.on("session_start", async () => {
+		connect_all_servers();
+	});
+	pi.on("before_agent_start", async (event) => {
+		await connect_all_servers();
+		return event;
+	});
 	pi.registerCommand("mcp", {
 		description: "Manage MCP servers (list, enable, disable)",
 		getArgumentCompletions: (prefix) => {
@@ -1898,10 +2209,7 @@ async function mcp(pi) {
 						return;
 					}
 					const lines = [];
-					for (const [sname, state] of servers.entries()) {
-						const status = state.enabled ? "enabled" : "disabled";
-						lines.push(`${sname} (${status}) — ${state.tool_names.length} tools`);
-					}
+					for (const [sname, state] of servers.entries()) lines.push(`${sname} (${format_server_status(state)}) — ${state.tool_names.length} tools${state.error ? ` — ${state.error}` : ""}`);
 					ctx.ui.notify(lines.join("\n"));
 					break;
 				}
@@ -1911,14 +2219,23 @@ async function mcp(pi) {
 						ctx.ui.notify(`Unknown server: ${name}`, "warning");
 						return;
 					}
-					if (server.enabled) {
+					if (server.enabled && server.status !== "failed") {
 						ctx.ui.notify(`${name} already enabled`);
 						return;
 					}
 					server.enabled = true;
-					const active = pi.getActiveTools();
-					pi.setActiveTools([...active, ...server.tool_names]);
-					ctx.ui.notify(`Enabled ${name}`);
+					if (server.status === "connected") {
+						const active = pi.getActiveTools();
+						pi.setActiveTools([...active, ...server.tool_names]);
+						ctx.ui.notify(`Enabled ${name}`);
+						return;
+					}
+					if (server.status === "failed") {
+						server.status = "disconnected";
+						server.error = void 0;
+					}
+					connect_server(server);
+					ctx.ui.notify(`Enabling ${name} and connecting in background`);
 					break;
 				}
 				case "disable": {
@@ -1932,8 +2249,7 @@ async function mcp(pi) {
 						return;
 					}
 					server.enabled = false;
-					const tool_set = new Set(server.tool_names);
-					pi.setActiveTools(pi.getActiveTools().filter((t) => !tool_set.has(t)));
+					remove_server_tools_from_active(pi, server.tool_names);
 					ctx.ui.notify(`Disabled ${name}`);
 					break;
 				}
@@ -1942,7 +2258,12 @@ async function mcp(pi) {
 		}
 	});
 	pi.on("session_shutdown", async () => {
-		for (const server of servers.values()) await server.client.disconnect();
+		await Promise.allSettled(Array.from(servers.values()).map(async (server) => {
+			await server.connect_promise?.catch(() => {});
+			await server.client?.disconnect();
+			server.client = void 0;
+			if (server.status !== "failed") server.status = "disconnected";
+		}));
 	});
 }
 //#endregion
@@ -2763,22 +3084,20 @@ async function prompt_presets(pi) {
 //#endregion
 //#region src/extensions/recall.ts
 const DEFAULT_DB_PATH = join(process.env.HOME, ".pi", "pirecall.db");
-async function recall(pi) {
-	if (existsSync(DEFAULT_DB_PATH)) try {
-		execFileSync("npx", [
+function sync_recall_db_in_background() {
+	if (!existsSync(DEFAULT_DB_PATH)) return;
+	try {
+		spawn("npx", [
 			"pirecall",
 			"sync",
 			"--json"
-		], {
-			encoding: "utf-8",
-			timeout: 3e4,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		});
+		], { stdio: "ignore" }).unref();
 	} catch {}
+}
+async function recall(pi) {
+	pi.on("session_start", async () => {
+		sync_recall_db_in_background();
+	});
 	pi.on("before_agent_start", async (event) => {
 		return { systemPrompt: event.systemPrompt + `
 
@@ -3650,4 +3969,4 @@ async function create_my_pi(options = {}) {
 //#endregion
 export { create_my_pi as n, runPrintMode$1 as r, InteractiveMode$1 as t };
 
-//# sourceMappingURL=api-Dcq2JalY.js.map
+//# sourceMappingURL=api-7LVj6kUV.js.map