oh-my-opencode 5.0.0-beta.8 → 5.0.0-beta.81

package/packages/lsp-daemon/dist/cli.js

@@ -3,14 +3,450 @@
 // src/cli.ts
 import { argv, stderr } from "node:process";
 
-// src/proxy.ts
-import { existsSync as existsSync12, realpathSync as realpathSync5 } from "node:fs";
-import { basename as basename4, delimiter as delimiter4, dirname as dirname9, isAbsolute as isAbsolute5 } from "node:path";
+// src/ownership.ts
+import { randomUUID } from "node:crypto";
+import { existsSync, lstatSync as lstatSync2, readFileSync as readFileSync3, statSync, unlinkSync as unlinkSync3 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+
+// src/lock.ts
+import { closeSync, mkdirSync, openSync, readFileSync, unlinkSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error instanceof Error)
+      return errorCode(error) === "EPERM";
+    throw error;
+  }
+}
+function readLockPid(lockPath) {
+  try {
+    const pid = Number.parseInt(readFileSync(lockPath, "utf8").trim(), 10);
+    return Number.isInteger(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function tryAcquireLock(lockPath, ownerPid = process.pid) {
+  mkdirSync(dirname(lockPath), { recursive: true });
+  for (let attempt = 0;attempt < 2; attempt += 1) {
+    const handle = writeLockFile(lockPath, ownerPid);
+    if (handle)
+      return handle;
+    if (!reapStaleLock(lockPath))
+      return null;
+  }
+  return null;
+}
+function writeLockFile(lockPath, ownerPid) {
+  try {
+    const fd = openSync(lockPath, "wx", 384);
+    writeSync(fd, `${ownerPid}
+`);
+    closeSync(fd);
+    return { release: () => unlinkQuietly(lockPath) };
+  } catch (error) {
+    if (errorCode(error) === "EEXIST")
+      return null;
+    throw error;
+  }
+}
+function reapStaleLock(lockPath) {
+  const pid = readLockPid(lockPath);
+  if (pid !== null && isProcessAlive(pid))
+    return false;
+  unlinkQuietly(lockPath);
+  return true;
+}
+function unlinkQuietly(path) {
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    if (error instanceof Error)
+      return;
+    throw error;
+  }
+}
+function errorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error))
+    return;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" ? code : undefined;
+}
+
+// src/ipc-protocol.ts
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import {
+  chmodSync,
+  closeSync as closeSync2,
+  constants,
+  fchmodSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  unlinkSync as unlinkSync2,
+  writeSync as writeSync2
+} from "node:fs";
+import { dirname as dirname2 } from "node:path";
 
 // ../mcp-stdio-core/src/record.ts
 function isPlainRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+
+// src/ipc-protocol.ts
+var OMO_DAEMON_PROTOCOL_VERSION = 1;
+var AUTH_ERROR_CODE = -32001;
+var PROTOCOL_ERROR_CODE = -32002;
+var AUTH_TOKEN_BYTES = 32;
+
+class UnsafePrivateDirectoryError extends Error {
+  constructor(path, reason) {
+    super(`unsafe private directory ${path}: ${reason}`);
+    this.path = path;
+    this.reason = reason;
+    this.name = "UnsafePrivateDirectoryError";
+    this.code = "unsafe_private_directory";
+  }
+}
+function authEnvelope(token) {
+  return { protocolVersion: OMO_DAEMON_PROTOCOL_VERSION, token };
+}
+function readAuthToken(paths) {
+  try {
+    const token = readFileSync2(paths.auth, "utf8").trim();
+    return token.length > 0 ? token : null;
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+function readOrCreateAuthToken(paths) {
+  const existing = readAuthToken(paths);
+  if (existing)
+    return existing;
+  return createAuthToken(paths);
+}
+function rotateAuthToken(paths) {
+  try {
+    unlinkSync2(paths.auth);
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+  }
+  return createAuthToken(paths);
+}
+function authenticateMessage(raw, expectedToken) {
+  const id = jsonRpcId(raw);
+  if (!isPlainRecord(raw))
+    return authError(id);
+  const params = raw["params"];
+  if (!isPlainRecord(params))
+    return authError(id);
+  const envelope = params["_omo"];
+  if (!isPlainRecord(envelope))
+    return authError(id);
+  const protocolVersion = envelope["protocolVersion"];
+  if (protocolVersion !== OMO_DAEMON_PROTOCOL_VERSION)
+    return protocolError(id);
+  const token = envelope["token"];
+  if (typeof token !== "string" || !tokenMatches(token, expectedToken))
+    return authError(id);
+  const cleanParams = { ...params };
+  delete cleanParams["_omo"];
+  return { input: { ...raw, params: cleanParams }, id, method: typeof raw["method"] === "string" ? raw["method"] : undefined };
+}
+function isAuthErrorResponse(message) {
+  if (!isPlainRecord(message))
+    return false;
+  const error = message["error"];
+  if (!isPlainRecord(error))
+    return false;
+  const data = error["data"];
+  return error["code"] === AUTH_ERROR_CODE && isPlainRecord(data) && data["code"] === "daemon_authentication_failed";
+}
+function writePrivateFile(path, data) {
+  const fd = openSync2(path, "w", 384);
+  try {
+    writeSync2(fd, data);
+  } finally {
+    closeSync2(fd);
+  }
+  setPrivateFileMode(path);
+}
+function ensurePrivateDirectory(path, options = {}) {
+  try {
+    mkdirSync2(path, { recursive: true, mode: 448 });
+  } catch (error) {
+    if (errorCode2(error) !== "EEXIST")
+      throw error;
+  }
+  if (process.platform === "win32")
+    return;
+  const before = validatePrivateDirectory(path, options);
+  const fd = openSync2(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    fchmodSync(fd, 448);
+    const after = validatePrivateDirectory(path, options);
+    const openStats = fstatSync(fd);
+    if (!sameDirectory(before, after) || !sameDirectory(before, openStats)) {
+      throw new UnsafePrivateDirectoryError(path, "changed_during_chmod");
+    }
+  } finally {
+    closeSync2(fd);
+  }
+}
+function setPrivateFileMode(path) {
+  if (process.platform !== "win32")
+    chmodSync(path, 384);
+}
+function createAuthToken(paths) {
+  ensurePrivateDirectory(dirname2(paths.auth));
+  const token = randomBytes(AUTH_TOKEN_BYTES).toString("base64url");
+  let fd;
+  try {
+    fd = openSync2(paths.auth, "wx", 384);
+  } catch (error) {
+    if (errorCode2(error) === "EEXIST") {
+      const existing = readAuthToken(paths);
+      if (existing)
+        return existing;
+    }
+    throw error;
+  }
+  try {
+    writeSync2(fd, `${token}
+`);
+  } finally {
+    closeSync2(fd);
+  }
+  setPrivateFileMode(paths.auth);
+  return token;
+}
+function errorCode2(error) {
+  if (!error || typeof error !== "object" || !("code" in error))
+    return;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" ? code : undefined;
+}
+function validatePrivateDirectory(path, options) {
+  const stats = options.lstat ? options.lstat(path) : lstatPrivateDirectory(path);
+  if (stats.isSymbolicLink())
+    throw new UnsafePrivateDirectoryError(path, "symlink");
+  if (!stats.isDirectory())
+    throw new UnsafePrivateDirectoryError(path, "not_directory");
+  const currentUid = options.currentUid ? options.currentUid() : process.getuid?.();
+  if (currentUid !== undefined && stats.uid !== currentUid) {
+    throw new UnsafePrivateDirectoryError(path, "wrong_owner");
+  }
+  return stats;
+}
+function lstatPrivateDirectory(path) {
+  return lstatSync(path);
+}
+function sameDirectory(a, b) {
+  return a.dev === b.dev && a.ino === b.ino;
+}
+function tokenMatches(candidate, expected) {
+  const candidateBytes = Buffer.from(candidate);
+  const expectedBytes = Buffer.from(expected);
+  return candidateBytes.length === expectedBytes.length && timingSafeEqual(candidateBytes, expectedBytes);
+}
+function jsonRpcId(raw) {
+  if (!isPlainRecord(raw))
+    return null;
+  const id = raw["id"];
+  return typeof id === "string" || typeof id === "number" || id === null ? id : null;
+}
+function authError(id) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: { code: AUTH_ERROR_CODE, message: "daemon authentication failed", data: { code: "daemon_authentication_failed" } }
+  };
+}
+function protocolError(id) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: { code: PROTOCOL_ERROR_CODE, message: "daemon protocol mismatch", data: { code: "daemon_protocol_mismatch" } }
+  };
+}
+
+// src/ownership.ts
+class DaemonAlreadyRunningError extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "DaemonAlreadyRunningError";
+    this.code = "daemon_already_running";
+  }
+}
+
+class DaemonStartupDeferredError extends Error {
+  constructor(reason) {
+    super(`LSP daemon startup deferred: ${reason}`);
+    this.reason = reason;
+    this.name = "DaemonStartupDeferredError";
+    this.code = "daemon_startup_deferred";
+  }
+}
+async function acquireStartupLease(paths, pingOwner) {
+  ensureDaemonDirectories(paths);
+  const lock = tryAcquireLock(paths.lock);
+  if (!lock) {
+    const token = readAuthToken(paths);
+    if (token && await pingOwner(token))
+      throw new DaemonAlreadyRunningError("LSP daemon already running");
+    throw new DaemonStartupDeferredError("startup_lock_busy");
+  }
+  try {
+    const token = await validateExistingOwner(paths, pingOwner);
+    return { lock, token, owner: newOwner(paths) };
+  } catch (error) {
+    lock.release();
+    throw error;
+  }
+}
+function ensureDaemonDirectories(paths) {
+  ensurePrivateDirectory(paths.dir);
+  if (process.platform !== "win32")
+    ensurePrivateDirectory(dirname3(paths.socket));
+}
+function readDaemonOwner(paths) {
+  try {
+    return parseOwner(JSON.parse(readFileSync3(paths.owner, "utf8")));
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+function writeDaemonOwner(paths, owner) {
+  writePrivateFile(paths.pid, `${owner.pid}
+`);
+  writePrivateFile(paths.endpoint, owner.endpoint.path);
+  writePrivateFile(paths.owner, `${JSON.stringify(owner)}
+`);
+}
+function removeDaemonMetadataForOwner(paths, owner) {
+  const current = readDaemonOwner(paths);
+  if (!current || !sameOwner(current, owner))
+    return;
+  unlinkQuietly(paths.socket);
+  unlinkQuietly(paths.pid);
+  unlinkQuietly(paths.endpoint);
+  unlinkQuietly(paths.owner);
+}
+function endpointIdentity(endpointPath) {
+  if (process.platform === "win32")
+    return { kind: "windows", path: endpointPath };
+  try {
+    const stats = statSync(endpointPath);
+    return { kind: "unix", path: endpointPath, dev: stats.dev, ino: stats.ino };
+  } catch (error) {
+    if (error instanceof Error)
+      return { kind: "missing", path: endpointPath };
+    throw error;
+  }
+}
+function sameEndpoint(a, b) {
+  if (a.kind !== b.kind || a.path !== b.path)
+    return false;
+  switch (a.kind) {
+    case "unix":
+      return b.kind === "unix" && a.dev === b.dev && a.ino === b.ino;
+    case "windows":
+      return true;
+    case "missing":
+      return true;
+  }
+}
+function sameOwner(a, b) {
+  return a.pid === b.pid && a.nonce === b.nonce && sameEndpoint(a.endpoint, b.endpoint);
+}
+async function validateExistingOwner(paths, pingOwner) {
+  let token = readOrCreateAuthToken(paths);
+  for (let attempt = 0;attempt < 2; attempt += 1) {
+    const owner = readDaemonOwner(paths);
+    if (!owner)
+      return token;
+    const ping = await pingOwner(token);
+    if (ping && owner.nonce === ping.nonce && sameEndpoint(owner.endpoint, ping.endpoint)) {
+      throw new DaemonAlreadyRunningError("LSP daemon already running");
+    }
+    if (ping)
+      continue;
+    if (isProcessAlive(owner.pid))
+      throw new DaemonStartupDeferredError("owner_pid_live_unreachable");
+    const reread = readDaemonOwner(paths);
+    if (!reread || !sameOwner(reread, owner)) {
+      throw new DaemonStartupDeferredError("owner_changed_during_cleanup");
+    }
+    cleanupDeadOwner(paths, owner);
+    token = rotateAuthToken(paths);
+    return token;
+  }
+  throw new DaemonStartupDeferredError("reachable_owner_mismatch");
+}
+function cleanupDeadOwner(paths, owner) {
+  if (process.platform !== "win32" && existsSync(owner.endpoint.path)) {
+    const stat = lstatSync2(owner.endpoint.path);
+    if (stat.isSocket())
+      unlinkSync3(owner.endpoint.path);
+  }
+  unlinkQuietly(paths.pid);
+  unlinkQuietly(paths.endpoint);
+  unlinkQuietly(paths.owner);
+}
+function newOwner(paths) {
+  return {
+    pid: process.pid,
+    nonce: randomUUID(),
+    startedAt: new Date().toISOString(),
+    endpoint: endpointIdentity(paths.socket)
+  };
+}
+function parseOwner(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const pid = Reflect.get(value, "pid");
+  const nonce = Reflect.get(value, "nonce");
+  const startedAt = Reflect.get(value, "startedAt");
+  const endpoint = parseEndpoint(Reflect.get(value, "endpoint"));
+  if (typeof pid !== "number" || typeof nonce !== "string" || typeof startedAt !== "string" || !endpoint)
+    return null;
+  return { pid, nonce, startedAt, endpoint };
+}
+function parseEndpoint(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const kind = Reflect.get(value, "kind");
+  const path = Reflect.get(value, "path");
+  if (typeof path !== "string")
+    return null;
+  if (kind === undefined)
+    return endpointIdentity(path);
+  if (kind === "windows")
+    return { kind, path };
+  if (kind === "missing")
+    return { kind, path };
+  const dev = Reflect.get(value, "dev");
+  const ino = Reflect.get(value, "ino");
+  if (kind === "unix" && typeof dev === "number" && typeof ino === "number")
+    return { kind, path, dev, ino };
+  return null;
+}
+
+// src/proxy.ts
+import { existsSync as existsSync14, realpathSync as realpathSync6 } from "node:fs";
+import { basename as basename4, delimiter as delimiter4, dirname as dirname13, isAbsolute as isAbsolute6 } from "node:path";
 // ../mcp-stdio-core/src/responses.ts
 function successResponse(id, result) {
   return { jsonrpc: "2.0", id, result };
@@ -18,7 +454,7 @@ function successResponse(id, result) {
 function errorResponse(id, code, message, data) {
   return { jsonrpc: "2.0", id, error: data === undefined ? { code, message } : { code, message, data } };
 }
-function jsonRpcId(value) {
+function jsonRpcId2(value) {
   return typeof value === "string" || typeof value === "number" || value === null ? value : null;
 }
 function messageFromError(error) {
@@ -169,7 +605,7 @@ function bufferFromChunk(chunk) {
 var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60000;
 var DEFAULT_PARENT_POLL_INTERVAL_MS = 30000;
 var noopLog = () => {};
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -184,6 +620,7 @@ async function runJsonRpcStdioServer(config) {
   const idleTimer = createIdleTimer(idleTimeoutMs, log, () => {
     isClosed = true;
     config.onIdleTimeout?.();
+    config.input.destroy();
   });
   const watchdog = createParentWatchdog(config.parentWatchdog, (parentPid, pollIntervalMs) => {
     isClosed = true;
@@ -228,7 +665,7 @@ async function handleParseError(message, config, log) {
 }
 async function handleRequest(message, config, log) {
   const parsed = message.payload;
-  const id = isPlainRecord(parsed) ? jsonRpcId(parsed["id"]) : null;
+  const id = isPlainRecord(parsed) ? jsonRpcId2(parsed["id"]) : null;
   const method = isPlainRecord(parsed) && typeof parsed["method"] === "string" ? parsed["method"] : null;
   log("request", { id: id === null ? null : String(id), method });
   let response;
@@ -277,10 +714,14 @@ function createParentWatchdog(config, onDeadParent) {
   if (pollIntervalMs <= 0)
     return { clear: () => {} };
   const parentPid = config.parentPid ?? process.ppid;
-  const probeAlive = config.probeAlive ?? isProcessAlive;
+  const probeAlive = config.probeAlive ?? isProcessAlive2;
   let fired = false;
   const timer = setInterval(() => {
-    if (fired || probeAlive(parentPid))
+    if (fired)
+      return;
+    const alive = probeAlive(parentPid);
+    config.onPoll?.(alive);
+    if (alive)
       return;
     fired = true;
     onDeadParent(parentPid, pollIntervalMs);
@@ -315,28 +756,27 @@ function createIdleTimer(idleTimeoutMs, log, onTimeout) {
   };
 }
 // ../lsp-core/src/lsp/client-wrapper.ts
-import { existsSync as existsSync9, realpathSync as realpathSync4, statSync as statSync3 } from "node:fs";
-import { basename as basename3, dirname as dirname6, join as join4, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync11, realpathSync as realpathSync5, statSync as statSync4 } from "node:fs";
+import { basename as basename3, dirname as dirname11, join as join5, resolve as resolve8 } from "node:path";
 
 // ../lsp-core/src/request-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { existsSync, realpathSync, statSync } from "node:fs";
+import { existsSync as existsSync2, realpathSync, statSync as statSync2 } from "node:fs";
 import { homedir } from "node:os";
-import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { basename, delimiter, dirname as dirname4, isAbsolute, join, relative, resolve } from "node:path";
 
 class LspRequestContextParseError extends Error {
-  code;
-  name = "LspRequestContextParseError";
   constructor(code, message) {
     super(message);
     this.code = code;
+    this.name = "LspRequestContextParseError";
   }
 }
 
 class LspRequestContextUnavailableError extends Error {
-  name = "LspRequestContextUnavailableError";
   constructor() {
     super("LSP request context is required. Standalone MCP startup must install one with runWithRequestContext(createStandaloneMcpRequestContext()).");
+    this.name = "LspRequestContextUnavailableError";
   }
 }
 var storage = new AsyncLocalStorage;
@@ -356,7 +796,7 @@ function contextCwd() {
 }
 function createStandaloneMcpRequestContext(input = {}) {
   const env = input.env ?? process.env;
-  const cwd = canonicalCwd(input.cwd ?? process.cwd());
+  const cwd = canonicalCwd(input.cwd ?? env["LSP_TOOLS_MCP_CWD"] ?? process.cwd());
   const home = input.homeDir ?? homedir();
   const projectConfigPaths = translateProjectConfigEnv(env["LSP_TOOLS_MCP_PROJECT_CONFIG"], cwd);
   const userConfigPath = translateHomeConfigEnv(env["LSP_TOOLS_MCP_USER_CONFIG"], home, ".codex/lsp-client.json");
@@ -409,7 +849,7 @@ function translateHomeConfigEnv(value, home, fallback) {
 }
 function canonicalCwd(cwd) {
   const resolved = resolve(cwd);
-  if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+  if (!existsSync2(resolved) || !statSync2(resolved).isDirectory()) {
     throw new LspRequestContextParseError("invalid_cwd", `LSP request cwd must be an existing directory: ${cwd}`);
   }
   return realpathSync(resolved);
@@ -424,7 +864,7 @@ function canonicalizeExistingOrNearestAncestor(path) {
     } catch (error) {
       if (!isMissingPathError(error))
         throw error;
-      const parent = dirname(current);
+      const parent = dirname4(current);
       if (parent === current)
         throw error;
       suffix.unshift(basename(current));
@@ -468,7 +908,7 @@ function isPathInside(parent, child) {
   return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
 }
 function isMissingPathError(error) {
-  const code = errorCode(error);
+  const code = errorCode3(error);
   return code === "ENOENT" || code === "ENOTDIR";
 }
 function rejectUnknownFields(value, allowed, scope) {
@@ -480,7 +920,7 @@ function rejectUnknownFields(value, allowed, scope) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function errorCode(error) {
+function errorCode3(error) {
   if (!error || typeof error !== "object" || !("code" in error))
     return;
   const code = Reflect.get(error, "code");
@@ -499,22 +939,15 @@ function effectiveExtension(filePath) {
 
 // ../lsp-core/src/lsp/errors.ts
 class LspConnectionClosedError extends Error {
-  serverId;
-  root;
-  name = "LspConnectionClosedError";
   constructor(serverId, root, message) {
     super(message ?? `LSP connection closed for ${serverId} at ${root}`);
     this.serverId = serverId;
     this.root = root;
+    this.name = "LspConnectionClosedError";
   }
 }
 
 class LspProcessExitedError extends Error {
-  serverId;
-  root;
-  exitCode;
-  stderrTail;
-  name = "LspProcessExitedError";
   constructor(serverId, root, exitCode, stderrTail) {
     const stderrSuffix = stderrTail ? `
 stderr tail: ${stderrTail}` : "";
@@ -523,46 +956,59 @@ stderr tail: ${stderrTail}` : "";
     this.root = root;
     this.exitCode = exitCode;
     this.stderrTail = stderrTail;
+    this.name = "LspProcessExitedError";
   }
 }
 
 class LspRequestTimeoutError extends Error {
-  method;
-  stderrTail;
-  name = "LspRequestTimeoutError";
   constructor(method, stderrTail) {
     const stderrSuffix = stderrTail ? `
 recent stderr: ${stderrTail}` : "";
     super(`LSP request timeout (method: ${method})${stderrSuffix}`);
     this.method = method;
     this.stderrTail = stderrTail;
+    this.name = "LspRequestTimeoutError";
   }
 }
 
 class LspInvalidPathError extends Error {
-  name = "LspInvalidPathError";
+  constructor() {
+    super(...arguments);
+    this.name = "LspInvalidPathError";
+  }
 }
 
 class LspServerLookupError extends Error {
-  lookup;
-  name = "LspServerLookupError";
   constructor(message, lookup) {
     super(message);
     this.lookup = lookup;
+    this.name = "LspServerLookupError";
   }
 }
 
 class LspServerInitializingError extends Error {
-  originalError;
-  name = "LspServerInitializingError";
   constructor(originalError) {
     super(`LSP server is still initializing. Please retry in a few seconds. Original error: ${originalError.message}`);
     this.originalError = originalError;
+    this.name = "LspServerInitializingError";
   }
 }
 
 class LspProcessSpawnError extends Error {
-  name = "LspProcessSpawnError";
+  constructor() {
+    super(...arguments);
+    this.name = "LspProcessSpawnError";
+  }
+}
+
+class LspClientRespawnBudgetExceededError extends Error {
+  constructor(serverId, root, retryLimit) {
+    super(`LSP server ${serverId} at ${root} failed to stay alive; respawn budget exhausted ` + `(${retryLimit} consecutive dead generations). Retrying after the cooldown may succeed.`);
+    this.serverId = serverId;
+    this.root = root;
+    this.retryLimit = retryLimit;
+    this.name = "LspClientRespawnBudgetExceededError";
+  }
 }
 function isLspDeadConnectionError(err) {
   return err instanceof LspConnectionClosedError || err instanceof LspProcessExitedError;
@@ -585,6 +1031,13 @@ import { pathToFileURL as pathToFileURL3 } from "node:url";
 // ../lsp-core/src/lsp/connection.ts
 import { pathToFileURL } from "node:url";
 
+// ../lsp-core/src/lsp/timer-provider.ts
+var realTimerProvider = {
+  now: () => Date.now(),
+  setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+
 // ../lsp-core/src/lsp/constants.ts
 var DEFAULT_MAX_REFERENCES = 200;
 var DEFAULT_MAX_SYMBOLS = 200;
@@ -593,9 +1046,12 @@ var DEFAULT_MAX_DIRECTORY_FILES = 50;
 var REQUEST_TIMEOUT_MS = 15000;
 var INIT_TIMEOUT_MS = 60000;
 var IDLE_TIMEOUT_MS = 5 * 60000;
+var MAX_RESIDENT_CLIENTS = 6;
 var REAPER_INTERVAL_MS = 60000;
 var STOP_HARD_KILL_TIMEOUT_MS = 5000;
 var STOP_SIGKILL_GRACE_MS = 1000;
+var CLIENT_RESPAWN_RETRY_LIMIT = 2;
+var CLIENT_RESPAWN_COOLDOWN_MS = 60000;
 
 // ../lsp-core/src/lsp/json-rpc-connection.ts
 var HEADER_SEPARATOR2 = `\r
@@ -607,20 +1063,31 @@ var METHOD_NOT_FOUND = -32601;
 var INTERNAL_ERROR = -32603;
 
 class JsonRpcConnection {
-  reader;
-  writer;
-  pendingRequests = new Map;
-  notificationHandlers = new Map;
-  requestHandlers = new Map;
-  closeHandlers = [];
-  errorHandlers = [];
-  inputBuffer = Buffer.alloc(0);
-  nextRequestId = 1;
-  listening = false;
-  disposed = false;
   constructor(reader, writer) {
     this.reader = reader;
     this.writer = writer;
+    this.pendingRequests = new Map;
+    this.notificationHandlers = new Map;
+    this.requestHandlers = new Map;
+    this.closeHandlers = [];
+    this.errorHandlers = [];
+    this.inputBuffer = Buffer.alloc(0);
+    this.nextRequestId = 1;
+    this.listening = false;
+    this.disposed = false;
+    this.handleData = (chunk) => {
+      const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+      this.inputBuffer = Buffer.concat([this.inputBuffer, chunkBuffer]);
+      this.drainInputBuffer();
+    };
+    this.handleClose = () => {
+      for (const handler of this.closeHandlers) {
+        handler();
+      }
+    };
+    this.handleStreamError = (error) => {
+      this.emitError(error);
+    };
   }
   listen() {
     if (this.listening)
@@ -655,7 +1122,8 @@ class JsonRpcConnection {
     let cancelAfterWrite = false;
     let settled = false;
     const writeCancel = () => this.writeMessage({ jsonrpc: "2.0", method: "$/cancelRequest", params: { id } });
-    const responsePromise = new Promise((resolve2, reject) => {
+    let rejectAfterCancelWrite;
+    const responsePromise = new Promise((resolve, reject) => {
       const cleanup = () => {
         options.signal?.removeEventListener("abort", onAbort);
       };
@@ -666,22 +1134,26 @@ class JsonRpcConnection {
         this.pendingRequests.delete(key);
         cleanup();
         const rejectCancelled = () => reject(abortError(options.signal));
+        rejectAfterCancelWrite = async () => {
+          try {
+            await writeCancel();
+          } catch (error) {
+            this.emitError(toError(error));
+          }
+          rejectCancelled();
+        };
         if (!requestWritten) {
           cancelAfterWrite = true;
-          rejectCancelled();
           return;
         }
-        writeCancel().then(rejectCancelled, (error) => {
-          this.emitError(toError(error));
-          rejectCancelled();
-        });
+        rejectAfterCancelWrite();
       };
       const onAbort = () => settleCancel();
       this.pendingRequests.set(key, {
         resolve(result) {
           settled = true;
           cleanup();
-          resolve2(result);
+          resolve(result);
         },
         reject(error) {
           settled = true;
@@ -702,7 +1174,7 @@ class JsonRpcConnection {
       await this.writeMessage(message);
       requestWritten = true;
       if (cancelAfterWrite)
-        await writeCancel();
+        await rejectAfterCancelWrite?.();
     } catch (error) {
       if (settled)
         return responsePromise;
@@ -741,19 +1213,6 @@ class JsonRpcConnection {
     this.notificationHandlers.clear();
     this.requestHandlers.clear();
   }
-  handleData = (chunk) => {
-    const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
-    this.inputBuffer = Buffer.concat([this.inputBuffer, chunkBuffer]);
-    this.drainInputBuffer();
-  };
-  handleClose = () => {
-    for (const handler of this.closeHandlers) {
-      handler();
-    }
-  };
-  handleStreamError = (error) => {
-    this.emitError(error);
-  };
   drainInputBuffer() {
     while (true) {
       const headerEnd = this.inputBuffer.indexOf(HEADER_SEPARATOR2);
@@ -853,13 +1312,13 @@ class JsonRpcConnection {
     const payload = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
 \r
 ${body}`;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       this.writer.write(payload, (error) => {
         if (error) {
           reject(error);
           return;
         }
-        resolve2();
+        resolve();
       });
     });
   }
@@ -916,7 +1375,7 @@ function toError(error) {
 
 // ../lsp-core/src/lsp/process.ts
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync as existsSync2, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync3, statSync as statSync3 } from "node:fs";
 import { delimiter as delimiter2, join as join2 } from "node:path";
 function isMissingProcessError(error) {
   if (!(error instanceof Error) || !("code" in error))
@@ -930,10 +1389,10 @@ function reportKillError(context, error) {
 }
 function validateCwd(cwd) {
   try {
-    if (!existsSync2(cwd)) {
+    if (!existsSync3(cwd)) {
       return { valid: false, error: `Working directory does not exist: ${cwd}` };
     }
-    const stats = statSync2(cwd);
+    const stats = statSync3(cwd);
     if (!stats.isDirectory()) {
       return { valid: false, error: `Path is not a directory: ${cwd}` };
     }
@@ -946,9 +1405,9 @@ function validateCwd(cwd) {
   }
 }
 function wrap(proc) {
-  const exitedPromise = new Promise((resolve2) => {
-    proc.once("close", (code) => resolve2(code ?? 0));
-    proc.once("error", () => resolve2(1));
+  const exitedPromise = new Promise((resolve) => {
+    proc.once("close", (code) => resolve(code ?? 0));
+    proc.once("error", () => resolve(1));
   });
   if (!proc.stdin || !proc.stdout || !proc.stderr) {
     throw new LspProcessSpawnError("Spawned process is missing one of stdin/stdout/stderr pipes");
@@ -1018,7 +1477,7 @@ function resolveWindowsCommand(command, env) {
   for (const baseDirectory of baseDirectories) {
     for (const extension of extensions) {
       const candidate = baseDirectory ? join2(baseDirectory, `${command}${extension}`) : `${command}${extension}`;
-      if (existsSync2(candidate))
+      if (existsSync3(candidate))
         return candidate;
     }
   }
@@ -1101,33 +1560,29 @@ function isPosition(value) {
 
 // ../lsp-core/src/lsp/transport.ts
 class LspClientNotStartedError extends Error {
-  serverId;
-  root;
-  name = "LspClientNotStartedError";
   constructor(serverId, root) {
     super("LSP client not started");
     this.serverId = serverId;
     this.root = root;
+    this.name = "LspClientNotStartedError";
   }
 }
 
 class LspClientTransport {
-  root;
-  server;
-  proc = null;
-  connection = null;
-  stderrBuffer = [];
-  processExited = false;
-  diagnosticsStore = new Map;
-  requestTimeoutMs;
-  initializeTimeoutMs;
-  workspaceApplyEditHandler = null;
-  diagnosticPullSupported = false;
-  constructor(root, server2, timeouts = {}) {
+  constructor(root, server, timeouts = {}) {
     this.root = root;
-    this.server = server2;
+    this.server = server;
+    this.proc = null;
+    this.connection = null;
+    this.stderrBuffer = [];
+    this.processExited = false;
+    this.diagnosticsStore = new Map;
+    this.workspaceApplyEditHandler = null;
+    this.diagnosticPullSupported = false;
+    this.documentFormattingSupported = false;
     this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
     this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
+    this.timerProvider = timeouts.timerProvider ?? realTimerProvider;
   }
   pid() {
     return this.proc?.pid;
@@ -1147,6 +1602,12 @@ class LspClientTransport {
   isDiagnosticPullSupported() {
     return this.diagnosticPullSupported;
   }
+  setDocumentFormattingSupported(supported) {
+    this.documentFormattingSupported = supported;
+  }
+  isDocumentFormattingSupported() {
+    return this.documentFormattingSupported;
+  }
   handlePublishDiagnostics(params) {
     this.diagnosticsStore.set(params.uri, [...params.diagnostics]);
   }
@@ -1222,7 +1683,7 @@ class LspClientTransport {
     const options = args[1];
     const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
     const timeoutController = new AbortController;
-    const timeoutHandle = setTimeout(() => {
+    const timeoutHandle = this.timerProvider.setTimeout(() => {
       const stderrTail = this.stderrBuffer.slice(-5).join(`
 `);
       timeoutController.abort(new LspRequestTimeoutError(method, stderrTail || undefined));
@@ -1241,7 +1702,7 @@ class LspClientTransport {
       }
       throw error;
     } finally {
-      clearTimeout(timeoutHandle);
+      this.timerProvider.clearTimeout(timeoutHandle);
       combinedSignal.dispose();
     }
   }
@@ -1292,8 +1753,8 @@ class LspClientTransport {
       try {
         proc.kill();
         let timeoutId;
-        const timeoutPromise = new Promise((resolve2) => {
-          timeoutId = setTimeout(resolve2, STOP_HARD_KILL_TIMEOUT_MS);
+        const timeoutPromise = new Promise((resolve) => {
+          timeoutId = setTimeout(resolve, STOP_HARD_KILL_TIMEOUT_MS);
         });
         await Promise.race([
           proc.exited.then(() => {
@@ -1309,7 +1770,7 @@ class LspClientTransport {
             proc.kill("SIGKILL");
             await Promise.race([
               proc.exited,
-              new Promise((resolve2) => setTimeout(resolve2, STOP_SIGKILL_GRACE_MS))
+              new Promise((resolve) => setTimeout(resolve, STOP_SIGKILL_GRACE_MS))
             ]);
           } catch (error) {
             reportBestEffortCleanupError("hard process kill", error instanceof Error ? error : String(error));
@@ -1360,6 +1821,14 @@ function supportsDiagnosticPull(capabilities) {
     return false;
   return Object.hasOwn(capabilities, "diagnosticProvider");
 }
+function supportsDocumentFormatting(capabilities) {
+  if (capabilities === undefined)
+    return false;
+  const provider = capabilities.documentFormattingProvider;
+  if (provider === undefined || provider === null || provider === false)
+    return false;
+  return provider === true || typeof provider === "object";
+}
 
 class LspClientConnection extends LspClientTransport {
   async initialize() {
@@ -1376,6 +1845,7 @@ class LspClientConnection extends LspClientTransport {
           references: {},
           documentSymbol: { hierarchicalDocumentSymbolSupport: true },
           publishDiagnostics: {},
+          formatting: { dynamicRegistration: false },
           rename: {
             prepareSupport: true,
             prepareSupportDefaultBehavior: 1
@@ -1417,6 +1887,7 @@ class LspClientConnection extends LspClientTransport {
       initializationOptions: this.server.initialization
     }, { timeoutMs: this.initializeTimeoutMs });
     this.setDiagnosticPullSupported(supportsDiagnosticPull(result?.capabilities));
+    this.setDocumentFormattingSupported(supportsDocumentFormatting(result?.capabilities));
     await this.sendNotification("initialized", {});
     await this.sendNotification("workspace/didChangeConfiguration", {
       settings: { json: { validate: { enable: true } } }
@@ -1425,7 +1896,7 @@ class LspClientConnection extends LspClientTransport {
 }
 
 // ../lsp-core/src/lsp/workspace-document-state.ts
-import { readFileSync, realpathSync as realpathSync2 } from "node:fs";
+import { readFileSync as readFileSync4, realpathSync as realpathSync2 } from "node:fs";
 import { relative as relative2, resolve as resolve2 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
@@ -1612,6 +2083,17 @@ function canonicalPath(filePath) {
     return absolute;
   }
 }
+function normalizeDocumentUri(uri) {
+  let decoded = uri;
+  try {
+    decoded = decodeURIComponent(uri);
+  } catch {
+    decoded = uri;
+  }
+  if (process.platform !== "win32")
+    return decoded;
+  return decoded.replace(/^(file:\/\/\/)([a-z]):/, (_match, prefix, drive) => `${prefix}${drive.toUpperCase()}:`);
+}
 function isSameOrDescendant(candidate, parent) {
   const suffix = relative2(parent, candidate);
   return suffix === "" || !suffix.startsWith("..") && suffix !== "..";
@@ -1622,17 +2104,18 @@ function movedPath(candidate, oldPath, newPath) {
 }
 
 class WorkspaceDocumentState {
-  sendNotification;
-  clearDiagnostics;
-  openDocuments = new Map;
-  openByUri = new Map;
-  openPromises = new Map;
-  now;
-  versionlessPublishQuiescenceMs;
   constructor(sendNotification, clearDiagnostics, options = {}) {
     this.sendNotification = sendNotification;
     this.clearDiagnostics = clearDiagnostics;
-    this.now = options.now ?? (() => Date.now());
+    this.openDocuments = new Map;
+    this.openByUri = new Map;
+    this.openPromises = new Map;
+    this.timerProvider = options.timerProvider ?? {
+      now: options.now ?? (() => Date.now()),
+      setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+      clearTimeout: (handle) => clearTimeout(handle)
+    };
+    this.now = () => this.timerProvider.now();
     this.versionlessPublishQuiescenceMs = options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
   }
   async openFile(filePath) {
@@ -1642,7 +2125,7 @@ class WorkspaceDocumentState {
       await existingOpen;
       return this.openFile(path);
     }
-    const text = readFileSync(path, "utf-8");
+    const text = readFileSync4(path, "utf-8");
     const existing = this.openDocuments.get(path);
     if (!existing)
       return this.openDocumentSingleFlight(path, text);
@@ -1654,7 +2137,7 @@ class WorkspaceDocumentState {
     return this.openDocuments.get(canonicalPath(filePath))?.version;
   }
   getStoredDiagnostics(uri) {
-    const state = this.openByUri.get(uri);
+    const state = this.openByUri.get(normalizeDocumentUri(uri));
     if (!state)
       return [];
     return state.lastPublish?.diagnostics ?? state.pullCache?.diagnostics ?? [];
@@ -1676,13 +2159,13 @@ class WorkspaceDocumentState {
     return state !== undefined && state.uri === snapshot.uri && state.version === snapshot.version && state.generation === snapshot.documentGeneration;
   }
   getPullCache(snapshot) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state?.pullCache || state.pullCache.documentVersion !== snapshot.version)
       return null;
     return state.pullCache;
   }
   recordPullDiagnostics(snapshot, report) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state)
       return;
     state.pullCache = {
@@ -1692,7 +2175,7 @@ class WorkspaceDocumentState {
     };
   }
   recordPublishedDiagnostics(params) {
-    const state = this.openByUri.get(params.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(params.uri));
     if (!state)
       return;
     state.publishGeneration += 1;
@@ -1706,7 +2189,7 @@ class WorkspaceDocumentState {
     this.notifyWaiters(state);
   }
   resolvePushDiagnostics(snapshot) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state?.lastPublish)
       return { status: "missing" };
     const publish = state.lastPublish;
@@ -1720,20 +2203,22 @@ class WorkspaceDocumentState {
     return waitMs === 0 ? { status: "ready", diagnostics: publish.diagnostics } : { status: "wait", waitMs };
   }
   waitForDiagnosticsActivity(snapshot, timeoutMs) {
-    const state = this.openByUri.get(snapshot.uri);
+    const state = this.openByUri.get(normalizeDocumentUri(snapshot.uri));
     if (!state || timeoutMs <= 0)
       return Promise.resolve();
+    if (state.publishGeneration !== snapshot.publishGeneration)
+      return Promise.resolve();
     return new Promise((resolveActivity) => {
       let settled = false;
       const finish = () => {
         if (settled)
           return;
         settled = true;
-        clearTimeout(timer);
+        this.timerProvider.clearTimeout(timer);
         state.waiters.delete(finish);
         resolveActivity();
       };
-      const timer = setTimeout(finish, timeoutMs);
+      const timer = this.timerProvider.setTimeout(finish, timeoutMs);
       if (typeof timer.unref === "function")
         timer.unref();
       state.waiters.add(finish);
@@ -1799,7 +2284,7 @@ class WorkspaceDocumentState {
       const state = this.openDocuments.get(mutation.path);
       if (state) {
         await this.closeDocument(state);
-        await this.openDocumentSingleFlight(mutation.path, readFileSync(mutation.path, "utf-8"));
+        await this.openDocumentSingleFlight(mutation.path, readFileSync4(mutation.path, "utf-8"));
       } else {
         watched.push({ uri: pathToFileURL2(mutation.path).href, type: mutation.replaced ? 2 : 1 });
       }
@@ -1811,7 +2296,7 @@ class WorkspaceDocumentState {
         await this.closeDocument(state);
       for (const state of moved) {
         const path = movedPath(state.path, mutation.oldPath, mutation.newPath);
-        await this.openDocumentSingleFlight(path, readFileSync(path, "utf-8"));
+        await this.openDocumentSingleFlight(path, readFileSync4(path, "utf-8"));
       }
       if (moved.length === 0) {
         watched.push({ uri: pathToFileURL2(mutation.oldPath).href, type: 3 });
@@ -1841,7 +2326,7 @@ class WorkspaceDocumentState {
         waiters: new Set
       };
       this.openDocuments.set(path, state);
-      this.openByUri.set(state.uri, state);
+      this.openByUri.set(normalizeDocumentUri(state.uri), state);
       this.notifyWaiters(state);
       await this.sendNotification("textDocument/didOpen", {
         textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text }
@@ -1866,7 +2351,7 @@ class WorkspaceDocumentState {
   }
   async closeDocument(state) {
     this.openDocuments.delete(state.path);
-    this.openByUri.delete(state.uri);
+    this.openByUri.delete(normalizeDocumentUri(state.uri));
     this.clearDiagnostics(state.uri);
     this.notifyWaiters(state);
     await this.sendNotification("textDocument/didClose", { textDocument: { uri: state.uri } });
@@ -1887,21 +2372,19 @@ function workspaceApplyEditConcurrentFailureReason(phase) {
 }
 
 // ../lsp-core/src/lsp/workspace-edit-commit.ts
-import { existsSync as existsSync4, lstatSync as lstatSync2, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync5, lstatSync as lstatSync4, renameSync, rmSync, writeFileSync } from "node:fs";
 
 // ../lsp-core/src/lsp/workspace-edit-path.ts
-import { existsSync as existsSync3, lstatSync, readFileSync as readFileSync2, readdirSync, realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname2, isAbsolute as isAbsolute2, relative as relative3, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync4, lstatSync as lstatSync3, readFileSync as readFileSync5, readdirSync, realpathSync as realpathSync3 } from "node:fs";
+import { dirname as dirname5, isAbsolute as isAbsolute2, relative as relative3, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 class WorkspaceEditPathError extends Error {
-  path;
-  detail;
-  name = "WorkspaceEditPathError";
   constructor(path, detail) {
     super(`${detail}: ${path}`);
     this.path = path;
     this.detail = detail;
+    this.name = "WorkspaceEditPathError";
   }
 }
 function isPathInsideWorkspace(filePath, workspaceRoot) {
@@ -1910,8 +2393,8 @@ function isPathInsideWorkspace(filePath, workspaceRoot) {
 }
 function canonicalizeMissingPath(filePath) {
   let ancestor = filePath;
-  while (!existsSync3(ancestor)) {
-    const parent = dirname2(ancestor);
+  while (!existsSync4(ancestor)) {
+    const parent = dirname5(ancestor);
     if (parent === ancestor)
       throw new WorkspaceEditPathError(filePath, "no existing ancestor");
     ancestor = parent;
@@ -1921,14 +2404,14 @@ function canonicalizeMissingPath(filePath) {
 function canonicalWorkspaceRoot(workspaceRoot) {
   try {
     const canonical = realpathSync3(resolve3(workspaceRoot));
-    if (!lstatSync(canonical).isDirectory()) {
+    if (!lstatSync3(canonical).isDirectory()) {
       return { success: false, error: `workspace root is not a directory: ${workspaceRoot}` };
     }
     return {
       success: true,
       path: canonical,
       requestedPath: resolve3(workspaceRoot),
-      followedSymbolicLink: existsSync3(resolve3(workspaceRoot)) && lstatSync(resolve3(workspaceRoot)).isSymbolicLink()
+      followedSymbolicLink: existsSync4(resolve3(workspaceRoot)) && lstatSync3(resolve3(workspaceRoot)).isSymbolicLink()
     };
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
@@ -1948,7 +2431,7 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
     return { success: false, error: `non-file URI ${uri}: ${detail}` };
   }
   try {
-    const canonical = existsSync3(requestedPath) ? realpathSync3(requestedPath) : canonicalizeMissingPath(requestedPath);
+    const canonical = existsSync4(requestedPath) ? realpathSync3(requestedPath) : canonicalizeMissingPath(requestedPath);
     if (!isPathInsideWorkspace(canonical, workspaceRoot)) {
       return { success: false, error: `${requestedPath}: outside workspace ${workspaceRoot}` };
     }
@@ -1956,7 +2439,7 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
       success: true,
       path: canonical,
       requestedPath,
-      followedSymbolicLink: existsSync3(requestedPath) && lstatSync(requestedPath).isSymbolicLink()
+      followedSymbolicLink: existsSync4(requestedPath) && lstatSync3(requestedPath).isSymbolicLink()
     };
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
@@ -1964,11 +2447,11 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
   }
 }
 function snapshotPath(path, includeChildren) {
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return { kind: "missing" };
-  const stats = lstatSync(path);
+  const stats = lstatSync3(path);
   if (stats.isFile())
-    return { kind: "file", content: readFileSync2(path, "utf-8") };
+    return { kind: "file", content: readFileSync5(path, "utf-8") };
   if (stats.isDirectory()) {
     return includeChildren ? { kind: "directory", children: readdirSync(path).sort() } : { kind: "directory" };
   }
@@ -2084,7 +2567,7 @@ function commitOperation(context, operation) {
   }
   if (operation.kind === "rename") {
     if (operation.replaceDestination) {
-      const targetKind = existsSync4(operation.newPath) && lstatSync2(operation.newPath).isDirectory() ? "directory" : "file";
+      const targetKind = existsSync5(operation.newPath) && lstatSync4(operation.newPath).isDirectory() ? "directory" : "file";
       io.remove(operation.newPath, targetKind === "directory");
       accumulator.mutations.push({ kind: "delete", path: operation.newPath, targetKind });
       addModifiedPath(accumulator.filesModified, reportedPath(plan, operation.newPath));
@@ -2193,13 +2676,11 @@ function canonicalFingerprint(operations) {
 
 // ../lsp-core/src/lsp/workspace-edit-types.ts
 class WorkspaceEditValidationError extends Error {
-  changeIndex;
-  detail;
-  name = "WorkspaceEditValidationError";
   constructor(changeIndex, detail) {
     super(`change ${changeIndex}: ${detail}`);
     this.changeIndex = changeIndex;
     this.detail = detail;
+    this.name = "WorkspaceEditValidationError";
   }
 }
 
@@ -2285,14 +2766,14 @@ function parseSinglePathResource(input, kind) {
     return;
   }
   if (kind === "create") {
-    const options2 = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
+    const options = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
     target.operations.push({
       kind,
       changeIndex,
       path: resolvedPath.path,
       reportedPath: resolvedPath.requestedPath,
-      overwrite: options2["overwrite"] ?? false,
-      ignoreIfExists: options2["ignoreIfExists"] ?? false,
+      overwrite: options["overwrite"] ?? false,
+      ignoreIfExists: options["ignoreIfExists"] ?? false,
       followedSymbolicLink: resolvedPath.followedSymbolicLink
     });
     return;
@@ -2450,7 +2931,7 @@ function parseDocumentChange(input) {
 }
 
 // ../lsp-core/src/lsp/workspace-edit-simulation.ts
-import { dirname as dirname3, relative as relative4, resolve as resolve4 } from "node:path";
+import { dirname as dirname6, relative as relative4, resolve as resolve4 } from "node:path";
 
 // ../lsp-core/src/lsp/workspace-edit-text.ts
 function comparePosition(left, right) {
@@ -2574,7 +3055,7 @@ function virtualDirectoryHasChildren(virtual, path) {
   return false;
 }
 function requireVirtualParent(virtual, path, changeIndex) {
-  if (virtual.get(dirname3(path))?.kind !== "directory") {
+  if (virtual.get(dirname6(path))?.kind !== "directory") {
     throw new WorkspaceEditValidationError(changeIndex, `parent directory does not exist for ${path}`);
   }
 }
@@ -2694,13 +3175,12 @@ function simulateDelete(operation, virtual) {
 }
 
 // ../lsp-core/src/lsp/workspace-edit-snapshot.ts
-import { existsSync as existsSync5, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
-import { dirname as dirname4, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync6, lstatSync as lstatSync5, readdirSync as readdirSync2 } from "node:fs";
+import { dirname as dirname7, resolve as resolve5 } from "node:path";
 class WorkspaceSnapshotBuilder {
-  workspaceRoot;
-  snapshots = new Map;
   constructor(workspaceRoot) {
     this.workspaceRoot = workspaceRoot;
+    this.snapshots = new Map;
   }
   build(operations) {
     this.add(this.workspaceRoot, false);
@@ -2730,9 +3210,9 @@ class WorkspaceSnapshotBuilder {
       }
       if (candidate === this.workspaceRoot)
         break;
-      candidate = dirname4(candidate);
+      candidate = dirname7(candidate);
     }
-    if (!includeChildren || !existsSync5(path) || !lstatSync3(path).isDirectory())
+    if (!includeChildren || !existsSync6(path) || !lstatSync5(path).isDirectory())
       return;
     for (const child of readdirSync2(path))
       this.add(resolve5(path, child), true);
@@ -2744,8 +3224,10 @@ function snapshotOperations(operations, workspaceRoot) {
 
 // ../lsp-core/src/lsp/workspace-edit-plan.ts
 class PlanPathIndex {
-  firstChangeByPath = new Map;
-  reportedPathByCanonical = new Map;
+  constructor() {
+    this.firstChangeByPath = new Map;
+    this.reportedPathByCanonical = new Map;
+  }
   build(operations) {
     for (const operation of operations) {
       switch (operation.kind) {
@@ -2761,11 +3243,11 @@ class PlanPathIndex {
       }
     }
   }
-  add(path, reportedPath2, changeIndex) {
+  add(path, reportedPath, changeIndex) {
     if (!this.firstChangeByPath.has(path))
       this.firstChangeByPath.set(path, changeIndex);
     if (!this.reportedPathByCanonical.has(path))
-      this.reportedPathByCanonical.set(path, reportedPath2);
+      this.reportedPathByCanonical.set(path, reportedPath);
   }
 }
 function fingerprintWorkspaceEdit(edit, workspaceRoot) {
@@ -2834,14 +3316,11 @@ function isRecord4(value) {
 }
 
 class WorkspaceMutationController {
-  workspaceRoot;
-  documents;
-  activeLease = null;
-  nextLeaseId = 1;
-  io;
   constructor(workspaceRoot, documents) {
     this.workspaceRoot = workspaceRoot;
     this.documents = documents;
+    this.activeLease = null;
+    this.nextLeaseId = 1;
   }
   setIo(io) {
     this.io = io;
@@ -2880,15 +3359,15 @@ class WorkspaceMutationController {
       };
     }
     lease.phase = "applying";
-    lease.applyCompletion = new Promise((resolve6) => {
-      lease.resolveApply = resolve6;
+    lease.applyCompletion = new Promise((resolve) => {
+      lease.resolveApply = resolve;
     });
     const edit = isRecord4(params) ? params["edit"] : undefined;
-    const record2 = edit === undefined ? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) } : await this.applyEdit(edit, lease);
-    lease.serverApply = record2;
+    const record = edit === undefined ? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) } : await this.applyEdit(edit, lease);
+    lease.serverApply = record;
     lease.phase = "settled";
     lease.resolveApply?.();
-    return responseFor(record2.result);
+    return responseFor(record.result);
   }
   async reconcileRename(leaseToken, edit) {
     const lease = this.requireActiveLease(leaseToken);
@@ -2904,16 +3383,16 @@ class WorkspaceMutationController {
     const applied = await this.applyEdit(edit, lease);
     return { edit, apply: applied.result };
   }
-  reconcileServerApply(record2, edit) {
+  reconcileServerApply(record, edit) {
     if (!edit)
-      return { edit, apply: record2.result };
+      return { edit, apply: record.result };
     const fingerprint = fingerprintWorkspaceEdit(edit, this.workspaceRoot);
-    if (fingerprint.success && record2.fingerprint !== null && fingerprint.fingerprint === record2.fingerprint) {
-      return { edit, apply: record2.result };
+    if (fingerprint.success && record.fingerprint !== null && fingerprint.fingerprint === record.fingerprint) {
+      return { edit, apply: record.result };
     }
     return {
       edit,
-      apply: failure("rename result conflicts with server-applied workspace edit", 0, record2.result)
+      apply: failure("rename result conflicts with server-applied workspace edit", 0, record.result)
     };
   }
   async applyEdit(edit, lease) {
@@ -2954,14 +3433,12 @@ var DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3000;
 var VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
 
 class LspClient extends LspClientConnection {
-  diagnosticPullErrors = [];
-  documents;
-  workspaceMutations;
-  diagnosticsFreshnessTimeoutMs;
-  constructor(root, server2, options = {}) {
-    super(root, server2, options);
+  constructor(root, server, options = {}) {
+    super(root, server, options);
+    this.diagnosticPullErrors = [];
     this.diagnosticsFreshnessTimeoutMs = options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
     this.documents = new WorkspaceDocumentState((method, params) => this.sendNotification(method, params), (uri) => this.diagnosticsStore.delete(uri), {
+      timerProvider: this.timerProvider,
       versionlessPublishQuiescenceMs: options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS
     });
     this.workspaceMutations = new WorkspaceMutationController(root, this.documents);
@@ -3014,6 +3491,18 @@ class LspClient extends LspClientConnection {
       textDocument: { uri: pathToFileURL3(absPath).href }
     }, options);
   }
+  async formatDocument(filePath, options, signal) {
+    if (!this.isDocumentFormattingSupported())
+      return null;
+    const absPath = this.resolveWorkspacePath(filePath);
+    await this.openFile(absPath);
+    const requestOptions = signal === undefined ? {} : { signal };
+    const edits = await this.sendRequest("textDocument/formatting", {
+      textDocument: { uri: pathToFileURL3(absPath).href },
+      options
+    }, requestOptions);
+    return edits ?? [];
+  }
   async workspaceSymbols(query, signal) {
     const options = signal === undefined ? {} : { signal };
     return this.sendRequest("workspace/symbol", { query }, options);
@@ -3053,7 +3542,7 @@ class LspClient extends LspClientConnection {
     const absPath = this.resolveWorkspacePath(filePath);
     const uri = pathToFileURL3(absPath).href;
     await this.openFile(absPath);
-    const deadlineAt = Date.now() + this.diagnosticsFreshnessTimeoutMs;
+    const deadlineAt = this.timerProvider.now() + this.diagnosticsFreshnessTimeoutMs;
     for (;; ) {
       signal?.throwIfAborted();
       const snapshot = this.documents.captureDiagnosticSnapshot(absPath);
@@ -3066,13 +3555,13 @@ class LspClient extends LspClientConnection {
       if (!pushFallbackOnly) {
         const cached = this.documents.getPullCache(snapshot);
         try {
-          const remainingMs2 = deadlineAt - Date.now();
-          if (remainingMs2 <= 0)
+          const remainingMs = deadlineAt - this.timerProvider.now();
+          if (remainingMs <= 0)
             return this.freshnessTimeout(absPath);
           const result = await this.sendRequest("textDocument/diagnostic", {
             textDocument: { uri },
             ...cached?.resultId === undefined ? {} : { previousResultId: cached.resultId }
-          }, { timeoutMs: remainingMs2, ...signal === undefined ? {} : { signal } });
+          }, { timeoutMs: remainingMs, ...signal === undefined ? {} : { signal } });
           if (!this.documents.isCurrentSnapshot(snapshot))
             continue;
           const report = this.parseDiagnosticPullReport(result);
@@ -3101,7 +3590,7 @@ class LspClient extends LspClientConnection {
       }
       if (!pushFallbackOnly)
         continue;
-      const remainingMs = deadlineAt - Date.now();
+      const remainingMs = deadlineAt - this.timerProvider.now();
       if (remainingMs <= 0) {
         if (!this.isDiagnosticPullSupported() && snapshot.publishGeneration === 0) {
           const cached = this.documents.getPullCache(snapshot);
@@ -3153,7 +3642,7 @@ function waitForDiagnosticsActivity(wait, signal) {
     return wait;
   if (signal.aborted)
     return Promise.reject(abortError2(signal));
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve, reject) => {
     const onAbort = () => {
       signal.removeEventListener("abort", onAbort);
       reject(abortError2(signal));
@@ -3161,7 +3650,7 @@ function waitForDiagnosticsActivity(wait, signal) {
     signal.addEventListener("abort", onAbort, { once: true });
     wait.then(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve7();
+      resolve();
     }, (error) => {
       signal.removeEventListener("abort", onAbort);
       reject(error);
@@ -3229,7 +3718,7 @@ async function stopClientBestEffort(client) {
 function awaitWithSignal(promise, signal) {
   if (!signal)
     return promise;
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const onAbort = () => {
       if (settled)
@@ -3247,7 +3736,7 @@ function awaitWithSignal(promise, signal) {
         return;
       settled = true;
       signal.removeEventListener("abort", onAbort);
-      resolve7(value);
+      resolve(value);
     }, (err) => {
       if (settled)
         return;
@@ -3259,20 +3748,18 @@ function awaitWithSignal(promise, signal) {
 }
 
 class LspManager {
-  clients = new Map;
-  reaperHandle = null;
-  signalDisposer = null;
-  disposed = false;
-  idleTimeoutMs;
-  initTimeoutMs;
-  reaperIntervalMs;
-  clientFactory;
-  now;
   constructor(options = {}) {
+    this.clients = new Map;
+    this.pendingStops = new Map;
+    this.respawnBudgets = new Map;
+    this.reaperHandle = null;
+    this.signalDisposer = null;
+    this.disposed = false;
     this.idleTimeoutMs = options.idleTimeoutMs ?? IDLE_TIMEOUT_MS;
     this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS;
+    this.maxResidentClients = options.maxResidentClients ?? MAX_RESIDENT_CLIENTS;
     this.reaperIntervalMs = options.reaperIntervalMs ?? REAPER_INTERVAL_MS;
-    this.clientFactory = options.clientFactory ?? ((root, server2) => new LspClient(root, server2));
+    this.clientFactory = options.clientFactory ?? ((root, server) => new LspClient(root, server));
     this.now = options.now ?? (() => Date.now());
     this.startReaper();
     this.signalDisposer = installProcessSignalCleanup(() => this.stopAll());
@@ -3290,38 +3777,103 @@ class LspManager {
   getKey(root, serverId) {
     return `${root}::${serverId}`;
   }
+  tombstoneStop(key, client) {
+    const stop = stopClientBestEffort(client);
+    this.pendingStops.set(key, stop);
+    stop.finally(() => {
+      if (this.pendingStops.get(key) === stop) {
+        this.pendingStops.delete(key);
+      }
+    });
+    return stop;
+  }
+  recordDeadGeneration(key) {
+    let budget = this.respawnBudgets.get(key);
+    if (budget === undefined) {
+      budget = { deadGenerations: 0, exhaustedAt: null };
+      this.respawnBudgets.set(key, budget);
+    }
+    budget.deadGenerations += 1;
+  }
+  markHealthyGeneration(key) {
+    this.respawnBudgets.delete(key);
+  }
+  ensureRespawnAllowed(key, root, serverId) {
+    const budget = this.respawnBudgets.get(key);
+    if (budget === undefined || budget.deadGenerations < CLIENT_RESPAWN_RETRY_LIMIT)
+      return;
+    if (budget.exhaustedAt === null) {
+      budget.exhaustedAt = this.now();
+      throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+    }
+    if (this.now() - budget.exhaustedAt < CLIENT_RESPAWN_COOLDOWN_MS) {
+      throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+    }
+    budget.deadGenerations = 0;
+    budget.exhaustedAt = null;
+  }
   reapStale() {
     const t = this.now();
     for (const [key, managed] of this.clients) {
       if (managed.isInitializing && managed.initializingSince !== null && t - managed.initializingSince > this.initTimeoutMs) {
-        stopClientBestEffort(managed.client);
         this.clients.delete(key);
+        this.tombstoneStop(key, managed.client);
         continue;
       }
       if (!managed.isInitializing && managed.refCount === 0 && managed.pendingWaiters === 0 && t - managed.lastUsedAt > this.idleTimeoutMs) {
-        stopClientBestEffort(managed.client);
         this.clients.delete(key);
+        this.tombstoneStop(key, managed.client);
+      }
+    }
+  }
+  evictForAdmission() {
+    while (this.clients.size >= this.maxResidentClients) {
+      const victim = this.leastRecentlyUsedIdleClient();
+      if (!victim)
+        return;
+      this.clients.delete(victim.key);
+      this.tombstoneStop(victim.key, victim.managed.client);
+    }
+  }
+  leastRecentlyUsedIdleClient() {
+    let candidate = null;
+    for (const [key, managed] of this.clients) {
+      if (managed.refCount > 0 || managed.pendingWaiters > 0 || managed.isInitializing)
+        continue;
+      if (candidate === null || managed.lastUsedAt < candidate.managed.lastUsedAt) {
+        candidate = { key, managed };
       }
     }
+    return candidate;
   }
   async tryDeleteIfOrphaned(key, managed) {
     if (managed.refCount === 0 && managed.pendingWaiters === 0 && !managed.isInitializing && this.clients.get(key) === managed) {
       this.clients.delete(key);
-      await stopClientBestEffort(managed.client);
+      await this.tombstoneStop(key, managed.client);
     }
   }
-  async getClient(root, server2, signal) {
+  async getClient(root, server, signal) {
     if (this.disposed) {
       throw new Error("LspManager has been disposed");
     }
     signal?.throwIfAborted();
-    const key = this.getKey(root, server2.id);
+    const key = this.getKey(root, server.id);
+    for (;; ) {
+      const pendingStop = this.pendingStops.get(key);
+      if (pendingStop === undefined)
+        break;
+      await awaitWithSignal(pendingStop, signal);
+      signal?.throwIfAborted();
+    }
+    if (this.disposed) {
+      throw new Error("LspManager has been disposed");
+    }
     let managed = this.clients.get(key);
     if (managed) {
       const t = this.now();
       if (managed.isInitializing && managed.initializingSince !== null && t - managed.initializingSince > this.initTimeoutMs) {
-        await stopClientBestEffort(managed.client);
         this.clients.delete(key);
+        await this.tombstoneStop(key, managed.client);
         managed = undefined;
       }
     }
@@ -3342,15 +3894,21 @@ class LspManager {
         signal.throwIfAborted();
       }
       if (!managed.client.isAlive()) {
-        await stopClientBestEffort(managed.client);
-        this.clients.delete(key);
-        return this.getClient(root, server2, signal);
+        this.recordDeadGeneration(key);
+        if (this.clients.get(key) === managed) {
+          this.clients.delete(key);
+        }
+        await this.tombstoneStop(key, managed.client);
+        return this.getClient(root, server, signal);
       }
+      this.markHealthyGeneration(key);
       managed.refCount++;
       managed.lastUsedAt = this.now();
       return managed.client;
     }
-    const client = this.clientFactory(root, server2);
+    this.evictForAdmission();
+    this.ensureRespawnAllowed(key, root, server.id);
+    const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
       await client.start();
@@ -3373,7 +3931,7 @@ class LspManager {
       if (this.clients.get(key) === newManaged) {
         this.clients.delete(key);
       }
-      await stopClientBestEffort(client);
+      await this.tombstoneStop(key, client);
       throw err;
     }
     newManaged.pendingWaiters--;
@@ -3384,6 +3942,15 @@ class LspManager {
       await this.tryDeleteIfOrphaned(key, newManaged);
       signal.throwIfAborted();
     }
+    if (!client.isAlive()) {
+      this.recordDeadGeneration(key);
+      if (this.clients.get(key) === newManaged) {
+        this.clients.delete(key);
+      }
+      await this.tombstoneStop(key, client);
+      return this.getClient(root, server, signal);
+    }
+    this.markHealthyGeneration(key);
     newManaged.refCount++;
     newManaged.lastUsedAt = this.now();
     return client;
@@ -3404,15 +3971,21 @@ class LspManager {
     if (client && managed.client !== client)
       return;
     this.clients.delete(key);
-    stopClientBestEffort(managed.client);
+    this.tombstoneStop(key, managed.client);
   }
-  warmupClient(root, server2) {
+  warmupClient(root, server) {
     if (this.disposed)
       return;
-    const key = this.getKey(root, server2.id);
-    if (this.clients.has(key))
+    const key = this.getKey(root, server.id);
+    if (this.clients.has(key) || this.pendingStops.has(key))
+      return;
+    this.evictForAdmission();
+    try {
+      this.ensureRespawnAllowed(key, root, server.id);
+    } catch {
       return;
-    const client = this.clientFactory(root, server2);
+    }
+    const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
       await client.start();
@@ -3437,7 +4010,7 @@ class LspManager {
       if (this.clients.get(key) === managed) {
         this.clients.delete(key);
       }
-      stopClientBestEffort(client);
+      this.tombstoneStop(key, client);
     });
   }
   isServerInitializing(root, serverId) {
@@ -3481,8 +4054,11 @@ class LspManager {
     for (const managed of this.clients.values()) {
       stopPromises.push(stopClientBestEffort(managed.client));
     }
+    const tombstonedStops = [...this.pendingStops.values()];
     this.clients.clear();
-    await Promise.allSettled(stopPromises);
+    this.respawnBudgets.clear();
+    await Promise.allSettled([...stopPromises, ...tombstonedStops]);
+    this.pendingStops.clear();
   }
 }
 var _defaultInstance = null;
@@ -3500,57 +4076,52 @@ async function disposeDefaultLspManager() {
   }
 }
 
-// ../lsp-core/src/lsp/server-install-state.ts
-import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
-function getInstallDecisionsPath() {
-  return lspRequestContext().installDecisionsPath;
-}
-function loadInstallDecisions() {
-  const path = getInstallDecisionsPath();
-  if (!existsSync6(path))
-    return {};
-  try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
-    return isInstallDecisions(parsed) ? parsed : {};
-  } catch {
-    return {};
+// ../lsp-core/src/lsp/outside-context-workspace.ts
+import { existsSync as existsSync7, realpathSync as realpathSync4 } from "node:fs";
+import { dirname as dirname8, join as join3 } from "node:path";
+
+// ../lsp-core/src/lsp/workspace-markers.ts
+var GIT_WORKSPACE_MARKER = ".git";
+var PROJECT_WORKSPACE_MARKERS = [
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle"
+];
+var WORKSPACE_MARKERS = [GIT_WORKSPACE_MARKER, ...PROJECT_WORKSPACE_MARKERS];
+
+// ../lsp-core/src/lsp/outside-context-workspace.ts
+function findWorkspaceRootOutsideContext(directory) {
+  const marked = nearestMarkedAncestor(directory);
+  if (marked !== undefined)
+    return marked;
+  return realpathSync4(nearestExistingAncestor(directory));
+}
+function nearestMarkedAncestor(directory) {
+  let current = directory;
+  for (;; ) {
+    if (existsSync7(current) && WORKSPACE_MARKERS.some((marker) => existsSync7(join3(current, marker)))) {
+      return realpathSync4(current);
+    }
+    const parent = dirname8(current);
+    if (parent === current)
+      return;
+    current = parent;
   }
 }
-function loadInstallDecision(serverId) {
-  return loadInstallDecisions()[serverId];
-}
-function recordInstallDecision(serverId, decision, decidedAt = new Date().toISOString()) {
-  const decisions = loadInstallDecisions();
-  decisions[serverId] = { decision, decidedAt };
-  writeInstallDecisions(decisions);
-}
-function isInstallDecision(value) {
-  return value === "declined" || value === "allowed";
-}
-function writeInstallDecisions(decisions) {
-  const path = getInstallDecisionsPath();
-  mkdirSync(dirname5(path), { recursive: true });
-  const tmpPath = `${path}.tmp`;
-  writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
-`, "utf8");
-  renameSync2(tmpPath, path);
-}
-function isInstallDecisions(value) {
-  return isRecord5(value) && Object.values(value).every(isInstallDecisionRecord);
-}
-function isInstallDecisionRecord(value) {
-  if (!isRecord5(value))
-    return false;
-  return isInstallDecision(value["decision"]) && typeof value["decidedAt"] === "string";
-}
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function nearestExistingAncestor(directory) {
+  let current = directory;
+  while (!existsSync7(current)) {
+    const parent = dirname8(current);
+    if (parent === current)
+      return current;
+    current = parent;
+  }
+  return current;
 }
 
-// ../lsp-core/src/lsp/config-loader.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
-
 // ../lsp-core/src/lsp/server-definitions.ts
 var LSP_INSTALL_HINTS = {
   typescript: "npm install -g typescript-language-server typescript",
@@ -3596,6 +4167,26 @@ var LSP_INSTALL_HINTS = {
   julials: `julia -e 'using Pkg; Pkg.add("LanguageServer")'`,
   razor: "Razor runs through the Roslyn language server (cohosting). " + "Install: dotnet tool install -g roslyn-language-server --prerelease (requires v5.8.0+). See https://github.com/dotnet/razor"
 };
+var LSP_LOCAL_INSTALL_HINTS = {
+  typescript: "bun add -d typescript-language-server typescript",
+  vue: "bun add -d @vue/language-server",
+  eslint: "bun add -d vscode-langservers-extracted",
+  oxlint: "bun add -d oxlint",
+  biome: "bun add -d @biomejs/biome",
+  svelte: "bun add -d svelte-language-server",
+  astro: "bun add -d @astrojs/language-server",
+  bash: "bun add -d bash-language-server",
+  "bash-ls": "bun add -d bash-language-server",
+  "yaml-ls": "bun add -d yaml-language-server",
+  php: "bun add -d intelephense",
+  prisma: "bun add -d prisma",
+  dockerfile: "bun add -d dockerfile-language-server-nodejs",
+  pyright: "uv add --dev pyright",
+  basedpyright: "uv add --dev basedpyright",
+  ruff: "uv add --dev ruff",
+  ty: "uv add --dev ty",
+  "ruby-lsp": "bundle add ruby-lsp --group development"
+};
 var BUILTIN_SERVERS = {
   typescript: {
     command: ["typescript-language-server", "--stdio"],
@@ -3698,7 +4289,56 @@ var BUILTIN_SERVERS = {
   }
 };
 
+// ../lsp-core/src/lsp/server-install-state.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname9 } from "node:path";
+function getInstallDecisionsPath() {
+  return lspRequestContext().installDecisionsPath;
+}
+function loadInstallDecisions() {
+  const path = getInstallDecisionsPath();
+  if (!existsSync8(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    return isInstallDecisions(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function loadInstallDecision(serverId) {
+  return loadInstallDecisions()[serverId];
+}
+function recordInstallDecision(serverId, decision, decidedAt = new Date().toISOString()) {
+  const decisions = loadInstallDecisions();
+  decisions[serverId] = { decision, decidedAt };
+  writeInstallDecisions(decisions);
+}
+function isInstallDecision(value) {
+  return value === "declined" || value === "allowed";
+}
+function writeInstallDecisions(decisions) {
+  const path = getInstallDecisionsPath();
+  mkdirSync3(dirname9(path), { recursive: true });
+  const tmpPath = `${path}.tmp`;
+  writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
+`, "utf8");
+  renameSync2(tmpPath, path);
+}
+function isInstallDecisions(value) {
+  return isRecord5(value) && Object.values(value).every(isInstallDecisionRecord);
+}
+function isInstallDecisionRecord(value) {
+  if (!isRecord5(value))
+    return false;
+  return isInstallDecision(value["decision"]) && typeof value["decidedAt"] === "string";
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // ../lsp-core/src/lsp/config-loader.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
 function getProjectConfigPaths() {
   return lspRequestContext().projectConfigPaths;
 }
@@ -3706,10 +4346,10 @@ function getUserConfigPath() {
   return lspRequestContext().userConfigPath;
 }
 function loadJsonFile(path) {
-  if (!existsSync7(path))
+  if (!existsSync9(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
     return isConfigJson(parsed) ? parsed : null;
   } catch {
     return null;
@@ -3753,10 +4393,10 @@ function getMergedServers() {
       }
       if (seen.has(id))
         continue;
-      const server2 = createServerFromEntry(id, entry, source);
-      if (!server2)
+      const server = createServerFromEntry(id, entry, source);
+      if (!server)
         continue;
-      servers.push(server2);
+      servers.push(server);
       seen.add(id);
     }
   }
@@ -3788,7 +4428,7 @@ function createServerFromEntry(id, entry, source) {
   if (source === "project") {
     if (!builtin)
       return null;
-    const server3 = createServer({
+    const server = createServer({
       id,
       command: builtin.command,
       extensions: entry.extensions ?? builtin.extensions,
@@ -3796,35 +4436,35 @@ function createServerFromEntry(id, entry, source) {
       source
     });
     if (entry.initialization !== undefined) {
-      server3.initialization = entry.initialization;
+      server.initialization = entry.initialization;
     }
-    return server3;
+    return server;
   }
   if (entry.command && entry.extensions) {
-    const server3 = createServer({
+    const server = createServer({
       id,
       command: entry.command,
       extensions: entry.extensions,
       priority: entry.priority ?? 0,
       source
     });
-    applyOptionalServerFields(server3, entry);
-    return server3;
+    applyOptionalServerFields(server, entry);
+    return server;
   }
   if (!builtin)
     return null;
-  const server2 = createServer({
+  const server = createServer({
     id,
     command: entry.command ?? builtin.command,
     extensions: entry.extensions ?? builtin.extensions,
     priority: entry.priority ?? 0,
     source
   });
-  applyOptionalServerFields(server2, entry);
-  return server2;
+  applyOptionalServerFields(server, entry);
+  return server;
 }
 function createServer(input) {
-  const server2 = {
+  const server = {
     id: input.id,
     command: input.command,
     extensions: input.extensions,
@@ -3832,19 +4472,19 @@ function createServer(input) {
     source: input.source
   };
   if (input.env !== undefined) {
-    server2.env = input.env;
+    server.env = input.env;
   }
   if (input.initialization !== undefined) {
-    server2.initialization = input.initialization;
+    server.initialization = input.initialization;
   }
-  return server2;
+  return server;
 }
-function applyOptionalServerFields(server2, entry) {
+function applyOptionalServerFields(server, entry) {
   if (entry.env !== undefined) {
-    server2.env = entry.env;
+    server.env = entry.env;
   }
   if (entry.initialization !== undefined) {
-    server2.initialization = entry.initialization;
+    server.initialization = entry.initialization;
   }
 }
 function isConfigJson(value) {
@@ -3894,64 +4534,165 @@ function getDisabledServerIds() {
 }
 
 // ../lsp-core/src/lsp/server-installation.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { delimiter as delimiter3, join as join3 } from "node:path";
-function isServerInstalled(command, _workingDirectory) {
-  if (command.length === 0)
-    return false;
-  const [cmd] = command;
-  if (!cmd)
-    return false;
-  if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync8(cmd))
-      return true;
+import { existsSync as existsSync10 } from "node:fs";
+import { delimiter as delimiter3, dirname as dirname10, isAbsolute as isAbsolute3, join as join4, resolve as resolve7 } from "node:path";
+var LOCAL_BIN_RULES = [
+  {
+    markers: ["package.json", "bun.lock", "bun.lockb", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"],
+    binDirs: [join4("node_modules", ".bin")]
+  },
+  {
+    markers: [
+      "pyproject.toml",
+      "ty.toml",
+      "requirements.txt",
+      "setup.py",
+      "setup.cfg",
+      "Pipfile",
+      "pyrightconfig.json",
+      "ruff.toml",
+      ".ruff.toml"
+    ],
+    binDirs: [
+      join4(".venv", "bin"),
+      join4(".venv", "Scripts"),
+      join4("venv", "bin"),
+      join4("venv", "Scripts"),
+      join4(".env", "bin"),
+      join4(".env", "Scripts")
+    ]
+  },
+  {
+    markers: ["Gemfile", "Gemfile.lock"],
+    binDirs: [join4("vendor", "bundle", "bin"), "bin"]
+  },
+  {
+    markers: ["go.mod", "go.sum", "go.work"],
+    binDirs: ["bin"]
+  }
+];
+var resolutionCache = new Map;
+var probeCount = 0;
+function probe(path) {
+  probeCount += 1;
+  return existsSync10(path);
+}
+function executableSuffixes(platform, pathExt) {
+  if (platform !== "win32")
+    return [""];
+  const configured = pathExt ?? process.env["PATHEXT"] ?? "";
+  const systemExts = configured.split(";").filter((entry) => entry.length > 0).map((entry) => entry.toLowerCase());
+  return [...new Set(["", ...systemExts, ".exe", ".cmd", ".bat", ".ps1"])];
+}
+function probeWithSuffixes(directory, command, suffixes) {
+  for (const suffix of suffixes) {
+    const candidate = join4(directory, command + suffix);
+    if (probe(candidate))
+      return candidate;
   }
-  const isWindows = process.platform === "win32";
-  let exts = [""];
-  if (isWindows) {
-    const pathExt = process.env["PATHEXT"] ?? "";
-    if (pathExt) {
-      const systemExts = pathExt.split(";").filter(Boolean);
-      exts = [...new Set([...exts, ...systemExts, ".exe", ".cmd", ".bat", ".ps1"])];
-    } else {
-      exts = ["", ".exe", ".cmd", ".bat", ".ps1"];
+  return null;
+}
+function resolveLocal(command, workingDirectory, suffixes, stopAt) {
+  const boundary = stopAt === undefined ? undefined : resolve7(stopAt);
+  let current = resolve7(workingDirectory);
+  while (true) {
+    for (const rule of LOCAL_BIN_RULES) {
+      if (!rule.markers.some((marker) => probe(join4(current, marker))))
+        continue;
+      for (const binDir of rule.binDirs) {
+        const found = probeWithSuffixes(join4(current, binDir), command, suffixes);
+        if (found !== null)
+          return found;
+      }
     }
+    if (probe(join4(current, ".git")))
+      return null;
+    if (boundary !== undefined && current === boundary)
+      return null;
+    const parent = dirname10(current);
+    if (parent === current)
+      return null;
+    current = parent;
   }
-  let pathEnv = process.env["PATH"] ?? "";
-  if (isWindows && !pathEnv) {
+}
+function resolveFromPath(command, suffixes, platform, pathEnvOverride) {
+  let pathEnv = pathEnvOverride ?? process.env["PATH"] ?? "";
+  if (platform === "win32" && !pathEnv) {
     pathEnv = process.env["Path"] ?? "";
   }
-  const paths = pathEnv.split(delimiter3);
-  for (const p of paths) {
-    for (const suffix of exts) {
-      if (existsSync8(join3(p, cmd + suffix))) {
-        return true;
-      }
-    }
+  for (const entry of pathEnv.split(delimiter3)) {
+    if (entry.length === 0)
+      continue;
+    const found = probeWithSuffixes(entry, command, suffixes);
+    if (found !== null)
+      return found;
   }
-  if (cmd === "node")
-    return true;
-  return false;
+  return null;
+}
+function resolveServerBinary(command, workingDirectory, options = {}) {
+  if (command.length === 0)
+    return null;
+  const [cmd] = command;
+  if (cmd === undefined || cmd.length === 0)
+    return null;
+  const platform = options.platform ?? process.platform;
+  const suffixes = executableSuffixes(platform, options.pathExt);
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    const explicit = isAbsolute3(cmd) ? cmd : resolve7(workingDirectory ?? process.cwd(), cmd);
+    return probe(explicit) ? explicit : null;
+  }
+  const cacheKey = JSON.stringify([
+    workingDirectory ?? "",
+    cmd,
+    platform,
+    options.stopAt ?? "",
+    options.pathExt ?? "",
+    options.pathEnv ?? process.env["PATH"] ?? ""
+  ]);
+  const cached = resolutionCache.get(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  let resolved = null;
+  if (workingDirectory !== undefined && workingDirectory.length > 0) {
+    resolved = resolveLocal(cmd, workingDirectory, suffixes, options.stopAt);
+  }
+  resolved ??= resolveFromPath(cmd, suffixes, platform, options.pathEnv);
+  if (resolved === null && cmd === "node")
+    resolved = cmd;
+  resolutionCache.set(cacheKey, resolved);
+  return resolved;
+}
+function isServerInstalled(command, workingDirectory, options = {}) {
+  if (command.length === 0)
+    return false;
+  return resolveServerBinary(command, workingDirectory, options) !== null;
 }
 
 // ../lsp-core/src/lsp/server-resolution.ts
+function withResolvedCommand(command, binaryPath) {
+  return [binaryPath, ...command.slice(1)];
+}
 function findServerForExtension(ext) {
   const servers = getMergedServers();
-  for (const server2 of servers) {
-    if (server2.extensions.includes(ext) && isServerInstalled(server2.command)) {
+  const workingDirectory = contextCwd();
+  for (const server of servers) {
+    if (!server.extensions.includes(ext))
+      continue;
+    const binaryPath = resolveServerBinary(server.command, workingDirectory);
+    if (binaryPath !== null) {
       const resolvedServer = {
-        id: server2.id,
-        command: server2.command,
-        extensions: server2.extensions,
-        priority: server2.priority
+        id: server.id,
+        command: withResolvedCommand(server.command, binaryPath),
+        extensions: server.extensions,
+        priority: server.priority
       };
-      if (server2.env !== undefined) {
+      if (server.env !== undefined) {
         return {
           status: "found",
           server: {
             ...resolvedServer,
-            env: server2.env,
-            ...server2.initialization === undefined ? {} : { initialization: server2.initialization }
+            env: server.env,
+            ...server.initialization === undefined ? {} : { initialization: server.initialization }
           }
         };
       }
@@ -3959,20 +4700,20 @@ function findServerForExtension(ext) {
         status: "found",
         server: {
           ...resolvedServer,
-          ...server2.initialization === undefined ? {} : { initialization: server2.initialization }
+          ...server.initialization === undefined ? {} : { initialization: server.initialization }
         }
       };
     }
   }
-  for (const server2 of servers) {
-    if (server2.extensions.includes(ext)) {
-      const installHint = LSP_INSTALL_HINTS[server2.id] ?? `Install '${server2.command[0]}' and ensure it's in your PATH`;
+  for (const server of servers) {
+    if (server.extensions.includes(ext)) {
+      const installHint = LSP_INSTALL_HINTS[server.id] ?? `Install '${server.command[0]}' and ensure it's in your PATH`;
       return {
         status: "not_installed",
         server: {
-          id: server2.id,
-          command: server2.command,
-          extensions: server2.extensions
+          id: server.id,
+          command: server.command,
+          extensions: server.extensions
         },
         installHint
       };
@@ -3988,20 +4729,21 @@ function findServerForExtension(ext) {
 function getAllServers() {
   const servers = getMergedServers();
   const disabled = getDisabledServerIds();
+  const workingDirectory = contextCwd();
   const result = [];
   const seen = new Set;
-  for (const server2 of servers) {
-    if (seen.has(server2.id))
+  for (const server of servers) {
+    if (seen.has(server.id))
       continue;
     result.push({
-      id: server2.id,
-      installed: isServerInstalled(server2.command),
-      extensions: server2.extensions,
+      id: server.id,
+      installed: isServerInstalled(server.command, workingDirectory),
+      extensions: server.extensions,
       disabled: false,
-      source: server2.source,
-      priority: server2.priority
+      source: server.source,
+      priority: server.priority
     });
-    seen.add(server2.id);
+    seen.add(server.id);
   }
   for (const id of disabled) {
     if (seen.has(id))
@@ -4009,7 +4751,7 @@ function getAllServers() {
     const builtin = BUILTIN_SERVERS[id];
     result.push({
       id,
-      installed: builtin ? isServerInstalled(builtin.command) : false,
+      installed: builtin ? isServerInstalled(builtin.command, workingDirectory) : false,
       extensions: builtin?.extensions ?? [],
       disabled: true,
       source: "disabled",
@@ -4020,10 +4762,9 @@ function getAllServers() {
 }
 
 // ../lsp-core/src/lsp/client-wrapper.ts
-var WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
 function isDirectoryPath(filePath) {
   try {
-    return statSync3(filePath).isDirectory();
+    return statSync4(filePath).isDirectory();
   } catch {
     return false;
   }
@@ -4033,36 +4774,40 @@ function findWorkspaceRoot(filePath) {
   const abs = resolveReadablePathInsideContext(filePath);
   let dir = abs;
   if (!isDirectoryPath(dir)) {
-    dir = dirname6(dir);
+    dir = dirname11(dir);
   }
+  if (!isPathInside(cwd, abs))
+    return findWorkspaceRootOutsideContext(dir);
   const fallbackRoot = nearestExistingDirectoryInsideContext(dir, cwd) ?? cwd;
+  let nearestPackageRoot;
   while (isPathInside(cwd, dir)) {
     const canonicalDir = existingDirectoryInsideContext(dir, cwd);
     if (canonicalDir !== undefined) {
-      for (const marker of WORKSPACE_MARKERS) {
-        if (existsSync9(join4(dir, marker))) {
-          return canonicalDir;
-        }
+      if (existsSync11(join5(dir, GIT_WORKSPACE_MARKER))) {
+        return canonicalDir;
+      }
+      if (nearestPackageRoot === undefined && hasProjectWorkspaceMarker(dir)) {
+        nearestPackageRoot = canonicalDir;
       }
     }
     if (dir === cwd)
       break;
-    dir = dirname6(dir);
+    dir = dirname11(dir);
   }
-  return fallbackRoot;
+  return nearestPackageRoot ?? fallbackRoot;
+}
+function hasProjectWorkspaceMarker(directory) {
+  return PROJECT_WORKSPACE_MARKERS.some((marker) => existsSync11(join5(directory, marker)));
 }
 function resolveReadablePathInsideContext(filePath) {
   const cwd = contextCwd();
-  const abs = resolve7(cwd, filePath);
+  const abs = resolve8(cwd, filePath);
   if (isPathInside(cwd, abs))
     return abs;
   const rebased = rebaseThroughCanonicalAncestor(abs, cwd);
   if (rebased !== undefined)
     return rebased;
-  const canonical = canonicalizeExistingOrNearestAncestor(abs);
-  if (isPathInside(cwd, canonical))
-    return canonical;
-  throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
+  return canonicalizeExistingOrNearestAncestor(abs);
 }
 function resolvePathInsideContext(filePath) {
   const cwd = contextCwd();
@@ -4077,12 +4822,12 @@ function rebaseThroughCanonicalAncestor(path, cwd) {
   let current = path;
   const suffix = [];
   while (true) {
-    if (existsSync9(current)) {
-      const canonical = realpathSync4(current);
+    if (existsSync11(current)) {
+      const canonical = realpathSync5(current);
       if (isPathInside(cwd, canonical))
-        return suffix.length === 0 ? canonical : join4(canonical, ...suffix);
+        return suffix.length === 0 ? canonical : join5(canonical, ...suffix);
     }
-    const parent = dirname6(current);
+    const parent = dirname11(current);
     if (parent === current)
       return;
     suffix.unshift(basename3(current));
@@ -4090,10 +4835,10 @@ function rebaseThroughCanonicalAncestor(path, cwd) {
   }
 }
 function existingDirectoryInsideContext(directory, cwd) {
-  if (!existsSync9(directory))
+  if (!existsSync11(directory))
     return;
-  const canonical = realpathSync4(directory);
-  if (!statSync3(canonical).isDirectory())
+  const canonical = realpathSync5(directory);
+  if (!statSync4(canonical).isDirectory())
     return;
   return isPathInside(cwd, canonical) ? canonical : undefined;
 }
@@ -4105,7 +4850,7 @@ function nearestExistingDirectoryInsideContext(directory, cwd) {
       return canonical;
     if (current === cwd)
       return;
-    current = dirname6(current);
+    current = dirname11(current);
   }
   return;
 }
@@ -4132,33 +4877,46 @@ function formatServerLookupError(result) {
   ].join(`
 `);
 }
+function formatInstallOptions(serverId, installHint) {
+  const localHint = LSP_LOCAL_INSTALL_HINTS[serverId];
+  if (localHint === undefined) {
+    return ["To install, run:", `  ${installHint}`];
+  }
+  return [
+    "To install in THIS repository (preferred — no global install needed):",
+    `  ${localHint}`,
+    "",
+    "Or install it globally:",
+    `  ${installHint}`
+  ];
+}
 function formatNotInstalled(result) {
-  const { server: server2, installHint } = result;
-  const extensions = server2.extensions.join(", ");
-  const decision = loadInstallDecision(server2.id)?.decision;
+  const { server, installHint } = result;
+  const extensions = server.extensions.join(", ");
+  const decision = loadInstallDecision(server.id)?.decision;
   const context = lspRequestContext();
   if (decision === "declined") {
-    return `LSP server '${server2.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
+    return `LSP server '${server.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
   }
   const header = [
-    `LSP server '${server2.id}' for ${extensions} is NOT INSTALLED.`,
+    `LSP server '${server.id}' for ${extensions} is NOT INSTALLED.`,
     "",
-    `Command not found: ${server2.command[0]}`,
+    `Command not found: ${server.command[0]}`,
     ""
   ];
+  const installOptions = formatInstallOptions(server.id, installHint);
   if (decision === "allowed") {
     return [
       ...header,
       "The user has pre-authorized LSP installation. Run the install command, then retry this tool:",
-      `  ${installHint}`
+      ...installOptions.slice(1)
     ].join(`
 `);
   }
   if (!context.capabilities.installDecisionTool) {
     return [
       ...header,
-      "To install, run:",
-      `  ${installHint}`,
+      ...installOptions,
       "",
       "ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
       "Install-decision recording is unavailable in this harness; proceed without LSP if the user declines."
@@ -4167,13 +4925,12 @@ function formatNotInstalled(result) {
   }
   return [
     ...header,
-    "To install, run:",
-    `  ${installHint}`,
+    ...installOptions,
     "",
     "ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
     "- If the user agrees: run the install command above, then retry this tool.",
     "- If the user declines, OR has NOT explicitly asked for LSP installation:",
-    `    call lsp_install_decision { server_id: "${server2.id}", decision: "declined" },`,
+    `    call lsp_install_decision { server_id: "${server.id}", decision: "declined" },`,
     `    which writes to ${context.installDecisionsPath},`,
     "    then ignore this message and proceed WITHOUT LSP."
   ].join(`
@@ -4197,34 +4954,34 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
   if (result.status !== "found") {
     throw new LspServerLookupError(formatServerLookupError(result), result);
   }
-  const server2 = result.server;
+  const server = result.server;
   const root = findWorkspaceRoot(absPath);
   const manager = options.manager ?? getLspManager();
   const acquireAndCall = async (allowRetry) => {
-    const client = await manager.getClient(root, server2, options.signal);
+    const client = await manager.getClient(root, server, options.signal);
     try {
       return await fn(client, root, absPath);
     } catch (err) {
       if (allowRetry && READ_ONLY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
-        manager.invalidateClient(root, server2.id, client);
+        manager.invalidateClient(root, server.id, client);
         return acquireAndCall(false);
       }
       if (err instanceof LspRequestTimeoutError) {
-        if (manager.isServerInitializing(root, server2.id)) {
+        if (manager.isServerInitializing(root, server.id)) {
           throw new LspServerInitializingError(err);
         }
       }
       throw err;
     } finally {
-      manager.releaseClient(root, server2.id);
+      manager.releaseClient(root, server.id);
     }
   };
   return acquireAndCall(true);
 }
 
 // ../lsp-core/src/lsp/directory-diagnostics.ts
-import { existsSync as existsSync10, lstatSync as lstatSync4, readdirSync as readdirSync3 } from "node:fs";
-import { join as join5, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync12, lstatSync as lstatSync6, readdirSync as readdirSync3 } from "node:fs";
+import { join as join6, resolve as resolve9 } from "node:path";
 
 // ../lsp-core/src/lsp/formatters.ts
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -4239,10 +4996,10 @@ function uriToPath(uri) {
 }
 function formatLocation(loc) {
   if ("targetUri" in loc) {
-    const uri2 = uriToPath(loc.targetUri);
-    const line2 = loc.targetRange.start.line + 1;
-    const char2 = loc.targetRange.start.character;
-    return `${uri2}:${line2}:${char2}`;
+    const uri = uriToPath(loc.targetUri);
+    const line = loc.targetRange.start.line + 1;
+    const char = loc.targetRange.start.character;
+    return `${uri}:${line}:${char}`;
   }
   const uri = uriToPath(loc.uri);
   const line = loc.range.start.line + 1;
@@ -4354,10 +5111,10 @@ function collectFilesWithExtension(dir, extension, maxFiles) {
     for (const entry of entries) {
       if (files.length >= maxFiles)
         return;
-      const fullPath = join5(currentDir, entry);
+      const fullPath = join6(currentDir, entry);
       let stat;
       try {
-        stat = lstatSync4(fullPath);
+        stat = lstatSync6(fullPath);
       } catch {
         continue;
       }
@@ -4379,15 +5136,15 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   if (!extension.startsWith(".")) {
     throw new LspInvalidPathError(`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`);
   }
-  const absDir = resolve8(options.workspaceRoot ?? contextCwd(), directory);
-  if (!existsSync10(absDir)) {
+  const absDir = resolve9(options.workspaceRoot ?? contextCwd(), directory);
+  if (!existsSync12(absDir)) {
     throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
   }
   const serverResult = options.server === undefined ? findServerForExtension(extension) : { status: "found", server: options.server };
   if (serverResult.status !== "found") {
     throw new LspServerLookupError(formatServerLookupError(serverResult));
   }
-  const server2 = serverResult.server;
+  const server = serverResult.server;
   const allFiles = (options.listFiles ?? collectFilesWithExtension)(absDir, extension, maxFiles + 1);
   const wasCapped = allFiles.length > maxFiles;
   const filesToProcess = allFiles.slice(0, maxFiles);
@@ -4407,7 +5164,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   const fileErrors = [];
   const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
   options.signal?.throwIfAborted();
-  const client = await manager.getClient(root, server2, options.signal);
+  const client = await manager.getClient(root, server, options.signal);
   try {
     let nextIndex = 0;
     const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
@@ -4435,7 +5192,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
     });
     await Promise.all(workers);
   } finally {
-    manager.releaseClient(root, server2.id);
+    manager.releaseClient(root, server.id);
   }
   const displayDiagnostics = allDiagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS);
   const wasDiagCapped = allDiagnostics.length > DEFAULT_MAX_DIAGNOSTICS;
@@ -4466,8 +5223,8 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
 }
 
 // ../lsp-core/src/lsp/infer-extension.ts
-import { lstatSync as lstatSync5, readdirSync as readdirSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+import { lstatSync as lstatSync7, readdirSync as readdirSync4 } from "node:fs";
+import { join as join7 } from "node:path";
 var SKIP_DIRECTORIES2 = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
 var MAX_SCAN_ENTRIES = 500;
 function inferExtensionFromDirectory(directory) {
@@ -4485,10 +5242,10 @@ function inferExtensionFromDirectory(directory) {
     for (const entry of entries) {
       if (scanned >= MAX_SCAN_ENTRIES)
         return;
-      const fullPath = join6(dir, entry);
+      const fullPath = join7(dir, entry);
       let stat;
       try {
-        stat = lstatSync5(fullPath);
+        stat = lstatSync7(fullPath);
       } catch {
         continue;
       }
@@ -4644,8 +5401,8 @@ function clientOptions(signal) {
 }
 
 // ../lsp-core/src/tools/result.ts
-function text(text2, details, isError = false) {
-  return { content: [{ type: "text", text: text2 }], details, isError };
+function text(text, details, isError = false) {
+  return { content: [{ type: "text", text }], details, isError };
 }
 
 // ../lsp-core/src/tools/diagnostics.ts
@@ -4665,7 +5422,7 @@ async function executeLspDiagnostics(params, signal) {
       const extension = inferExtensionFromDirectory(absPath);
       if (!extension) {
         const message = `No supported source files found in directory: ${absPath}`;
-        const details3 = {
+        const details = {
           filePath,
           severity,
           mode: "directory",
@@ -4675,24 +5432,24 @@ async function executeLspDiagnostics(params, signal) {
           error: message,
           errorKind: "no_files"
         };
-        return text(message, details3);
+        return text(message, details);
       }
-      const output2 = await aggregateDiagnosticsForDirectory(absPath, extension, severity, undefined, signal === undefined ? {} : { signal });
-      const details2 = {
+      const output = await aggregateDiagnosticsForDirectory(absPath, extension, severity, undefined, signal === undefined ? {} : { signal });
+      const details = {
         filePath,
         severity,
         mode: "directory",
         diagnostics: [],
-        totalDiagnostics: output2.totalDiagnostics,
+        totalDiagnostics: output.totalDiagnostics,
         truncated: false,
-        fileFailures: [...output2.fileFailures]
+        fileFailures: [...output.fileFailures]
       };
-      return text(output2.output, details2);
+      return text(output.output, details);
     }
     const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.diagnostics(resolvedFilePath, signal), "diagnostics", clientOptions(signal));
     if (result.transientError) {
       const message = result.transientError.message;
-      const details2 = {
+      const details = {
         filePath,
         severity,
         mode: "file",
@@ -4702,7 +5459,7 @@ async function executeLspDiagnostics(params, signal) {
         error: message,
         errorKind: result.transientError.kind
       };
-      return text(message, details2, true);
+      return text(message, details, true);
     }
     const diagnostics = filterDiagnosticsBySeverity(asDiagnosticArray(result), severity);
     const total = diagnostics.length;
@@ -4736,6 +5493,96 @@ async function executeLspDiagnostics(params, signal) {
     throw error;
   }
 }
+// ../lsp-core/src/lsp/format-document.ts
+import { readFileSync as readFileSync8, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+var DEFAULT_FORMATTING_OPTIONS = {
+  tabSize: 4,
+  insertSpaces: false,
+  trimTrailingWhitespace: true,
+  insertFinalNewline: true,
+  trimFinalNewlines: true
+};
+var UNCHANGED = { status: "unchanged", linesAdded: 0, linesRemoved: 0 };
+async function formatDocumentWithClient(client, filePath, options = {}) {
+  const edits = await client.formatDocument(filePath, options.formattingOptions ?? DEFAULT_FORMATTING_OPTIONS, options.signal);
+  if (edits === null)
+    return { status: "unavailable", reason: "capability_not_advertised" };
+  if (edits.length === 0)
+    return UNCHANGED;
+  const before = readFileSync8(filePath, "utf-8");
+  const normalized = normalizeTextEdits(before, edits, 0);
+  if (normalized.text === before)
+    return UNCHANGED;
+  writeAtomically(filePath, normalized.text);
+  await client.openFile(filePath);
+  return {
+    status: "formatted",
+    ...lineDelta(normalized.edits)
+  };
+}
+function lineDelta(edits) {
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  for (const edit of edits) {
+    linesRemoved += edit.range.end.line - edit.range.start.line + 1;
+    linesAdded += edit.newText.split(`
+`).length;
+  }
+  return { linesAdded, linesRemoved };
+}
+function writeAtomically(filePath, content) {
+  const tempPath = `${filePath}.omo-format.tmp`;
+  writeFileSync3(tempPath, content, "utf-8");
+  try {
+    renameSync3(tempPath, filePath);
+  } catch (error) {
+    try {
+      unlinkSync4(tempPath);
+    } catch {}
+    throw error;
+  }
+}
+
+// ../lsp-core/src/tools/format.ts
+async function executeLspFormat(params, signal) {
+  const filePath = requireString(params, "filePath");
+  try {
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => formatDocumentWithClient(client, resolvedFilePath, signal === undefined ? {} : { signal }), "format", clientOptions(signal));
+    return text(describeResult(filePath, result), formatDetails(filePath, result));
+  } catch (error) {
+    const missingDependency = missingDependencyResult(error, {
+      filePath,
+      status: "unavailable",
+      reason: "server_unavailable",
+      linesAdded: 0,
+      linesRemoved: 0
+    });
+    if (missingDependency)
+      return missingDependency;
+    throw error;
+  }
+}
+function formatDetails(filePath, result) {
+  if (result.status === "unavailable") {
+    return { filePath, status: "unavailable", reason: result.reason, linesAdded: 0, linesRemoved: 0 };
+  }
+  return {
+    filePath,
+    status: result.status,
+    linesAdded: result.linesAdded,
+    linesRemoved: result.linesRemoved
+  };
+}
+function describeResult(filePath, result) {
+  if (result.status === "unavailable") {
+    return `Formatting unavailable for ${filePath}: the language server does not advertise documentFormattingProvider.`;
+  }
+  if (result.status === "unchanged") {
+    return `Already formatted: ${filePath}`;
+  }
+  return `Formatted ${filePath} (+${result.linesAdded}/-${result.linesRemoved} lines)`;
+}
+
 // ../lsp-core/src/tools/install-decision.ts
 async function executeLspInstallDecision(params) {
   const serverId = requireString(params, "server_id");
@@ -4743,7 +5590,7 @@ async function executeLspInstallDecision(params) {
   if (!isInstallDecision(decision)) {
     return text(`Invalid decision '${String(decision)}'. Expected "declined" or "allowed".`, { serverId, errorKind: "invalid_decision" }, true);
   }
-  const serverIds = [...new Set(getMergedServers().map((server2) => server2.id))];
+  const serverIds = [...new Set(getMergedServers().map((server) => server.id))];
   if (!serverIds.includes(serverId)) {
     const preview = serverIds.slice(0, 20).join(", ");
     return text(`Unknown LSP server '${serverId}'. Known servers: ${preview}${serverIds.length > 20 ? "..." : ""}`, { serverId, errorKind: "unknown_server" }, true);
@@ -4883,10 +5730,10 @@ function objectSchema(properties, required = []) {
 async function executeLspStatus() {
   const servers = getAllServers();
   const snapshots = getLspManager().getSnapshot();
-  const installed = servers.filter((server2) => server2.installed && !server2.disabled);
-  const configuredLines = servers.map((server2) => {
-    const state = server2.disabled ? "disabled" : server2.installed ? "installed" : "missing";
-    return `- ${server2.id}: ${state}; source=${server2.source}; extensions=${server2.extensions.join(", ")}`;
+  const installed = servers.filter((server) => server.installed && !server.disabled);
+  const configuredLines = servers.map((server) => {
+    const state = server.disabled ? "disabled" : server.installed ? "installed" : "missing";
+    return `- ${server.id}: ${state}; source=${server.source}; extensions=${server.extensions.join(", ")}`;
   });
   const activeLines = snapshots.map((snapshot) => {
     const state = snapshot.alive ? snapshot.isInitializing ? "initializing" : "alive" : "dead";
@@ -4929,8 +5776,8 @@ async function executeLspSymbols(params, signal) {
           errorKind: "missing_query"
         });
       }
-      const symbols2 = await withLspClient(filePath, async (client) => client.workspaceSymbols(query, signal), "workspaceSymbols", clientOptions(signal));
-      return formatSymbolsResult(filePath, scope, symbols2, limit, query);
+      const symbols = await withLspClient(filePath, async (client) => client.workspaceSymbols(query, signal), "workspaceSymbols", clientOptions(signal));
+      return formatSymbolsResult(filePath, scope, symbols, limit, query);
     }
     const symbols = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal), "documentSymbols", clientOptions(signal));
     return formatSymbolsResult(filePath, scope, symbols, limit);
@@ -5068,6 +5915,16 @@ var LSP_MCP_TOOLS = [
     }, ["filePath", "line", "character", "newName"]),
     execute: executeLspRename
   },
+  {
+    name: "format",
+    aliases: ["lsp_format"],
+    title: "LSP Format",
+    description: "Format a source file with its language server and write the returned edits to disk.",
+    inputSchema: objectSchema({
+      filePath: { type: "string", description: "Source file path to format." }
+    }, ["filePath"]),
+    execute: executeLspFormat
+  },
   {
     name: "install_decision",
     aliases: ["lsp_install_decision"],
@@ -5107,7 +5964,7 @@ async function handleLspMcpRequest(input, options = {}) {
   if (!isPlainRecord(input)) {
     return errorResponse(null, -32600, "Invalid Request");
   }
-  const id = jsonRpcId(input["id"]);
+  const id = jsonRpcId2(input["id"]);
   const method = input["method"];
   if (method === "notifications/initialized")
     return;
@@ -5167,11 +6024,11 @@ function requestedProtocolVersion(params) {
 // src/daemon-client.ts
 import { connect } from "node:net";
 import { homedir as homedir3 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 
 // src/daemon-request-error.ts
 class DaemonRequestError extends Error {
-  requestWritten;
   constructor(message, requestWritten) {
     super(message);
     this.name = "DaemonRequestError";
@@ -5194,7 +6051,6 @@ class DaemonRequestCancelledError extends DaemonRequestError {
 }
 
 class DaemonRequestTimedOutError extends DaemonRequestError {
-  timeoutMs;
   constructor(requestWritten, timeoutMs) {
     super("daemon request timed out", requestWritten);
     this.name = "DaemonRequestTimedOutError";
@@ -5211,243 +6067,46 @@ function daemonFailureResult(paths, error) {
   return daemonUnreachableResult(paths, error);
 }
 function daemonCancelledResult(paths) {
-  const text2 = [
+  const text = [
     "LSP daemon request cancelled: the caller aborted this request (for example, the turn was interrupted).",
     "The daemon stays available; no LSP work was applied. Retry when you are ready.",
     `Socket: ${paths.socket}`
   ].join(`
 `);
-  return { content: [{ type: "text", text: text2 }], isError: true };
+  return { content: [{ type: "text", text }], isError: true };
 }
 function daemonTimedOutResult(paths, timeoutMs) {
-  const text2 = [
+  const text = [
     `LSP daemon request timed out after ${timeoutMs}ms: the daemon did not respond in time.`,
-    "The daemon stays available but may be busy. Retry when you are ready.",
-    `Socket: ${paths.socket}`,
-    `Logs: ${paths.log}`
-  ].join(`
-`);
-  return { content: [{ type: "text", text: text2 }], isError: true };
-}
-function daemonUnreachableResult(paths, error) {
-  const text2 = [
-    `LSP daemon unreachable: ${errorText(error)}.`,
-    "The MCP server is a thin proxy and never runs language servers in-process.",
-    `Socket: ${paths.socket}`,
-    `Logs: ${paths.log}`,
-    "The daemon is auto-started on demand and will be retried on the next request."
-  ].join(`
-`);
-  return { content: [{ type: "text", text: text2 }], isError: true };
-}
-function errorText(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/ensure-daemon.ts
-import { spawn as spawn2 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync11, mkdirSync as mkdirSync3, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
-import { Socket } from "node:net";
-import { dirname as dirname8, isAbsolute as isAbsolute4 } from "node:path";
-import { argv0, execPath } from "node:process";
-
-// src/ipc-protocol.ts
-import { randomBytes, timingSafeEqual } from "node:crypto";
-import {
-  chmodSync,
-  closeSync,
-  constants,
-  fchmodSync,
-  fstatSync,
-  lstatSync as lstatSync6,
-  mkdirSync as mkdirSync2,
-  openSync,
-  readFileSync as readFileSync5,
-  unlinkSync,
-  writeSync
-} from "node:fs";
-import { dirname as dirname7 } from "node:path";
-var OMO_DAEMON_PROTOCOL_VERSION = 1;
-var AUTH_ERROR_CODE = -32001;
-var PROTOCOL_ERROR_CODE = -32002;
-var AUTH_TOKEN_BYTES = 32;
-
-class UnsafePrivateDirectoryError extends Error {
-  path;
-  reason;
-  name = "UnsafePrivateDirectoryError";
-  code = "unsafe_private_directory";
-  constructor(path, reason) {
-    super(`unsafe private directory ${path}: ${reason}`);
-    this.path = path;
-    this.reason = reason;
-  }
-}
-function authEnvelope(token) {
-  return { protocolVersion: OMO_DAEMON_PROTOCOL_VERSION, token };
-}
-function readAuthToken(paths) {
-  try {
-    const token = readFileSync5(paths.auth, "utf8").trim();
-    return token.length > 0 ? token : null;
-  } catch (error) {
-    if (error instanceof Error)
-      return null;
-    throw error;
-  }
-}
-function readOrCreateAuthToken(paths) {
-  const existing = readAuthToken(paths);
-  if (existing)
-    return existing;
-  return createAuthToken(paths);
-}
-function rotateAuthToken(paths) {
-  try {
-    unlinkSync(paths.auth);
-  } catch (error) {
-    if (!(error instanceof Error))
-      throw error;
-  }
-  return createAuthToken(paths);
-}
-function authenticateMessage(raw, expectedToken) {
-  const id = jsonRpcId2(raw);
-  if (!isPlainRecord(raw))
-    return authError(id);
-  const params = raw["params"];
-  if (!isPlainRecord(params))
-    return authError(id);
-  const envelope = params["_omo"];
-  if (!isPlainRecord(envelope))
-    return authError(id);
-  const protocolVersion = envelope["protocolVersion"];
-  if (protocolVersion !== OMO_DAEMON_PROTOCOL_VERSION)
-    return protocolError(id);
-  const token = envelope["token"];
-  if (typeof token !== "string" || !tokenMatches(token, expectedToken))
-    return authError(id);
-  const cleanParams = { ...params };
-  delete cleanParams["_omo"];
-  return { input: { ...raw, params: cleanParams }, id, method: typeof raw["method"] === "string" ? raw["method"] : undefined };
-}
-function isAuthErrorResponse(message) {
-  if (!isPlainRecord(message))
-    return false;
-  const error = message["error"];
-  if (!isPlainRecord(error))
-    return false;
-  const data = error["data"];
-  return error["code"] === AUTH_ERROR_CODE && isPlainRecord(data) && data["code"] === "daemon_authentication_failed";
-}
-function writePrivateFile(path, data) {
-  const fd = openSync(path, "w", 384);
-  try {
-    writeSync(fd, data);
-  } finally {
-    closeSync(fd);
-  }
-  setPrivateFileMode(path);
-}
-function ensurePrivateDirectory(path, options = {}) {
-  try {
-    mkdirSync2(path, { recursive: true, mode: 448 });
-  } catch (error) {
-    if (errorCode2(error) !== "EEXIST")
-      throw error;
-  }
-  if (process.platform === "win32")
-    return;
-  const before = validatePrivateDirectory(path, options);
-  const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-  try {
-    fchmodSync(fd, 448);
-    const after = validatePrivateDirectory(path, options);
-    const openStats = fstatSync(fd);
-    if (!sameDirectory(before, after) || !sameDirectory(before, openStats)) {
-      throw new UnsafePrivateDirectoryError(path, "changed_during_chmod");
-    }
-  } finally {
-    closeSync(fd);
-  }
-}
-function setPrivateFileMode(path) {
-  if (process.platform !== "win32")
-    chmodSync(path, 384);
-}
-function createAuthToken(paths) {
-  ensurePrivateDirectory(dirname7(paths.auth));
-  const token = randomBytes(AUTH_TOKEN_BYTES).toString("base64url");
-  let fd;
-  try {
-    fd = openSync(paths.auth, "wx", 384);
-  } catch (error) {
-    if (errorCode2(error) === "EEXIST") {
-      const existing = readAuthToken(paths);
-      if (existing)
-        return existing;
-    }
-    throw error;
-  }
-  try {
-    writeSync(fd, `${token}
-`);
-  } finally {
-    closeSync(fd);
-  }
-  setPrivateFileMode(paths.auth);
-  return token;
-}
-function errorCode2(error) {
-  if (!error || typeof error !== "object" || !("code" in error))
-    return;
-  const code = Reflect.get(error, "code");
-  return typeof code === "string" ? code : undefined;
-}
-function validatePrivateDirectory(path, options) {
-  const stats = options.lstat ? options.lstat(path) : lstatPrivateDirectory(path);
-  if (stats.isSymbolicLink())
-    throw new UnsafePrivateDirectoryError(path, "symlink");
-  if (!stats.isDirectory())
-    throw new UnsafePrivateDirectoryError(path, "not_directory");
-  const currentUid = options.currentUid ? options.currentUid() : process.getuid?.();
-  if (currentUid !== undefined && stats.uid !== currentUid) {
-    throw new UnsafePrivateDirectoryError(path, "wrong_owner");
-  }
-  return stats;
-}
-function lstatPrivateDirectory(path) {
-  return lstatSync6(path);
-}
-function sameDirectory(a, b) {
-  return a.dev === b.dev && a.ino === b.ino;
-}
-function tokenMatches(candidate, expected) {
-  const candidateBytes = Buffer.from(candidate);
-  const expectedBytes = Buffer.from(expected);
-  return candidateBytes.length === expectedBytes.length && timingSafeEqual(candidateBytes, expectedBytes);
-}
-function jsonRpcId2(raw) {
-  if (!isPlainRecord(raw))
-    return null;
-  const id = raw["id"];
-  return typeof id === "string" || typeof id === "number" || id === null ? id : null;
+    "The daemon stays available but may be busy. Retry when you are ready.",
+    `Socket: ${paths.socket}`,
+    `Logs: ${paths.log}`
+  ].join(`
+`);
+  return { content: [{ type: "text", text }], isError: true };
 }
-function authError(id) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    error: { code: AUTH_ERROR_CODE, message: "daemon authentication failed", data: { code: "daemon_authentication_failed" } }
-  };
+function daemonUnreachableResult(paths, error) {
+  const text = [
+    `LSP daemon unreachable: ${errorText(error)}.`,
+    "The MCP server is a thin proxy and never runs language servers in-process.",
+    `Socket: ${paths.socket}`,
+    `Logs: ${paths.log}`,
+    "The daemon is auto-started on demand and will be retried on the next request."
+  ].join(`
+`);
+  return { content: [{ type: "text", text }], isError: true };
 }
-function protocolError(id) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    error: { code: PROTOCOL_ERROR_CODE, message: "daemon protocol mismatch", data: { code: "daemon_protocol_mismatch" } }
-  };
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
 }
 
+// src/ensure-daemon.ts
+import { spawn as spawn2 } from "node:child_process";
+import { closeSync as closeSync3, existsSync as existsSync13, mkdirSync as mkdirSync4, openSync as openSync3, writeSync as writeSync3 } from "node:fs";
+import { Socket } from "node:net";
+import { dirname as dirname12, isAbsolute as isAbsolute5 } from "node:path";
+import { argv0, execPath } from "node:process";
+
 // src/paths.ts
 import { createHash as createHash2 } from "node:crypto";
 import { createRequire } from "node:module";
@@ -5456,28 +6115,26 @@ import * as path from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/runtime-contract.ts
-import { statSync as statSync4 } from "node:fs";
-import { isAbsolute as isAbsolute3 } from "node:path";
+import { statSync as statSync5 } from "node:fs";
+import { isAbsolute as isAbsolute4 } from "node:path";
 var OMO_LSP_DAEMON_DIR = "OMO_LSP_DAEMON_DIR";
 var OMO_LSP_DAEMON_CLI = "OMO_LSP_DAEMON_CLI";
 var OMO_LSP_DAEMON_VERSION = "OMO_LSP_DAEMON_VERSION";
 var DAEMON_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
 
 class InvalidRuntimeOverrideError extends Error {
-  code = "invalid_runtime_override";
-  reason;
   constructor(reason, message) {
     super(message);
+    this.code = "invalid_runtime_override";
     this.name = "InvalidRuntimeOverrideError";
     this.reason = reason;
   }
 }
 
 class InvalidDaemonVersionError extends Error {
-  code = "invalid_daemon_version";
-  version;
   constructor(version) {
     super("LSP daemon version must match [A-Za-z0-9][A-Za-z0-9._+-]{0,127}");
+    this.code = "invalid_daemon_version";
     this.name = "InvalidDaemonVersionError";
     this.version = version;
   }
@@ -5496,17 +6153,17 @@ function resolveDaemonRuntime(env, defaults) {
     throw new InvalidRuntimeOverrideError("paired_values_required", `${OMO_LSP_DAEMON_CLI} and ${OMO_LSP_DAEMON_VERSION} must be set together`);
   }
   if (!hasCliOverride || !hasVersionOverride) {
-    if (!isAbsolute3(defaults.cliPath)) {
+    if (!isAbsolute4(defaults.cliPath)) {
       throw new InvalidRuntimeOverrideError("packaged_cli_must_be_absolute", "Packaged LSP daemon CLI path must be absolute");
     }
     return { cliPath: defaults.cliPath, version: validateDaemonVersion(defaults.version) };
   }
-  if (!isAbsolute3(cliOverride)) {
+  if (!isAbsolute4(cliOverride)) {
     throw new InvalidRuntimeOverrideError("cli_must_be_absolute", `${OMO_LSP_DAEMON_CLI} must be an absolute path to an existing regular file`);
   }
   let cliStats;
   try {
-    cliStats = statSync4(cliOverride);
+    cliStats = statSync5(cliOverride);
   } catch (error) {
     if (!(error instanceof Error))
       throw error;
@@ -5523,10 +6180,9 @@ var requireFromHere = createRequire(import.meta.url);
 var MAX_SOCKET_PATH_LENGTH = 100;
 
 class InvalidDaemonDirectoryError extends Error {
-  code = "invalid_daemon_directory";
-  directory;
   constructor(directory) {
     super(`${OMO_LSP_DAEMON_DIR} must be an absolute path`);
+    this.code = "invalid_daemon_directory";
     this.name = "InvalidDaemonDirectoryError";
     this.directory = directory;
   }
@@ -5641,9 +6297,11 @@ function createLineDecoder(onMessage, onParseError) {
 }
 
 // src/ensure-daemon.ts
-var PROBE_TIMEOUT_MS = 500;
+var PROBE_TIMEOUT_MS = 2000;
 var DEFAULT_READY_TIMEOUT_MS = 5000;
 var DEFAULT_POLL_INTERVAL_MS = 100;
+var FAILED_SPAWN_COOLDOWN_MS = 5000;
+var failedSpawnUntil = new Map;
 
 class DaemonUnreachableError extends Error {
   constructor(socketPath) {
@@ -5656,11 +6314,22 @@ async function ensureDaemonRunning(paths, deps = defaultEnsureDaemonDeps(), opti
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const signal = options.signal;
   throwIfAborted(signal);
-  if (await awaitWithSignal2(deps.probe(paths, signal), signal))
+  if (await awaitWithSignal2(deps.probe(paths, signal), signal)) {
+    failedSpawnUntil.delete(paths.socket);
     return;
+  }
   throwIfAborted(signal);
+  const retryAt = failedSpawnUntil.get(paths.socket);
+  if (retryAt !== undefined && deps.now() < retryAt)
+    throw new DaemonUnreachableError(paths.socket);
+  failedSpawnUntil.delete(paths.socket);
   deps.spawnDaemon(paths);
-  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal);
+  try {
+    await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal);
+  } catch (error) {
+    failedSpawnUntil.set(paths.socket, deps.now() + FAILED_SPAWN_COOLDOWN_MS);
+    throw error;
+  }
 }
 async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal) {
   const deadline = deps.now() + readyTimeoutMs;
@@ -5680,7 +6349,7 @@ async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   return await pingDaemon(paths, token, timeoutMs, signal) !== null;
 }
 function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve) => {
     const socket = new Socket;
     let settled = false;
     let timer;
@@ -5692,7 +6361,7 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
         clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
       socket.destroy();
-      resolve9(value);
+      resolve(value);
     };
     const onAbort = () => finish(null);
     const decoder = createLineDecoder((message) => {
@@ -5715,30 +6384,34 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
     socket.connect(paths.socket);
   });
 }
-function spawnDaemonProcess(paths) {
-  mkdirSync3(dirname8(paths.log), { recursive: true });
-  const logFd = openSync2(paths.log, "a");
+function spawnDaemonProcess(paths, deps = {}) {
+  mkdirSync4(dirname12(paths.log), { recursive: true });
+  const logFd = openSync3(paths.log, "a");
   try {
-    const child = spawn2(resolveDaemonNodeExecutable(), [paths.cliPath, "daemon"], {
+    const spawnDaemonChild = deps.spawn ?? spawn2;
+    const executable = deps.resolveExecutable?.() ?? resolveDaemonNodeExecutable();
+    const child = spawnDaemonChild(executable, [paths.cliPath, "daemon"], {
       detached: true,
-      stdio: ["ignore", logFd, logFd]
+      stdio: ["ignore", logFd, logFd],
+      windowsHide: true,
+      env: { ...process.env, BUN_BE_BUN: "1" }
     });
-    child.once("spawn", () => closeSync2(logFd));
+    child.once("spawn", () => closeSync3(logFd));
     child.once("error", (error) => {
-      writeSync2(logFd, `[lsp-daemon] failed to spawn daemon: ${error.message}
+      writeSync3(logFd, `[lsp-daemon] failed to spawn daemon: ${error.message}
 `);
-      closeSync2(logFd);
+      closeSync3(logFd);
     });
     child.unref();
   } catch (error) {
-    closeSync2(logFd);
+    closeSync3(logFd);
     throw error;
   }
 }
-function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync11) {
+function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync13) {
   if (pathExists(cachedExecPath))
     return cachedExecPath;
-  if (isAbsolute4(originalArgv0) && pathExists(originalArgv0))
+  if (isAbsolute5(originalArgv0) && pathExists(originalArgv0))
     return originalArgv0;
   return "node";
 }
@@ -5751,7 +6424,7 @@ function defaultEnsureDaemonDeps() {
   };
 }
 function sleepWithSignal(ms, signal) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve) => {
     let settled = false;
     const finish = () => {
       if (settled)
@@ -5759,7 +6432,7 @@ function sleepWithSignal(ms, signal) {
       settled = true;
       clearTimeout(timer);
       signal?.removeEventListener("abort", finish);
-      resolve9();
+      resolve();
     };
     const timer = setTimeout(finish, ms);
     if (signal?.aborted) {
@@ -5774,7 +6447,7 @@ function awaitWithSignal2(promise, signal) {
     return promise;
   if (signal.aborted)
     return Promise.reject(abortError3(signal));
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const finish = (run) => {
       if (settled)
@@ -5785,7 +6458,7 @@ function awaitWithSignal2(promise, signal) {
     };
     const onAbort = () => finish(() => reject(abortError3(signal)));
     signal.addEventListener("abort", onAbort, { once: true });
-    promise.then((value) => finish(() => resolve9(value)), (error) => finish(() => reject(error)));
+    promise.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
   });
 }
 function throwIfAborted(signal) {
@@ -5814,18 +6487,18 @@ function parsePingResponse(message) {
     return null;
   if (!endpoint || typeof endpoint !== "object" || Array.isArray(endpoint))
     return null;
-  const path2 = Reflect.get(endpoint, "path");
+  const path = Reflect.get(endpoint, "path");
   const kind = Reflect.get(endpoint, "kind");
-  if (typeof path2 !== "string")
+  if (typeof path !== "string")
     return null;
   if (kind === "windows")
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2 } };
+    return { pid, nonce, startedAt, endpoint: { kind, path } };
   if (kind === "missing")
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2 } };
+    return { pid, nonce, startedAt, endpoint: { kind, path } };
   const dev = Reflect.get(endpoint, "dev");
   const ino = Reflect.get(endpoint, "ino");
   if (kind === "unix" && typeof dev === "number" && typeof ino === "number") {
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2, dev, ino } };
+    return { pid, nonce, startedAt, endpoint: { kind, path, dev, ino } };
   }
   return null;
 }
@@ -5834,7 +6507,10 @@ function parsePingResponse(message) {
 var CONTEXT_KEY = "_context";
 
 class InvalidDaemonRequestError extends Error {
-  name = "InvalidDaemonRequestError";
+  constructor() {
+    super(...arguments);
+    this.name = "InvalidDaemonRequestError";
+  }
 }
 function extractRequestContext(raw) {
   if (!isPlainRecord(raw) || raw["method"] !== "tools/call")
@@ -5916,6 +6592,7 @@ function parseContext(value) {
 
 // src/daemon-client.ts
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+var STARTUP_BACKOFF_MS = [0, 100, 300];
 var nextProxyRequestId = 1;
 async function callToolViaDaemon(name, args, options) {
   const context = requireContext(options.context);
@@ -5923,17 +6600,31 @@ async function callToolViaDaemon(name, args, options) {
   const ensure = options.ensure ?? ((ensurePaths, signal) => ensureDaemonRunning(ensurePaths, undefined, signal === undefined ? {} : { signal }));
   const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const requestArgs = withContext(args, context);
+  const probe = options.probe ?? ((probePaths, signal) => probeDaemon(probePaths, undefined, signal));
+  const sleep = options.sleep ?? ((ms, signal) => delay(ms, undefined, { signal }));
   let lastError;
   let authRefreshUsed = false;
-  for (let attempt = 0;attempt < 3; attempt += 1) {
+  for (const [attempt, backoffMs] of STARTUP_BACKOFF_MS.entries()) {
     try {
-      await ensureDaemonAvailable(paths, ensure, options.signal);
+      if (backoffMs > 0)
+        await sleep(backoffMs, options.signal);
+      if (options.signal?.aborted)
+        throw new DaemonRequestCancelledError(false);
+      if (attempt === 0) {
+        await ensureDaemonAvailable(paths, ensure, options.signal);
+      } else if (!await probe(paths, options.signal)) {
+        throw new DaemonUnreachableError(paths.socket);
+      }
       const token = readAuthToken(paths);
       if (!token)
         throw new DaemonRequestError("daemon auth token missing", false);
       const sendOptions = options.signal === undefined ? { timeoutMs } : { timeoutMs, signal: options.signal };
       return await sendToolCall(paths, token, name, requestArgs, sendOptions);
     } catch (error) {
+      if (options.signal?.aborted) {
+        lastError = new DaemonRequestCancelledError(false);
+        break;
+      }
       lastError = error;
       if (error instanceof DaemonAuthenticationRejectedError && !authRefreshUsed) {
         authRefreshUsed = true;
@@ -5950,14 +6641,17 @@ async function callToolViaDaemon(name, args, options) {
 function callDiagnosticsViaDaemon(filePath, options) {
   return callToolViaDaemon("diagnostics", { filePath, severity: "error" }, options);
 }
+function callFormatViaDaemon(filePath, options) {
+  return callToolViaDaemon("format", { filePath }, options);
+}
 function currentRequestContext(env = process.env) {
   const cwd = process.cwd();
   const home = env["HOME"] ?? homedir3();
   return parseLspRequestContext({
     cwd,
-    projectConfigPaths: [join7(cwd, ".codex", "lsp-client.json")],
-    userConfigPath: join7(home, ".codex", "lsp-client.json"),
-    installDecisionsPath: join7(home, ".codex", "lsp-install-decisions.json"),
+    projectConfigPaths: [join8(cwd, ".codex", "lsp-client.json")],
+    userConfigPath: join8(home, ".codex", "lsp-client.json"),
+    installDecisionsPath: join8(home, ".codex", "lsp-install-decisions.json"),
     capabilities: { installDecisionTool: true }
   });
 }
@@ -5972,7 +6666,7 @@ function withContext(args, context) {
 function ensureDaemonAvailable(paths, ensure, signal) {
   if (!signal)
     return ensure(paths);
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const finish = (run) => {
       if (settled)
@@ -5987,11 +6681,11 @@ function ensureDaemonAvailable(paths, ensure, signal) {
       return;
     }
     signal.addEventListener("abort", onAbort, { once: true });
-    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve9()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
+    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
   });
 }
 function sendToolCall(paths, token, name, args, options) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve, reject) => {
     const socket = connect(paths.socket);
     const requestId = allocateProxyRequestId();
     let settled = false;
@@ -6044,7 +6738,7 @@ function sendToolCall(paths, token, name, args, options) {
       }
       const result = toToolResult(message, requestId);
       if (result)
-        finish(() => resolve9(result));
+        finish(() => resolve(result));
       else
         finish(() => reject(new DaemonRequestError("invalid daemon response", requestWritten)));
     });
@@ -6186,7 +6880,7 @@ function asToolCall(parsed) {
   if (!isPlainRecord(params) || typeof params["name"] !== "string")
     return null;
   const args = params["arguments"];
-  return { id: jsonRpcId(parsed["id"]), name: params["name"], args: isPlainRecord(args) ? args : {} };
+  return { id: jsonRpcId2(parsed["id"]), name: params["name"], args: isPlainRecord(args) ? args : {} };
 }
 function inferOpenCodeProjectCwd(projectConfigEnv) {
   if (!projectConfigEnv)
@@ -6212,266 +6906,28 @@ function canonicalizePathList(value) {
   return value.split(delimiter4).map((entry) => canonicalizePath(entry) ?? entry).join(delimiter4);
 }
 function canonicalizePath(value) {
-  if (value === undefined || !isAbsolute5(value) || !existsSync12(value))
+  if (value === undefined || !isAbsolute6(value) || !existsSync14(value))
     return value;
-  return realpathSync5(value);
+  return realpathSync6(value);
 }
-function projectRootFromOpenCodeConfigPath(path2) {
-  if (basename4(path2) !== "lsp.json" && basename4(path2) !== "lsp-client.json")
+function projectRootFromOpenCodeConfigPath(path) {
+  if (basename4(path) !== "lsp.json" && basename4(path) !== "lsp-client.json")
     return;
-  const configDir = dirname9(path2);
+  const configDir = dirname13(path);
   const configDirName = basename4(configDir);
   if (configDirName !== ".opencode" && configDirName !== ".omo")
     return;
-  return dirname9(configDir);
+  return dirname13(configDir);
 }
 
 // src/daemon-server.ts
 import { chmodSync as chmodSync2 } from "node:fs";
 import { createServer as createServer2 } from "node:net";
 
-// src/ownership.ts
-import { randomUUID } from "node:crypto";
-import { existsSync as existsSync13, lstatSync as lstatSync7, readFileSync as readFileSync7, statSync as statSync5, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
-
-// src/lock.ts
-import { closeSync as closeSync3, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeSync as writeSync3 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
-function isProcessAlive2(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    if (error instanceof Error)
-      return errorCode3(error) === "EPERM";
-    throw error;
-  }
-}
-function readLockPid(lockPath) {
-  try {
-    const pid = Number.parseInt(readFileSync6(lockPath, "utf8").trim(), 10);
-    return Number.isInteger(pid) ? pid : null;
-  } catch {
-    return null;
-  }
-}
-function tryAcquireLock(lockPath, ownerPid = process.pid) {
-  mkdirSync4(dirname10(lockPath), { recursive: true });
-  for (let attempt = 0;attempt < 2; attempt += 1) {
-    const handle = writeLockFile(lockPath, ownerPid);
-    if (handle)
-      return handle;
-    if (!reapStaleLock(lockPath))
-      return null;
-  }
-  return null;
-}
-function writeLockFile(lockPath, ownerPid) {
-  try {
-    const fd = openSync3(lockPath, "wx", 384);
-    writeSync3(fd, `${ownerPid}
-`);
-    closeSync3(fd);
-    return { release: () => unlinkQuietly(lockPath) };
-  } catch (error) {
-    if (errorCode3(error) === "EEXIST")
-      return null;
-    throw error;
-  }
-}
-function reapStaleLock(lockPath) {
-  const pid = readLockPid(lockPath);
-  if (pid !== null && isProcessAlive2(pid))
-    return false;
-  unlinkQuietly(lockPath);
-  return true;
-}
-function unlinkQuietly(path2) {
-  try {
-    unlinkSync2(path2);
-  } catch (error) {
-    if (error instanceof Error)
-      return;
-    throw error;
-  }
-}
-function errorCode3(error) {
-  if (!error || typeof error !== "object" || !("code" in error))
-    return;
-  const code = Reflect.get(error, "code");
-  return typeof code === "string" ? code : undefined;
-}
-
-// src/ownership.ts
-class DaemonAlreadyRunningError extends Error {
-  name = "DaemonAlreadyRunningError";
-  code = "daemon_already_running";
-}
-
-class DaemonStartupDeferredError extends Error {
-  reason;
-  name = "DaemonStartupDeferredError";
-  code = "daemon_startup_deferred";
-  constructor(reason) {
-    super(`LSP daemon startup deferred: ${reason}`);
-    this.reason = reason;
-  }
-}
-async function acquireStartupLease(paths, pingOwner) {
-  ensureDaemonDirectories(paths);
-  const lock = tryAcquireLock(paths.lock);
-  if (!lock) {
-    const token = readAuthToken(paths);
-    if (token && await pingOwner(token))
-      throw new DaemonAlreadyRunningError("LSP daemon already running");
-    throw new DaemonStartupDeferredError("startup_lock_busy");
-  }
-  try {
-    const token = await validateExistingOwner(paths, pingOwner);
-    return { lock, token, owner: newOwner(paths) };
-  } catch (error) {
-    lock.release();
-    throw error;
-  }
-}
-function ensureDaemonDirectories(paths) {
-  ensurePrivateDirectory(paths.dir);
-  if (process.platform !== "win32")
-    ensurePrivateDirectory(dirname11(paths.socket));
-}
-function readDaemonOwner(paths) {
-  try {
-    return parseOwner(JSON.parse(readFileSync7(paths.owner, "utf8")));
-  } catch (error) {
-    if (error instanceof Error)
-      return null;
-    throw error;
-  }
-}
-function writeDaemonOwner(paths, owner) {
-  writePrivateFile(paths.pid, `${owner.pid}
-`);
-  writePrivateFile(paths.endpoint, owner.endpoint.path);
-  writePrivateFile(paths.owner, `${JSON.stringify(owner)}
-`);
-}
-function removeDaemonMetadataForOwner(paths, owner) {
-  const current = readDaemonOwner(paths);
-  if (!current || !sameOwner(current, owner))
-    return;
-  unlinkQuietly(paths.socket);
-  unlinkQuietly(paths.pid);
-  unlinkQuietly(paths.endpoint);
-  unlinkQuietly(paths.owner);
-}
-function endpointIdentity(endpointPath) {
-  if (process.platform === "win32")
-    return { kind: "windows", path: endpointPath };
-  try {
-    const stats = statSync5(endpointPath);
-    return { kind: "unix", path: endpointPath, dev: stats.dev, ino: stats.ino };
-  } catch (error) {
-    if (error instanceof Error)
-      return { kind: "missing", path: endpointPath };
-    throw error;
-  }
-}
-function sameEndpoint(a, b) {
-  if (a.kind !== b.kind || a.path !== b.path)
-    return false;
-  switch (a.kind) {
-    case "unix":
-      return b.kind === "unix" && a.dev === b.dev && a.ino === b.ino;
-    case "windows":
-      return true;
-    case "missing":
-      return true;
-  }
-}
-function sameOwner(a, b) {
-  return a.pid === b.pid && a.nonce === b.nonce && sameEndpoint(a.endpoint, b.endpoint);
-}
-async function validateExistingOwner(paths, pingOwner) {
-  let token = readOrCreateAuthToken(paths);
-  for (let attempt = 0;attempt < 2; attempt += 1) {
-    const owner = readDaemonOwner(paths);
-    if (!owner)
-      return token;
-    const ping = await pingOwner(token);
-    if (ping && owner.nonce === ping.nonce && sameEndpoint(owner.endpoint, ping.endpoint)) {
-      throw new DaemonAlreadyRunningError("LSP daemon already running");
-    }
-    if (ping)
-      continue;
-    if (isProcessAlive2(owner.pid))
-      throw new DaemonStartupDeferredError("owner_pid_live_unreachable");
-    const reread = readDaemonOwner(paths);
-    const endpoint = endpointIdentity(owner.endpoint.path);
-    if (!reread || reread.nonce !== owner.nonce || !sameEndpoint(endpoint, owner.endpoint)) {
-      throw new DaemonStartupDeferredError("owner_changed_during_cleanup");
-    }
-    cleanupDeadOwner(paths, owner);
-    token = rotateAuthToken(paths);
-    return token;
-  }
-  throw new DaemonStartupDeferredError("reachable_owner_mismatch");
-}
-function cleanupDeadOwner(paths, owner) {
-  if (process.platform !== "win32" && existsSync13(owner.endpoint.path)) {
-    const stat = lstatSync7(owner.endpoint.path);
-    if (stat.isSocket())
-      unlinkSync3(owner.endpoint.path);
-  }
-  unlinkQuietly(paths.pid);
-  unlinkQuietly(paths.endpoint);
-  unlinkQuietly(paths.owner);
-}
-function newOwner(paths) {
-  return {
-    pid: process.pid,
-    nonce: randomUUID(),
-    startedAt: new Date().toISOString(),
-    endpoint: endpointIdentity(paths.socket)
-  };
-}
-function parseOwner(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const pid = Reflect.get(value, "pid");
-  const nonce = Reflect.get(value, "nonce");
-  const startedAt = Reflect.get(value, "startedAt");
-  const endpoint = parseEndpoint(Reflect.get(value, "endpoint"));
-  if (typeof pid !== "number" || typeof nonce !== "string" || typeof startedAt !== "string" || !endpoint)
-    return null;
-  return { pid, nonce, startedAt, endpoint };
-}
-function parseEndpoint(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const kind = Reflect.get(value, "kind");
-  const path2 = Reflect.get(value, "path");
-  if (typeof path2 !== "string")
-    return null;
-  if (kind === undefined)
-    return endpointIdentity(path2);
-  if (kind === "windows")
-    return { kind, path: path2 };
-  if (kind === "missing")
-    return { kind, path: path2 };
-  const dev = Reflect.get(value, "dev");
-  const ino = Reflect.get(value, "ino");
-  if (kind === "unix" && typeof dev === "number" && typeof ino === "number")
-    return { kind, path: path2, dev, ino };
-  return null;
-}
-
 // src/version-reap.ts
 import { execFile } from "node:child_process";
 import { readdir, readFile, rm } from "node:fs/promises";
-import { basename as basename5, dirname as dirname12, join as join8 } from "node:path";
+import { basename as basename5, dirname as dirname14, join as join9 } from "node:path";
 var TERM_GRACE_MS = 5000;
 var KILL_GRACE_MS = 1000;
 var VERSION_ENTRY_PATTERN = /^v([A-Za-z0-9][A-Za-z0-9._+-]{0,127})$/;
@@ -6492,13 +6948,13 @@ async function attestDaemonCliProcess(pid, platform, deps = {}) {
   return isNodeCliDaemonCommand(command.trim());
 }
 async function reapStaleDaemonVersions(ownPaths, deps = {}) {
-  const baseDir = dirname12(ownPaths.dir);
+  const baseDir = dirname14(ownPaths.dir);
   const platform = deps.platform ?? process.platform;
-  const isAlive = deps.isAlive ?? isProcessAlive2;
+  const isAlive = deps.isAlive ?? isProcessAlive;
   const attest = deps.attest ?? ((pid) => attestDaemonCliProcess(pid, platform));
   const sendSignal = deps.sendSignal ?? defaultSendSignal;
   const waitForExit = deps.waitForExit ?? defaultWaitForExit;
-  const removeDir = deps.removeDir ?? ((path2) => rm(path2, { recursive: true, force: true }));
+  const removeDir = deps.removeDir ?? ((path) => rm(path, { recursive: true, force: true }));
   const readOwner = deps.readOwner ?? readDaemonOwner;
   const log = deps.log ?? defaultLog;
   const termGraceMs = deps.termGraceMs ?? TERM_GRACE_MS;
@@ -6511,7 +6967,7 @@ async function reapStaleDaemonVersions(ownPaths, deps = {}) {
     const version = parseVersionEntry(entry.name);
     if (version === null || !entry.isDirectory())
       continue;
-    const versionDir = join8(baseDir, entry.name);
+    const versionDir = join9(baseDir, entry.name);
     const siblingPaths = daemonPaths({ [OMO_LSP_DAEMON_DIR]: baseDir }, { cliPath: ownPaths.cliPath, version });
     results.push(await reapOneVersion({
       version,
@@ -6535,7 +6991,7 @@ async function reapOneVersion(context) {
   const { version, versionDir } = context;
   const owner = context.readOwner(context.siblingPaths);
   if (!owner) {
-    const lockPid = readLockPid(join8(versionDir, "daemon.lock"));
+    const lockPid = readLockPid(join9(versionDir, "daemon.lock"));
     if (lockPid !== null && context.isAlive(lockPid)) {
       context.log(`reap: sparing v${version}: owner metadata missing but daemon.lock is held by live pid ${lockPid}`);
       return { version, status: "spared", reason: `owner metadata missing but lock held by live pid ${lockPid}` };
@@ -6609,17 +7065,17 @@ function isNodeCliDaemonArgv(argv) {
 function isNodeCliDaemonCommand(command) {
   return /\bnode(?:\.exe)?\b/i.test(command) && /\bcli\.js\b/.test(command) && /\bdaemon\b/.test(command);
 }
-function defaultReadProcFile(path2) {
-  return readFile(path2);
+function defaultReadProcFile(path) {
+  return readFile(path);
 }
 function defaultExecuteForStdout(file, args) {
-  return new Promise((resolve9) => {
-    execFile(file, [...args], { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: 1000 }, (error, stdout) => {
+  return new Promise((resolve) => {
+    execFile(file, [...args], { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: 1000, windowsHide: true }, (error, stdout) => {
       if (error !== null) {
-        resolve9(null);
+        resolve(null);
         return;
       }
-      resolve9(stdout);
+      resolve(stdout);
     });
   });
 }
@@ -6634,11 +7090,11 @@ function defaultSendSignal(pid, signal) {
 async function defaultWaitForExit(pid, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   for (;; ) {
-    if (!isProcessAlive2(pid))
+    if (!isProcessAlive(pid))
       return true;
     if (Date.now() >= deadline)
       return false;
-    await new Promise((resolve9) => setTimeout(resolve9, 100));
+    await new Promise((resolve) => setTimeout(resolve, 100));
   }
 }
 function defaultLog(message) {
@@ -6659,7 +7115,7 @@ async function startDaemonServer(paths, options = {}) {
     lastActiveAt = Date.now();
   };
   let routeOwner = lease.owner;
-  const server2 = createServer2((socket) => {
+  const server = createServer2((socket) => {
     connections.add(socket);
     const activeRequests = new Map;
     touch();
@@ -6677,10 +7133,10 @@ async function startDaemonServer(paths, options = {}) {
       touch();
     });
   });
-  server2.on("error", (error) => logServerError(error));
+  server.on("error", (error) => logServerError(error));
   let owner;
   try {
-    await listen(server2, paths.socket);
+    await listen(server, paths.socket);
     if (process.platform !== "win32")
       chmodSync2(paths.socket, 384);
     owner = { ...lease.owner, endpoint: endpointIdentity(paths.socket) };
@@ -6702,7 +7158,7 @@ async function startDaemonServer(paths, options = {}) {
     for (const socket of connections)
       socket.destroy();
     connections.clear();
-    await closeServer(server2);
+    await closeServer(server);
     removeDaemonMetadataForOwner(paths, owner);
     await disposeDefaultLspManager();
   };
@@ -6723,7 +7179,7 @@ async function startDaemonServer(paths, options = {}) {
   }, idleCheckIntervalMs);
   idleTimer.unref();
   installSignalHandlers(close);
-  return { server: server2, close };
+  return { server, close };
 }
 async function respond(socket, message, token, owner, activeRequests) {
   try {
@@ -6744,18 +7200,18 @@ async function assertSelfProbe(paths, token, owner) {
   if (!ping || ping.nonce !== owner.nonce)
     throw new DaemonStartupDeferredError("self_probe_failed");
 }
-function listen(server2, socketPath) {
-  return new Promise((resolve9, reject) => {
+function listen(server, socketPath) {
+  return new Promise((resolve, reject) => {
     const onError = (error) => reject(error);
-    server2.once("error", onError);
-    server2.listen(socketPath, () => {
-      server2.removeListener("error", onError);
-      resolve9();
+    server.once("error", onError);
+    server.listen(socketPath, () => {
+      server.removeListener("error", onError);
+      resolve();
     });
   });
 }
-function closeServer(server2) {
-  return new Promise((resolve9) => server2.close(() => resolve9()));
+function closeServer(server) {
+  return new Promise((resolve) => server.close(() => resolve()));
 }
 function installSignalHandlers(close) {
   const handler = () => {
@@ -6804,7 +7260,12 @@ async function main() {
   process.exitCode = 2;
 }
 main().catch((error) => {
-  stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
+  if (error instanceof DaemonStartupDeferredError) {
+    stderr.write(`[lsp-daemon] startup deferred: ${error.reason}
+`);
+  } else {
+    stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
 `);
+  }
   process.exitCode = 1;
 });