lazycodex-ai 5.0.0-beta.4 → 5.0.0-beta.40

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

@@ -15,6 +15,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;
@@ -23,28 +30,24 @@ 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/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}` : "";
@@ -53,46 +56,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;
@@ -108,20 +124,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)
@@ -242,19 +269,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_SEPARATOR);
@@ -602,33 +616,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, server, timeouts = {}) {
     this.root = root;
     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;
@@ -648,6 +658,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]);
   }
@@ -723,7 +739,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));
@@ -742,7 +758,7 @@ class LspClientTransport {
       }
       throw error;
     } finally {
-      clearTimeout(timeoutHandle);
+      this.timerProvider.clearTimeout(timeoutHandle);
       combinedSignal.dispose();
     }
   }
@@ -861,6 +877,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() {
@@ -877,6 +901,7 @@ class LspClientConnection extends LspClientTransport {
           references: {},
           documentSymbol: { hierarchicalDocumentSymbolSupport: true },
           publishDiagnostics: {},
+          formatting: { dynamicRegistration: false },
           rename: {
             prepareSupport: true,
             prepareSupportDefaultBehavior: 1
@@ -918,6 +943,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 } } }
@@ -1123,6 +1149,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 = relative(parent, candidate);
   return suffix === "" || !suffix.startsWith("..") && suffix !== "..";
@@ -1133,17 +1170,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) {
@@ -1165,7 +1203,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 ?? [];
@@ -1187,13 +1225,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 = {
@@ -1203,7 +1241,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;
@@ -1217,7 +1255,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;
@@ -1231,7 +1269,7 @@ 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();
     return new Promise((resolveActivity) => {
@@ -1240,11 +1278,11 @@ class WorkspaceDocumentState {
         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);
@@ -1352,7 +1390,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 }
@@ -1377,7 +1415,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 } });
@@ -1406,13 +1444,11 @@ import { dirname, isAbsolute, relative as relative2, resolve as resolve2 } from
 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) {
@@ -1704,13 +1740,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";
   }
 }
 
@@ -2208,10 +2242,9 @@ function simulateDelete(operation, virtual) {
 import { existsSync as existsSync4, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname3, resolve as resolve4 } 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);
@@ -2255,8 +2288,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) {
@@ -2345,14 +2380,11 @@ function isRecord3(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;
@@ -2465,14 +2497,12 @@ var DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3000;
 var VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
 
 class LspClient extends LspClientConnection {
-  diagnosticPullErrors = [];
-  documents;
-  workspaceMutations;
-  diagnosticsFreshnessTimeoutMs;
   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);
@@ -2525,6 +2555,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);
@@ -2564,7 +2606,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);
@@ -2577,7 +2619,7 @@ class LspClient extends LspClientConnection {
       if (!pushFallbackOnly) {
         const cached = this.documents.getPullCache(snapshot);
         try {
-          const remainingMs2 = deadlineAt - Date.now();
+          const remainingMs2 = deadlineAt - this.timerProvider.now();
           if (remainingMs2 <= 0)
             return this.freshnessTimeout(absPath);
           const result = await this.sendRequest("textDocument/diagnostic", {
@@ -2612,7 +2654,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);
@@ -2770,18 +2812,16 @@ 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, server) => new LspClient(root, server));
     this.now = options.now ?? (() => Date.now());
@@ -2801,24 +2841,79 @@ 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, server, signal) {
@@ -2827,12 +2922,22 @@ class LspManager {
     }
     signal?.throwIfAborted();
     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;
       }
     }
@@ -2853,14 +2958,20 @@ class LspManager {
         signal.throwIfAborted();
       }
       if (!managed.client.isAlive()) {
-        await stopClientBestEffort(managed.client);
-        this.clients.delete(key);
+        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;
     }
+    this.evictForAdmission();
+    this.ensureRespawnAllowed(key, root, server.id);
     const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
@@ -2884,7 +2995,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--;
@@ -2895,6 +3006,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;
@@ -2915,14 +3035,20 @@ class LspManager {
     if (client && managed.client !== client)
       return;
     this.clients.delete(key);
-    stopClientBestEffort(managed.client);
+    this.tombstoneStop(key, managed.client);
   }
   warmupClient(root, server) {
     if (this.disposed)
       return;
     const key = this.getKey(root, server.id);
-    if (this.clients.has(key))
+    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, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
@@ -2948,7 +3074,7 @@ class LspManager {
       if (this.clients.get(key) === managed) {
         this.clients.delete(key);
       }
-      stopClientBestEffort(client);
+      this.tombstoneStop(key, client);
     });
   }
   isServerInitializing(root, serverId) {
@@ -2992,8 +3118,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;
@@ -3013,7 +3142,7 @@ async function disposeDefaultLspManager() {
 // 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";
 
 // ../lsp-core/src/request-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -3022,18 +3151,17 @@ import { homedir } from "node:os";
 import { basename as basename2, delimiter as delimiter2, dirname as dirname4, isAbsolute as isAbsolute2, join as join2, relative as relative4, resolve as resolve6 } 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;
@@ -3053,7 +3181,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");
@@ -3191,7 +3319,6 @@ function isPlainRecord(value) {
 
 // src/daemon-request-error.ts
 class DaemonRequestError extends Error {
-  requestWritten;
   constructor(message, requestWritten) {
     super(message);
     this.name = "DaemonRequestError";
@@ -3214,7 +3341,6 @@ class DaemonRequestCancelledError extends DaemonRequestError {
 }
 
 class DaemonRequestTimedOutError extends DaemonRequestError {
-  timeoutMs;
   constructor(requestWritten, timeoutMs) {
     super("daemon request timed out", requestWritten);
     this.name = "DaemonRequestTimedOutError";
@@ -3293,14 +3419,12 @@ 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;
+    this.name = "UnsafePrivateDirectoryError";
+    this.code = "unsafe_private_directory";
   }
 }
 function authEnvelope(token) {
@@ -3484,20 +3608,18 @@ 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;
   }
@@ -3543,10 +3665,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;
   }
@@ -3741,7 +3862,8 @@ function spawnDaemonProcess(paths) {
   try {
     const child = spawn2(resolveDaemonNodeExecutable(), [paths.cliPath, "daemon"], {
       detached: true,
-      stdio: ["ignore", logFd, logFd]
+      stdio: ["ignore", logFd, logFd],
+      windowsHide: true
     });
     child.once("spawn", () => closeSync2(logFd));
     child.once("error", (error) => {
@@ -4022,6 +4144,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;
@@ -4118,7 +4241,11 @@ function createParentWatchdog(config, onDeadParent) {
   const probeAlive = config.probeAlive ?? isProcessAlive;
   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);
@@ -4153,60 +4280,55 @@ function createIdleTimer(idleTimeoutMs, log, onTimeout) {
   };
 }
 // ../lsp-core/src/lsp/client-wrapper.ts
-import { existsSync as existsSync10, statSync as statSync4 } from "node:fs";
-import { dirname as dirname8, 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 dirname10, join as join5, resolve as resolve8 } from "node:path";
 
-// ../lsp-core/src/lsp/server-install-state.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
-function getInstallDecisionsPath() {
-  return lspRequestContext().installDecisionsPath;
-}
-function loadInstallDecisions() {
-  const path2 = getInstallDecisionsPath();
-  if (!existsSync7(path2))
-    return {};
-  try {
-    const parsed = JSON.parse(readFileSync4(path2, "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 dirname7, 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 = dirname7(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 path2 = getInstallDecisionsPath();
-  mkdirSync3(dirname7(path2), { recursive: true });
-  const tmpPath = `${path2}.tmp`;
-  writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
-`, "utf8");
-  renameSync2(tmpPath, path2);
-}
-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 = dirname7(current);
+    if (parent === current)
+      return current;
+    current = parent;
+  }
+  return current;
 }
 
-// ../lsp-core/src/lsp/config-loader.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
-
 // ../lsp-core/src/lsp/server-definitions.ts
 var LSP_INSTALL_HINTS = {
   typescript: "npm install -g typescript-language-server typescript",
@@ -4252,6 +4374,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"],
@@ -4354,7 +4496,56 @@ var BUILTIN_SERVERS = {
   }
 };
 
+// ../lsp-core/src/lsp/server-install-state.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
+function getInstallDecisionsPath() {
+  return lspRequestContext().installDecisionsPath;
+}
+function loadInstallDecisions() {
+  const path2 = getInstallDecisionsPath();
+  if (!existsSync8(path2))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync4(path2, "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 path2 = getInstallDecisionsPath();
+  mkdirSync3(dirname8(path2), { recursive: true });
+  const tmpPath = `${path2}.tmp`;
+  writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
+`, "utf8");
+  renameSync2(tmpPath, path2);
+}
+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 readFileSync5 } from "node:fs";
 function getProjectConfigPaths() {
   return lspRequestContext().projectConfigPaths;
 }
@@ -4362,7 +4553,7 @@ function getUserConfigPath() {
   return lspRequestContext().userConfigPath;
 }
 function loadJsonFile(path2) {
-  if (!existsSync8(path2))
+  if (!existsSync9(path2))
     return null;
   try {
     const parsed = JSON.parse(readFileSync5(path2, "utf-8"));
@@ -4550,54 +4741,155 @@ function getDisabledServerIds() {
 }
 
 // ../lsp-core/src/lsp/server-installation.ts
-import { existsSync as existsSync9 } 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 (existsSync9(cmd))
-      return true;
+import { existsSync as existsSync10 } from "node:fs";
+import { delimiter as delimiter3, dirname as dirname9, isAbsolute as isAbsolute5, 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(path2) {
+  probeCount += 1;
+  return existsSync10(path2);
+}
+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 = dirname9(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 (existsSync9(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 = isAbsolute5(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();
+  const workingDirectory = contextCwd();
   for (const server2 of servers) {
-    if (server2.extensions.includes(ext) && isServerInstalled(server2.command)) {
+    if (!server2.extensions.includes(ext))
+      continue;
+    const binaryPath = resolveServerBinary(server2.command, workingDirectory);
+    if (binaryPath !== null) {
       const resolvedServer = {
         id: server2.id,
-        command: server2.command,
+        command: withResolvedCommand(server2.command, binaryPath),
         extensions: server2.extensions,
         priority: server2.priority
       };
@@ -4644,6 +4936,7 @@ 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) {
@@ -4651,7 +4944,7 @@ function getAllServers() {
       continue;
     result.push({
       id: server2.id,
-      installed: isServerInstalled(server2.command),
+      installed: isServerInstalled(server2.command, workingDirectory),
       extensions: server2.extensions,
       disabled: false,
       source: server2.source,
@@ -4665,7 +4958,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",
@@ -4676,7 +4969,6 @@ 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 statSync4(filePath).isDirectory();
@@ -4685,32 +4977,90 @@ function isDirectoryPath(filePath) {
   }
 }
 function findWorkspaceRoot(filePath) {
-  const abs = resolvePathInsideContext(filePath);
+  const cwd = contextCwd();
+  const abs = resolveReadablePathInsideContext(filePath);
   let dir = abs;
   if (!isDirectoryPath(dir)) {
-    dir = dirname8(dir);
-  }
-  let prevDir = "";
-  while (dir !== prevDir) {
-    for (const marker of WORKSPACE_MARKERS) {
-      if (existsSync10(join4(dir, marker))) {
-        return dir;
+    dir = dirname10(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) {
+      if (existsSync11(join5(dir, GIT_WORKSPACE_MARKER))) {
+        return canonicalDir;
+      }
+      if (nearestPackageRoot === undefined && hasProjectWorkspaceMarker(dir)) {
+        nearestPackageRoot = canonicalDir;
       }
     }
-    prevDir = dir;
-    dir = dirname8(dir);
+    if (dir === cwd)
+      break;
+    dir = dirname10(dir);
   }
-  return dirname8(abs);
+  return nearestPackageRoot ?? fallbackRoot;
+}
+function hasProjectWorkspaceMarker(directory) {
+  return PROJECT_WORKSPACE_MARKERS.some((marker) => existsSync11(join5(directory, marker)));
+}
+function resolveReadablePathInsideContext(filePath) {
+  const cwd = contextCwd();
+  const abs = resolve8(cwd, filePath);
+  if (isPathInside(cwd, abs))
+    return abs;
+  const rebased = rebaseThroughCanonicalAncestor(abs, cwd);
+  if (rebased !== undefined)
+    return rebased;
+  return canonicalizeExistingOrNearestAncestor(abs);
 }
 function resolvePathInsideContext(filePath) {
   const cwd = contextCwd();
-  const abs = resolve7(cwd, filePath);
+  const abs = resolveReadablePathInsideContext(filePath);
   const canonical = canonicalizeExistingOrNearestAncestor(abs);
   if (!isPathInside(cwd, canonical)) {
     throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
   }
   return canonical;
 }
+function rebaseThroughCanonicalAncestor(path2, cwd) {
+  let current = path2;
+  const suffix = [];
+  while (true) {
+    if (existsSync11(current)) {
+      const canonical = realpathSync5(current);
+      if (isPathInside(cwd, canonical))
+        return suffix.length === 0 ? canonical : join5(canonical, ...suffix);
+    }
+    const parent = dirname10(current);
+    if (parent === current)
+      return;
+    suffix.unshift(basename3(current));
+    current = parent;
+  }
+}
+function existingDirectoryInsideContext(directory, cwd) {
+  if (!existsSync11(directory))
+    return;
+  const canonical = realpathSync5(directory);
+  if (!statSync4(canonical).isDirectory())
+    return;
+  return isPathInside(cwd, canonical) ? canonical : undefined;
+}
+function nearestExistingDirectoryInsideContext(directory, cwd) {
+  let current = directory;
+  while (isPathInside(cwd, current)) {
+    const canonical = existingDirectoryInsideContext(current, cwd);
+    if (canonical !== undefined)
+      return canonical;
+    if (current === cwd)
+      return;
+    current = dirname10(current);
+  }
+  return;
+}
 function formatServerLookupError(result) {
   if (result.status === "not_installed") {
     return formatNotInstalled(result);
@@ -4734,6 +5084,19 @@ 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(", ");
@@ -4748,19 +5111,19 @@ function formatNotInstalled(result) {
     `Command not found: ${server2.command[0]}`,
     ""
   ];
+  const installOptions = formatInstallOptions(server2.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."
@@ -4769,8 +5132,7 @@ 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.",
@@ -4781,7 +5143,7 @@ function formatNotInstalled(result) {
   ].join(`
 `);
 }
-var READ_ONLY_RETRY_TOOLS = new Set([
+var READ_ONLY_TOOLS = new Set([
   "diagnostics",
   "definition",
   "references",
@@ -4790,7 +5152,7 @@ var READ_ONLY_RETRY_TOOLS = new Set([
   "prepareRename"
 ]);
 async function withLspClient(filePath, fn, toolName, options = {}) {
-  const absPath = resolvePathInsideContext(filePath);
+  const absPath = READ_ONLY_TOOLS.has(toolName) ? resolveReadablePathInsideContext(filePath) : resolvePathInsideContext(filePath);
   if (isDirectoryPath(absPath)) {
     throw new LspInvalidPathError("Directory paths are not supported by this LSP tool. " + "Use lsp.diagnostics with a directory path for directory diagnostics.");
   }
@@ -4805,9 +5167,9 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
   const acquireAndCall = async (allowRetry) => {
     const client = await manager.getClient(root, server2, options.signal);
     try {
-      return await fn(client, root);
+      return await fn(client, root, absPath);
     } catch (err) {
-      if (allowRetry && READ_ONLY_RETRY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
+      if (allowRetry && READ_ONLY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
         manager.invalidateClient(root, server2.id, client);
         return acquireAndCall(false);
       }
@@ -4825,8 +5187,8 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
 }
 
 // ../lsp-core/src/lsp/directory-diagnostics.ts
-import { existsSync as existsSync11, lstatSync as lstatSync5, readdirSync as readdirSync3 } from "node:fs";
-import { join as join5, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync12, lstatSync as lstatSync5, 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 fileURLToPath3 } from "node:url";
@@ -4956,7 +5318,7 @@ 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 = lstatSync5(fullPath);
@@ -4981,8 +5343,8 @@ 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 (!existsSync11(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 };
@@ -5069,7 +5431,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
 
 // ../lsp-core/src/lsp/infer-extension.ts
 import { lstatSync as lstatSync6, readdirSync as readdirSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+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) {
@@ -5087,7 +5449,7 @@ 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 = lstatSync6(fullPath);
@@ -5262,7 +5624,7 @@ async function executeLspDiagnostics(params, signal) {
   const filePath = requireString(params, "filePath");
   const severity = severityFilter(params);
   try {
-    const absPath = resolvePathInsideContext(filePath);
+    const absPath = resolveReadablePathInsideContext(filePath);
     if (isDirectoryPath(absPath)) {
       const extension = inferExtensionFromDirectory(absPath);
       if (!extension) {
@@ -5291,7 +5653,7 @@ async function executeLspDiagnostics(params, signal) {
       };
       return text(output2.output, details2);
     }
-    const result = await withLspClient(filePath, async (client) => client.diagnostics(filePath, signal), "diagnostics", clientOptions(signal));
+    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 = {
@@ -5338,6 +5700,96 @@ async function executeLspDiagnostics(params, signal) {
     throw error;
   }
 }
+// ../lsp-core/src/lsp/format-document.ts
+import { readFileSync as readFileSync6, renameSync as renameSync3, unlinkSync as unlinkSync2, 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 = readFileSync6(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 {
+      unlinkSync2(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");
@@ -5366,7 +5818,7 @@ async function executeLspGotoDefinition(params, signal) {
   const line = requireNumber(params, "line");
   const character = requireNumber(params, "character");
   try {
-    const result = await withLspClient(filePath, async (client) => client.definition(filePath, line, character, signal), "definition", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.definition(resolvedFilePath, line, character, signal), "definition", clientOptions(signal));
     const locations = !result ? [] : Array.isArray(result) ? result : [result];
     const details = { filePath, line, character, locations };
     if (locations.length === 0)
@@ -5391,7 +5843,7 @@ async function executeLspFindReferences(params, signal) {
   const character = requireNumber(params, "character");
   const includeDeclaration = optionalBoolean(params, "includeDeclaration") ?? true;
   try {
-    const result = await withLspClient(filePath, async (client) => client.references(filePath, line, character, includeDeclaration, signal), "references", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.references(resolvedFilePath, line, character, includeDeclaration, signal), "references", clientOptions(signal));
     const references = Array.isArray(result) ? result : [];
     const total = references.length;
     const truncated = total > DEFAULT_MAX_REFERENCES;
@@ -5433,7 +5885,7 @@ async function executeLspPrepareRename(params, signal) {
   const line = requireNumber(params, "line");
   const character = requireNumber(params, "character");
   try {
-    const result = await withLspClient(filePath, async (client) => client.prepareRename(filePath, line, character, signal), "prepareRename", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.prepareRename(resolvedFilePath, line, character, signal), "prepareRename", clientOptions(signal));
     const details = { filePath, line, character, result };
     return text(formatPrepareRenameResult(result), details);
   } catch (error) {
@@ -5454,7 +5906,7 @@ async function executeLspRename(params, signal) {
   const character = requireNumber(params, "character");
   const newName = requireString(params, "newName");
   try {
-    const result = await withLspClient(filePath, async (client) => client.rename(filePath, line, character, newName, signal), "rename", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.rename(resolvedFilePath, line, character, newName, signal), "rename", clientOptions(signal));
     const details = { filePath, line, character, newName, apply: result.apply, edit: result.edit };
     return text(formatApplyResult(result.apply), details, !result.apply.success);
   } catch (error) {
@@ -5534,7 +5986,7 @@ async function executeLspSymbols(params, signal) {
       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.documentSymbols(filePath, signal), "documentSymbols", clientOptions(signal));
+    const symbols = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal), "documentSymbols", clientOptions(signal));
     return formatSymbolsResult(filePath, scope, symbols, limit);
   } catch (error) {
     const query = optionalString(params, "query");
@@ -5670,6 +6122,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"],
@@ -5770,7 +6232,10 @@ function requestedProtocolVersion(params) {
 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")
@@ -5886,14 +6351,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 }
   });
 }
@@ -5908,7 +6376,7 @@ function withContext(args, context) {
 function ensureDaemonAvailable(paths, ensure, signal) {
   if (!signal)
     return ensure(paths);
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let settled = false;
     const finish = (run) => {
       if (settled)
@@ -5923,11 +6391,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(() => resolve10()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
   });
 }
 function sendToolCall(paths, token, name, args, options) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const socket = connect(paths.socket);
     const requestId = allocateProxyRequestId();
     let settled = false;
@@ -5980,7 +6448,7 @@ function sendToolCall(paths, token, name, args, options) {
       }
       const result = toToolResult(message, requestId);
       if (result)
-        finish(() => resolve9(result));
+        finish(() => resolve10(result));
       else
         finish(() => reject(new DaemonRequestError("invalid daemon response", requestWritten)));
     });
@@ -6025,8 +6493,8 @@ function isRetryableTool(name) {
   return name !== "rename" && name !== "lsp_rename";
 }
 // src/proxy.ts
-import { existsSync as existsSync12, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename3, delimiter as delimiter4, dirname as dirname9, isAbsolute as isAbsolute5 } from "node:path";
+import { existsSync as existsSync13, realpathSync as realpathSync6 } from "node:fs";
+import { basename as basename4, delimiter as delimiter4, dirname as dirname11, isAbsolute as isAbsolute6 } from "node:path";
 var DEFAULT_STARTUP_TIMEOUT_MS = 1e4;
 async function runMcpStdioProxy(options = {}) {
   const input = options.input ?? process.stdin;
@@ -6149,34 +6617,34 @@ 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) || !existsSync13(value))
     return value;
-  return realpathSync4(value);
+  return realpathSync6(value);
 }
 function projectRootFromOpenCodeConfigPath(path2) {
-  if (basename3(path2) !== "lsp.json" && basename3(path2) !== "lsp-client.json")
+  if (basename4(path2) !== "lsp.json" && basename4(path2) !== "lsp-client.json")
     return;
-  const configDir = dirname9(path2);
-  const configDirName = basename3(configDir);
+  const configDir = dirname11(path2);
+  const configDirName = basename4(configDir);
   if (configDirName !== ".opencode" && configDirName !== ".omo")
     return;
-  return dirname9(configDir);
+  return dirname11(configDir);
 }
 export {
-  validateDaemonVersion,
-  runMcpStdioProxy,
-  resolveDaemonRuntime,
-  probeDaemon,
-  ensureDaemonRunning,
-  disposeDefaultLspManager,
-  daemonPaths,
-  currentRequestContext,
-  callToolViaDaemon,
-  callDiagnosticsViaDaemon,
-  OMO_LSP_DAEMON_VERSION,
-  OMO_LSP_DAEMON_DIR,
-  OMO_LSP_DAEMON_CLI,
-  InvalidRuntimeOverrideError,
+  InvalidDaemonDirectoryError,
   InvalidDaemonVersionError,
-  InvalidDaemonDirectoryError
+  InvalidRuntimeOverrideError,
+  OMO_LSP_DAEMON_CLI,
+  OMO_LSP_DAEMON_DIR,
+  OMO_LSP_DAEMON_VERSION,
+  callDiagnosticsViaDaemon,
+  callToolViaDaemon,
+  currentRequestContext,
+  daemonPaths,
+  disposeDefaultLspManager,
+  ensureDaemonRunning,
+  probeDaemon,
+  resolveDaemonRuntime,
+  runMcpStdioProxy,
+  validateDaemonVersion
 };