oh-my-opencode 4.18.0 → 4.18.1

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

@@ -1,31 +1,16 @@
 // ../lsp-core/src/lsp/cleanup-errors.ts
-function reportBestEffortCleanupError(operation, error) {
-  if (process.env["CODEX_LSP_DEBUG_CLEANUP"] !== "1")
-    return;
+function writeCleanupError(message) {
+  process.stderr.write(`${message}
+`);
+}
+function reportBestEffortCleanupError(operation, error, logger = writeCleanupError) {
   const message = error instanceof Error ? error.message : String(error);
-  console.error(`[codex-lsp] ignored ${operation} failure during cleanup: ${message}`);
+  logger(`[lsp] ignored ${operation} failure during cleanup: ${message}`);
 }
 
 // ../lsp-core/src/lsp/client.ts
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-
-// ../lsp-core/src/request-context.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var storage = new AsyncLocalStorage;
-function runWithRequestContext(context, fn) {
-  return storage.run(context, fn);
-}
-function contextCwd() {
-  return storage.getStore()?.cwd ?? process.cwd();
-}
-function contextEnv(key) {
-  const store = storage.getStore();
-  if (store?.env)
-    return store.env[key];
-  return process.env[key];
-}
+import { resolve as resolve5 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // ../lsp-core/src/lsp/connection.ts
 import { pathToFileURL } from "node:url";
@@ -89,7 +74,12 @@ class LspInvalidPathError extends Error {
 }
 
 class LspServerLookupError extends Error {
+  lookup;
   name = "LspServerLookupError";
+  constructor(message, lookup) {
+    super(message);
+    this.lookup = lookup;
+  }
 }
 
 class LspServerInitializingError extends Error {
@@ -155,28 +145,80 @@ class JsonRpcConnection {
   onError(handler) {
     this.errorHandlers.push(handler);
   }
-  async sendRequest(method, params) {
+  async sendRequest(method, params, options = {}) {
     if (this.disposed)
       throw new Error("JSON-RPC connection is disposed");
     const id = this.nextRequestId;
     this.nextRequestId += 1;
+    const key = String(id);
     const message = params === undefined ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
+    let requestWritten = false;
+    let cancelAfterWrite = false;
+    let settled = false;
+    const writeCancel = () => this.writeMessage({ jsonrpc: "2.0", method: "$/cancelRequest", params: { id } });
     const responsePromise = new Promise((resolve, reject) => {
-      this.pendingRequests.set(String(id), {
+      const cleanup = () => {
+        options.signal?.removeEventListener("abort", onAbort);
+      };
+      const settleCancel = () => {
+        if (settled)
+          return;
+        settled = true;
+        this.pendingRequests.delete(key);
+        cleanup();
+        const rejectCancelled = () => reject(abortError(options.signal));
+        if (!requestWritten) {
+          cancelAfterWrite = true;
+          rejectCancelled();
+          return;
+        }
+        writeCancel().then(rejectCancelled, (error) => {
+          this.emitError(toError(error));
+          rejectCancelled();
+        });
+      };
+      const onAbort = () => settleCancel();
+      this.pendingRequests.set(key, {
         resolve(result) {
+          settled = true;
+          cleanup();
           resolve(result);
         },
-        reject
+        reject(error) {
+          settled = true;
+          cleanup();
+          reject(error);
+        },
+        cleanup
       });
+      if (options.signal?.aborted) {
+        settleCancel();
+        return;
+      }
+      options.signal?.addEventListener("abort", onAbort, { once: true });
     });
+    if (settled)
+      return responsePromise;
     try {
       await this.writeMessage(message);
+      requestWritten = true;
+      if (cancelAfterWrite)
+        await writeCancel();
     } catch (error) {
-      this.pendingRequests.delete(String(id));
+      if (settled)
+        return responsePromise;
+      const pending = this.pendingRequests.get(key);
+      if (pending) {
+        pending.cleanup();
+        this.pendingRequests.delete(key);
+      }
       throw error;
     }
     return responsePromise;
   }
+  pendingRequestCount() {
+    return this.pendingRequests.size;
+  }
   async sendNotification(method, params) {
     if (this.disposed)
       return;
@@ -193,6 +235,7 @@ class JsonRpcConnection {
     this.reader.off("error", this.handleStreamError);
     this.writer.off("error", this.handleStreamError);
     for (const pending of this.pendingRequests.values()) {
+      pending.cleanup();
       pending.reject(new Error("JSON-RPC connection disposed"));
     }
     this.pendingRequests.clear();
@@ -268,6 +311,7 @@ class JsonRpcConnection {
     if (!pending)
       return;
     this.pendingRequests.delete(String(id));
+    pending.cleanup();
     if ("error" in message) {
       pending.reject(jsonRpcErrorToError(message["error"]));
       return;
@@ -281,7 +325,11 @@ class JsonRpcConnection {
     try {
       handler(params);
     } catch (error) {
-      this.emitError(toError(error));
+      if (error instanceof Error) {
+        this.emitError(error);
+        return;
+      }
+      this.emitError(new Error(String(error)));
     }
   }
   handleRequest(message) {
@@ -322,6 +370,14 @@ ${body}`;
     }
   }
 }
+function abortError(signal) {
+  const reason = signal?.reason;
+  if (reason instanceof Error)
+    return reason;
+  const error = new Error(typeof reason === "string" ? reason : "LSP request cancelled");
+  error.name = "AbortError";
+  return error;
+}
 function parseContentLength(headers) {
   for (const line of headers.split(`\r
 `)) {
@@ -508,7 +564,7 @@ function spawnProcess(command, options) {
   return wrap(proc);
 }
 
-// ../lsp-core/src/lsp/transport.ts
+// ../lsp-core/src/lsp/transport-protocol.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -528,7 +584,32 @@ function parseDiagnosticsParams(params) {
   if (!isRecord(params) || typeof params["uri"] !== "string")
     return null;
   const diagnostics = Array.isArray(params["diagnostics"]) ? params["diagnostics"].filter(isDiagnostic) : [];
-  return { uri: params["uri"], diagnostics };
+  const version = typeof params["version"] === "number" ? params["version"] : undefined;
+  return { uri: params["uri"], diagnostics, ...version === undefined ? {} : { version } };
+}
+function createLspSpawnEnv(_root, input) {
+  return { ...input };
+}
+function isDiagnostic(value) {
+  return isRecord(value) && isRange(value["range"]) && typeof value["message"] === "string";
+}
+function isRange(value) {
+  return isRecord(value) && isPosition(value["start"]) && isPosition(value["end"]);
+}
+function isPosition(value) {
+  return isRecord(value) && typeof value["line"] === "number" && typeof value["character"] === "number";
+}
+
+// ../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;
+  }
 }
 
 class LspClientTransport {
@@ -541,6 +622,8 @@ class LspClientTransport {
   diagnosticsStore = new Map;
   requestTimeoutMs;
   initializeTimeoutMs;
+  workspaceApplyEditHandler = null;
+  diagnosticPullSupported = false;
   constructor(root, server, timeouts = {}) {
     this.root = root;
     this.server = server;
@@ -553,6 +636,21 @@ class LspClientTransport {
   command() {
     return [...this.server.command];
   }
+  setWorkspaceApplyEditHandler(handler) {
+    this.workspaceApplyEditHandler = handler;
+  }
+  hasWorkspaceApplyEditHandler() {
+    return this.workspaceApplyEditHandler !== null;
+  }
+  setDiagnosticPullSupported(supported) {
+    this.diagnosticPullSupported = supported;
+  }
+  isDiagnosticPullSupported() {
+    return this.diagnosticPullSupported;
+  }
+  handlePublishDiagnostics(params) {
+    this.diagnosticsStore.set(params.uri, [...params.diagnostics]);
+  }
   async start() {
     const env = createLspSpawnEnv(this.root, {
       ...process.env,
@@ -563,7 +661,6 @@ class LspClientTransport {
       env
     });
     this.startStderrReading();
-    await new Promise((resolve) => setTimeout(resolve, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -573,7 +670,7 @@ class LspClientTransport {
     this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
       const diagnosticsParams = parseDiagnosticsParams(params);
       if (diagnosticsParams?.uri) {
-        this.diagnosticsStore.set(diagnosticsParams.uri, diagnosticsParams.diagnostics);
+        this.handlePublishDiagnostics(diagnosticsParams);
       }
     });
     this.connection.onRequest("workspace/configuration", (params) => {
@@ -586,6 +683,9 @@ class LspClientTransport {
     });
     this.connection.onRequest("client/registerCapability", () => null);
     this.connection.onRequest("window/workDoneProgress/create", () => null);
+    if (this.workspaceApplyEditHandler) {
+      this.connection.onRequest("workspace/applyEdit", this.workspaceApplyEditHandler);
+    }
     this.connection.onClose(() => {
       this.processExited = true;
     });
@@ -614,30 +714,25 @@ class LspClientTransport {
   }
   async sendRequest(method, ...args) {
     if (!this.connection)
-      throw new Error("LSP client not started");
+      throw new LspClientNotStartedError(this.server.id, this.root);
     if (this.processExited || this.proc && this.proc.exitCode !== null) {
       const stderrTail = this.stderrBuffer.slice(-10).join(`
 `);
       throw new LspProcessExitedError(this.server.id, this.root, this.proc?.exitCode ?? null, stderrTail || undefined);
     }
-    const timeoutMs = args[1]?.timeoutMs ?? this.requestTimeoutMs;
-    let timeoutHandle = null;
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutHandle = setTimeout(() => {
-        const stderrTail = this.stderrBuffer.slice(-5).join(`
+    const options = args[1];
+    const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
+    const timeoutController = new AbortController;
+    const timeoutHandle = setTimeout(() => {
+      const stderrTail = this.stderrBuffer.slice(-5).join(`
 `);
-        reject(new LspRequestTimeoutError(method, stderrTail || undefined));
-      }, timeoutMs);
-    });
+      timeoutController.abort(new LspRequestTimeoutError(method, stderrTail || undefined));
+    }, timeoutMs);
+    const combinedSignal = combineAbortSignals(options?.signal, timeoutController.signal);
     try {
-      const requestPromise = args.length === 0 ? this.connection.sendRequest(method) : this.connection.sendRequest(method, args[0]);
-      const result = await Promise.race([requestPromise, timeoutPromise]);
-      if (timeoutHandle !== null)
-        clearTimeout(timeoutHandle);
+      const result = args.length === 0 ? await this.connection.sendRequest(method, undefined, { signal: combinedSignal.signal }) : await this.connection.sendRequest(method, args[0], { signal: combinedSignal.signal });
       return result;
     } catch (error) {
-      if (timeoutHandle !== null)
-        clearTimeout(timeoutHandle);
       if (this.processExited || this.proc && this.proc.exitCode !== null) {
         throw new LspProcessExitedError(this.server.id, this.root, this.proc?.exitCode ?? null, this.stderrBuffer.slice(-10).join(`
 `) || undefined);
@@ -646,6 +741,9 @@ class LspClientTransport {
         throw new LspConnectionClosedError(this.server.id, this.root, error.message);
       }
       throw error;
+    } finally {
+      clearTimeout(timeoutHandle);
+      combinedSignal.dispose();
     }
   }
   async sendNotification(method, ...args) {
@@ -674,17 +772,17 @@ class LspClientTransport {
       try {
         await this.sendRequest("shutdown");
       } catch (error) {
-        reportBestEffortCleanupError("shutdown request", error);
+        reportBestEffortCleanupError("shutdown request", error instanceof Error ? error : String(error));
       }
       try {
         await this.sendNotification("exit");
       } catch (error) {
-        reportBestEffortCleanupError("exit notification", error);
+        reportBestEffortCleanupError("exit notification", error instanceof Error ? error : String(error));
       }
       try {
         this.connection.dispose();
       } catch (error) {
-        reportBestEffortCleanupError("connection dispose", error);
+        reportBestEffortCleanupError("connection dispose", error instanceof Error ? error : String(error));
       }
       this.connection = null;
     }
@@ -715,11 +813,11 @@ class LspClientTransport {
               new Promise((resolve) => setTimeout(resolve, STOP_SIGKILL_GRACE_MS))
             ]);
           } catch (error) {
-            reportBestEffortCleanupError("hard process kill", error);
+            reportBestEffortCleanupError("hard process kill", error instanceof Error ? error : String(error));
           }
         }
       } catch (error) {
-        reportBestEffortCleanupError("process stop", error);
+        reportBestEffortCleanupError("process stop", error instanceof Error ? error : String(error));
       }
     }
     this.processExited = true;
@@ -729,26 +827,45 @@ class LspClientTransport {
     return this.diagnosticsStore.get(uri) ?? [];
   }
 }
-function createLspSpawnEnv(_root, input) {
-  return { ...input };
-}
-function isDiagnostic(value) {
-  return isRecord(value) && isRange(value["range"]) && typeof value["message"] === "string";
-}
-function isRange(value) {
-  return isRecord(value) && isPosition(value["start"]) && isPosition(value["end"]);
-}
-function isPosition(value) {
-  return isRecord(value) && typeof value["line"] === "number" && typeof value["character"] === "number";
+function combineAbortSignals(primary, secondary) {
+  const controller = new AbortController;
+  const abortFrom = (signal) => {
+    if (!controller.signal.aborted)
+      controller.abort(signal.reason);
+  };
+  const onPrimaryAbort = () => {
+    if (primary)
+      abortFrom(primary);
+  };
+  const onSecondaryAbort = () => abortFrom(secondary);
+  if (primary?.aborted)
+    abortFrom(primary);
+  else
+    primary?.addEventListener("abort", onPrimaryAbort, { once: true });
+  if (secondary.aborted)
+    abortFrom(secondary);
+  else
+    secondary.addEventListener("abort", onSecondaryAbort, { once: true });
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      primary?.removeEventListener("abort", onPrimaryAbort);
+      secondary.removeEventListener("abort", onSecondaryAbort);
+    }
+  };
 }
 
 // ../lsp-core/src/lsp/connection.ts
-var INITIALIZE_SETTLE_MS = 300;
+function supportsDiagnosticPull(capabilities) {
+  if (capabilities === undefined)
+    return false;
+  return Object.hasOwn(capabilities, "diagnosticProvider");
+}
 
 class LspClientConnection extends LspClientTransport {
   async initialize() {
     const rootUri = pathToFileURL(this.root).href;
-    await this.sendRequest("initialize", {
+    const result = await this.sendRequest("initialize", {
       processId: process.pid,
       rootUri,
       rootPath: this.root,
@@ -762,8 +879,7 @@ class LspClientConnection extends LspClientTransport {
           publishDiagnostics: {},
           rename: {
             prepareSupport: true,
-            prepareSupportDefaultBehavior: 1,
-            honorsChangeAnnotations: true
+            prepareSupportDefaultBehavior: 1
           },
           codeAction: {
             codeActionLiteralSupport: {
@@ -792,22 +908,28 @@ class LspClientConnection extends LspClientTransport {
           symbol: {},
           workspaceFolders: true,
           configuration: true,
-          applyEdit: true,
+          ...this.hasWorkspaceApplyEditHandler() ? { applyEdit: true } : {},
           workspaceEdit: {
-            documentChanges: true
+            documentChanges: true,
+            resourceOperations: ["create", "rename", "delete"]
           }
         }
       },
       initializationOptions: this.server.initialization
     }, { timeoutMs: this.initializeTimeoutMs });
+    this.setDiagnosticPullSupported(supportsDiagnosticPull(result?.capabilities));
     await this.sendNotification("initialized");
     await this.sendNotification("workspace/didChangeConfiguration", {
       settings: { json: { validate: { enable: true } } }
     });
-    await new Promise((r) => setTimeout(r, INITIALIZE_SETTLE_MS));
   }
 }
 
+// ../lsp-core/src/lsp/workspace-document-state.ts
+import { readFileSync, realpathSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+
 // ../lsp-core/src/lsp/effective-extension.ts
 import { basename, extname } from "node:path";
 var BASENAME_EXTENSIONS = {
@@ -990,191 +1112,1662 @@ function getLanguageId(ext) {
   return EXT_TO_LANG[ext] ?? "plaintext";
 }
 
-// ../lsp-core/src/lsp/client.ts
-var POST_OPEN_DELAY_MS = 1000;
-var POST_DIAGNOSTICS_WAIT_MS = 500;
+// ../lsp-core/src/lsp/workspace-document-state.ts
+var WATCHED_FILE_BATCH_SIZE = 128;
+var DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
+function canonicalPath(filePath) {
+  const absolute = resolve(filePath);
+  try {
+    return realpathSync(absolute);
+  } catch {
+    return absolute;
+  }
+}
+function isSameOrDescendant(candidate, parent) {
+  const suffix = relative(parent, candidate);
+  return suffix === "" || !suffix.startsWith("..") && suffix !== "..";
+}
+function movedPath(candidate, oldPath, newPath) {
+  const suffix = relative(oldPath, candidate);
+  return suffix === "" ? newPath : resolve(newPath, suffix);
+}
 
-class LspClient extends LspClientConnection {
-  openedFiles = new Set;
-  documentVersions = new Map;
-  lastSyncedText = new Map;
-  diagnosticPullErrors = [];
-  getDiagnosticPullErrors() {
-    return this.diagnosticPullErrors;
+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.versionlessPublishQuiescenceMs = options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
   }
   async openFile(filePath) {
-    const absPath = resolve(contextCwd(), filePath);
-    const uri = pathToFileURL2(absPath).href;
-    const text = readFileSync(absPath, "utf-8");
-    if (!this.openedFiles.has(absPath)) {
-      const ext = effectiveExtension(absPath);
-      const languageId = getLanguageId(ext);
-      const version = 1;
-      await this.sendNotification("textDocument/didOpen", {
-        textDocument: {
-          uri,
-          languageId,
-          version,
-          text
-        }
-      });
-      this.openedFiles.add(absPath);
-      this.documentVersions.set(uri, version);
-      this.lastSyncedText.set(uri, text);
-      await new Promise((r) => setTimeout(r, POST_OPEN_DELAY_MS));
-      return;
+    const path = canonicalPath(filePath);
+    const existingOpen = this.openPromises.get(path);
+    if (existingOpen) {
+      await existingOpen;
+      return this.openFile(path);
     }
-    const prevText = this.lastSyncedText.get(uri);
-    if (prevText === text) {
+    const text = readFileSync(path, "utf-8");
+    const existing = this.openDocuments.get(path);
+    if (!existing)
+      return this.openDocumentSingleFlight(path, text);
+    if (existing.text === text)
       return;
-    }
-    const nextVersion = (this.documentVersions.get(uri) ?? 1) + 1;
-    this.documentVersions.set(uri, nextVersion);
-    this.lastSyncedText.set(uri, text);
-    await this.sendNotification("textDocument/didChange", {
-      textDocument: { uri, version: nextVersion },
-      contentChanges: [{ text }]
-    });
-    await this.sendNotification("textDocument/didSave", {
-      textDocument: { uri },
-      text
-    });
+    await this.changeDocument(existing, text);
   }
-  async definition(filePath, line, character) {
-    const absPath = resolve(contextCwd(), filePath);
-    await this.openFile(absPath);
-    return this.sendRequest("textDocument/definition", {
-      textDocument: { uri: pathToFileURL2(absPath).href },
-      position: { line: line - 1, character }
-    });
+  getVersion(filePath) {
+    return this.openDocuments.get(canonicalPath(filePath))?.version;
   }
-  async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve(contextCwd(), filePath);
-    await this.openFile(absPath);
-    return this.sendRequest("textDocument/references", {
-      textDocument: { uri: pathToFileURL2(absPath).href },
-      position: { line: line - 1, character },
-      context: { includeDeclaration }
-    });
+  getStoredDiagnostics(uri) {
+    const state = this.openByUri.get(uri);
+    if (!state)
+      return [];
+    return state.lastPublish?.diagnostics ?? state.pullCache?.diagnostics ?? [];
+  }
+  captureDiagnosticSnapshot(filePath) {
+    const state = this.openDocuments.get(canonicalPath(filePath));
+    if (!state)
+      return null;
+    return {
+      path: state.path,
+      uri: state.uri,
+      version: state.version,
+      documentGeneration: state.generation,
+      publishGeneration: state.publishGeneration
+    };
   }
-  async documentSymbols(filePath) {
-    const absPath = resolve(contextCwd(), filePath);
-    await this.openFile(absPath);
-    return this.sendRequest("textDocument/documentSymbol", {
-      textDocument: { uri: pathToFileURL2(absPath).href }
-    });
+  isCurrentSnapshot(snapshot) {
+    const state = this.openDocuments.get(snapshot.path);
+    return state !== undefined && state.uri === snapshot.uri && state.version === snapshot.version && state.generation === snapshot.documentGeneration;
   }
-  async workspaceSymbols(query) {
-    return this.sendRequest("workspace/symbol", { query });
+  getPullCache(snapshot) {
+    const state = this.openByUri.get(snapshot.uri);
+    if (!state?.pullCache || state.pullCache.documentVersion !== snapshot.version)
+      return null;
+    return state.pullCache;
   }
-  isUnsupportedDiagnosticPullError(error) {
-    if (!(error instanceof Error))
-      return false;
-    const code = "code" in error && typeof error.code === "number" ? error.code : undefined;
-    if (code === -32601)
-      return true;
-    return /unsupported|not supported|method not found|unknown request/i.test(error.message);
+  recordPullDiagnostics(snapshot, report) {
+    const state = this.openByUri.get(snapshot.uri);
+    if (!state)
+      return;
+    state.pullCache = {
+      documentVersion: snapshot.version,
+      diagnostics: [...report.diagnostics],
+      ...report.resultId === undefined ? {} : { resultId: report.resultId }
+    };
   }
-  async diagnostics(filePath) {
-    const absPath = resolve(contextCwd(), filePath);
-    const uri = pathToFileURL2(absPath).href;
-    await this.openFile(absPath);
-    await new Promise((r) => setTimeout(r, POST_DIAGNOSTICS_WAIT_MS));
-    try {
-      const result = await this.sendRequest("textDocument/diagnostic", {
-        textDocument: { uri }
-      });
-      if (result.items) {
-        return { items: result.items };
+  recordPublishedDiagnostics(params) {
+    const state = this.openByUri.get(params.uri);
+    if (!state)
+      return;
+    state.publishGeneration += 1;
+    state.lastPublish = {
+      diagnostics: [...params.diagnostics],
+      publishGeneration: state.publishGeneration,
+      documentGenerationAtArrival: state.generation,
+      arrivedAt: this.now(),
+      ...params.version === undefined ? {} : { version: params.version }
+    };
+    this.notifyWaiters(state);
+  }
+  resolvePushDiagnostics(snapshot) {
+    const state = this.openByUri.get(snapshot.uri);
+    if (!state?.lastPublish)
+      return { status: "missing" };
+    const publish = state.lastPublish;
+    if (publish.version !== undefined) {
+      return publish.version === snapshot.version ? { status: "ready", diagnostics: publish.diagnostics } : { status: "missing" };
+    }
+    if (publish.documentGenerationAtArrival < snapshot.documentGeneration)
+      return { status: "missing" };
+    const readyAt = publish.arrivedAt + this.versionlessPublishQuiescenceMs;
+    const waitMs = Math.max(0, readyAt - this.now());
+    return waitMs === 0 ? { status: "ready", diagnostics: publish.diagnostics } : { status: "wait", waitMs };
+  }
+  waitForDiagnosticsActivity(snapshot, timeoutMs) {
+    const state = this.openByUri.get(snapshot.uri);
+    if (!state || timeoutMs <= 0)
+      return Promise.resolve();
+    return new Promise((resolveActivity) => {
+      let settled = false;
+      const finish = () => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        state.waiters.delete(finish);
+        resolveActivity();
+      };
+      const timer = setTimeout(finish, timeoutMs);
+      if (typeof timer.unref === "function")
+        timer.unref();
+      state.waiters.add(finish);
+    });
+  }
+  validateVersions(operations) {
+    const versions = new Map([...this.openDocuments].map(([path, state]) => [path, state.version]));
+    for (const operation of operations) {
+      if (operation.kind === "text") {
+        const current = versions.get(operation.path);
+        if (operation.documentVersion !== null && current !== operation.documentVersion) {
+          const observed = current === undefined ? "closed document" : `open document version ${current}`;
+          return {
+            changeIndex: operation.changeIndex,
+            message: `document version ${operation.documentVersion} does not match ${observed} for ${operation.path}`
+          };
+        }
+        if (current !== undefined)
+          versions.set(operation.path, current + 1);
+        continue;
       }
-    } catch (error) {
-      if (!this.isUnsupportedDiagnosticPullError(error)) {
-        this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
+      if (operation.kind === "rename") {
+        const moved = [...versions].filter(([path]) => isSameOrDescendant(path, operation.oldPath));
+        for (const [path] of moved)
+          versions.delete(path);
+        for (const [path] of moved)
+          versions.set(movedPath(path, operation.oldPath, operation.newPath), 1);
+        continue;
+      }
+      if (operation.kind === "delete") {
+        for (const path of [...versions.keys()]) {
+          if (isSameOrDescendant(path, operation.path))
+            versions.delete(path);
+        }
+        continue;
+      }
+      if (operation.kind === "create" && operation.replaced && versions.has(operation.path)) {
+        versions.set(operation.path, 1);
       }
     }
-    return { items: this.getStoredDiagnostics(uri) };
+    return null;
   }
-  async prepareRename(filePath, line, character) {
-    const absPath = resolve(contextCwd(), filePath);
-    await this.openFile(absPath);
-    return this.sendRequest("textDocument/prepareRename", {
-      textDocument: { uri: pathToFileURL2(absPath).href },
-      position: { line: line - 1, character }
-    });
+  async synchronize(delta) {
+    const watched = [];
+    for (const mutation of delta.operations)
+      await this.synchronizeMutation(mutation, watched);
+    for (let index = 0;index < watched.length; index += WATCHED_FILE_BATCH_SIZE) {
+      await this.sendNotification("workspace/didChangeWatchedFiles", {
+        changes: watched.slice(index, index + WATCHED_FILE_BATCH_SIZE)
+      });
+    }
   }
-  async rename(filePath, line, character, newName) {
-    const absPath = resolve(contextCwd(), filePath);
-    await this.openFile(absPath);
-    return this.sendRequest("textDocument/rename", {
-      textDocument: { uri: pathToFileURL2(absPath).href },
-      position: { line: line - 1, character },
-      newName
+  async synchronizeMutation(mutation, watched) {
+    if (mutation.kind === "text") {
+      const state = this.openDocuments.get(mutation.path);
+      if (state)
+        await this.changeDocument(state, mutation.afterText);
+      else
+        watched.push({ uri: pathToFileURL2(mutation.path).href, type: 2 });
+      return;
+    }
+    if (mutation.kind === "create") {
+      const state = this.openDocuments.get(mutation.path);
+      if (state) {
+        await this.closeDocument(state);
+        await this.openDocumentSingleFlight(mutation.path, readFileSync(mutation.path, "utf-8"));
+      } else {
+        watched.push({ uri: pathToFileURL2(mutation.path).href, type: mutation.replaced ? 2 : 1 });
+      }
+      return;
+    }
+    if (mutation.kind === "rename") {
+      const moved = [...this.openDocuments.values()].filter((state) => isSameOrDescendant(state.path, mutation.oldPath));
+      for (const state of moved)
+        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"));
+      }
+      if (moved.length === 0) {
+        watched.push({ uri: pathToFileURL2(mutation.oldPath).href, type: 3 });
+        watched.push({ uri: pathToFileURL2(mutation.newPath).href, type: 1 });
+      }
+      return;
+    }
+    const removed = [...this.openDocuments.values()].filter((state) => isSameOrDescendant(state.path, mutation.path));
+    for (const state of removed)
+      await this.closeDocument(state);
+    if (removed.length === 0)
+      watched.push({ uri: pathToFileURL2(mutation.path).href, type: 3 });
+  }
+  async openDocumentSingleFlight(path, text) {
+    const existing = this.openPromises.get(path);
+    if (existing)
+      return existing;
+    const open = (async () => {
+      const state = {
+        path,
+        uri: pathToFileURL2(path).href,
+        languageId: getLanguageId(effectiveExtension(path)),
+        text,
+        version: 1,
+        generation: 1,
+        publishGeneration: 0,
+        waiters: new Set
+      };
+      this.openDocuments.set(path, state);
+      this.openByUri.set(state.uri, state);
+      this.notifyWaiters(state);
+      await this.sendNotification("textDocument/didOpen", {
+        textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text }
+      });
+    })().finally(() => {
+      this.openPromises.delete(path);
     });
+    this.openPromises.set(path, open);
+    return open;
+  }
+  async changeDocument(state, text) {
+    state.text = text;
+    state.version += 1;
+    state.generation += 1;
+    this.clearDiagnostics(state.uri);
+    this.notifyWaiters(state);
+    await this.sendNotification("textDocument/didChange", {
+      textDocument: { uri: state.uri, version: state.version },
+      contentChanges: [{ text }]
+    });
+    await this.sendNotification("textDocument/didSave", { textDocument: { uri: state.uri }, text });
+  }
+  async closeDocument(state) {
+    this.openDocuments.delete(state.path);
+    this.openByUri.delete(state.uri);
+    this.clearDiagnostics(state.uri);
+    this.notifyWaiters(state);
+    await this.sendNotification("textDocument/didClose", { textDocument: { uri: state.uri } });
+  }
+  notifyWaiters(state) {
+    for (const waiter of [...state.waiters])
+      waiter();
   }
 }
 
-// ../lsp-core/src/lsp/process-signal-cleanup.ts
-function installProcessSignalCleanup(cleanup) {
-  const signals = process.platform === "win32" ? ["SIGINT", "SIGTERM", "SIGBREAK"] : ["SIGINT", "SIGTERM"];
-  const handler = () => {
-    cleanup().catch((error) => {
-      reportBestEffortCleanupError("signal cleanup", error);
-    });
-  };
-  for (const signal of signals) {
-    process.on(signal, handler);
-  }
-  return () => {
-    for (const signal of signals) {
-      process.removeListener(signal, handler);
-    }
-  };
+// ../lsp-core/src/lsp/workspace-apply-edit-failure.ts
+var CONCURRENT_FAILURE_REASON_BY_PHASE = {
+  applying: "workspace/applyEdit is already in progress for this workspace mutation",
+  settled: "workspace/applyEdit was already handled for this workspace mutation"
+};
+function workspaceApplyEditConcurrentFailureReason(phase) {
+  return CONCURRENT_FAILURE_REASON_BY_PHASE[phase];
 }
 
-// ../lsp-core/src/lsp/manager.ts
-async function stopClientBestEffort(client) {
+// ../lsp-core/src/lsp/workspace-edit-commit.ts
+import { existsSync as existsSync3, lstatSync as lstatSync2, renameSync, rmSync, writeFileSync } from "node:fs";
+
+// ../lsp-core/src/lsp/workspace-edit-path.ts
+import { existsSync as existsSync2, lstatSync, readFileSync as readFileSync2, readdirSync, realpathSync as realpathSync2 } from "node:fs";
+import { dirname, isAbsolute, relative as relative2, resolve as resolve2 } 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;
+  }
+}
+function isPathInsideWorkspace(filePath, workspaceRoot) {
+  const relativePath = relative2(workspaceRoot, filePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function canonicalizeMissingPath(filePath) {
+  let ancestor = filePath;
+  while (!existsSync2(ancestor)) {
+    const parent = dirname(ancestor);
+    if (parent === ancestor)
+      throw new WorkspaceEditPathError(filePath, "no existing ancestor");
+    ancestor = parent;
+  }
+  return resolve2(realpathSync2(ancestor), relative2(ancestor, filePath));
+}
+function canonicalWorkspaceRoot(workspaceRoot) {
   try {
-    await client.stop();
+    const canonical = realpathSync2(resolve2(workspaceRoot));
+    if (!lstatSync(canonical).isDirectory()) {
+      return { success: false, error: `workspace root is not a directory: ${workspaceRoot}` };
+    }
+    return {
+      success: true,
+      path: canonical,
+      requestedPath: resolve2(workspaceRoot),
+      followedSymbolicLink: existsSync2(resolve2(workspaceRoot)) && lstatSync(resolve2(workspaceRoot)).isSymbolicLink()
+    };
   } catch (error) {
-    reportBestEffortCleanupError("client stop", error);
+    const detail = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `workspace root ${workspaceRoot}: ${detail}` };
   }
 }
-function awaitWithSignal(promise, signal) {
-  if (!signal)
-    return promise;
-  return new Promise((resolve2, reject) => {
-    let settled = false;
-    const onAbort = () => {
-      if (settled)
-        return;
-      settled = true;
-      reject(new DOMException("Aborted", "AbortError"));
-    };
-    if (signal.aborted) {
-      onAbort();
-      return;
+function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
+  let requestedPath;
+  try {
+    const parsed = new URL(uri);
+    if (parsed.protocol !== "file:" || parsed.search !== "" || parsed.hash !== "") {
+      return { success: false, error: `non-file URI ${uri}` };
     }
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then((value) => {
-      if (settled)
-        return;
-      settled = true;
-      signal.removeEventListener("abort", onAbort);
-      resolve2(value);
-    }, (err) => {
-      if (settled)
-        return;
-      settled = true;
-      signal.removeEventListener("abort", onAbort);
-      reject(err);
-    });
-  });
+    requestedPath = resolve2(fileURLToPath(parsed));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `non-file URI ${uri}: ${detail}` };
+  }
+  try {
+    const canonical = existsSync2(requestedPath) ? realpathSync2(requestedPath) : canonicalizeMissingPath(requestedPath);
+    if (!isPathInsideWorkspace(canonical, workspaceRoot)) {
+      return { success: false, error: `${requestedPath}: outside workspace ${workspaceRoot}` };
+    }
+    return {
+      success: true,
+      path: canonical,
+      requestedPath,
+      followedSymbolicLink: existsSync2(requestedPath) && lstatSync(requestedPath).isSymbolicLink()
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `${requestedPath}: ${detail}` };
+  }
+}
+function snapshotPath(path, includeChildren) {
+  if (!existsSync2(path))
+    return { kind: "missing" };
+  const stats = lstatSync(path);
+  if (stats.isFile())
+    return { kind: "file", content: readFileSync2(path, "utf-8") };
+  if (stats.isDirectory()) {
+    return includeChildren ? { kind: "directory", children: readdirSync(path).sort() } : { kind: "directory" };
+  }
+  throw new WorkspaceEditPathError(path, "unsupported filesystem entry");
 }
 
-class LspManager {
-  clients = new Map;
-  reaperHandle = null;
-  signalDisposer = null;
+// ../lsp-core/src/lsp/workspace-edit-commit.ts
+var DEFAULT_IO = {
+  writeFile(path, content) {
+    writeFileSync(path, content, "utf-8");
+  },
+  rename(oldPath, newPath) {
+    renameSync(oldPath, newPath);
+  },
+  remove(path, recursive) {
+    rmSync(path, { recursive, force: false });
+  }
+};
+function snapshotsEqual(expected, actual) {
+  if (expected.kind !== actual.kind)
+    return false;
+  if (expected.kind === "file" && actual.kind === "file")
+    return expected.content === actual.content;
+  if (expected.kind === "directory" && actual.kind === "directory" && expected.children !== undefined) {
+    return JSON.stringify(expected.children) === JSON.stringify(actual.children);
+  }
+  return true;
+}
+function liveSnapshot(path, expected) {
+  return snapshotPath(path, expected.kind === "directory" && expected.children !== undefined);
+}
+function firstOperationIndex(plan) {
+  return plan.operations[0]?.changeIndex ?? 0;
+}
+function failedCommit(plan, failure) {
+  const { message, changeIndex, mutations = [], filesModified = [], totalEdits = 0, lateAbort = false } = failure;
+  return {
+    result: {
+      success: false,
+      filesModified,
+      totalEdits,
+      errors: [`change ${changeIndex}: ${message}`],
+      failedChange: changeIndex,
+      ...lateAbort ? { lateAbort: true } : {}
+    },
+    delta: mutationDelta(mutations),
+    fingerprint: plan.fingerprint
+  };
+}
+function verifySnapshots(plan) {
+  for (const [path, expected] of plan.snapshots) {
+    let actual;
+    try {
+      actual = liveSnapshot(path, expected);
+    } catch (error) {
+      const changeIndex = plan.firstChangeByPath.get(path) ?? firstOperationIndex(plan);
+      const detail = error instanceof Error ? error.message : String(error);
+      return failedCommit(plan, { message: `cannot verify snapshot for ${path}: ${detail}`, changeIndex });
+    }
+    if (!snapshotsEqual(expected, actual)) {
+      const changeIndex = plan.firstChangeByPath.get(path) ?? firstOperationIndex(plan);
+      return failedCommit(plan, { message: `workspace state changed before commit: ${path}`, changeIndex });
+    }
+  }
+  return null;
+}
+function addModifiedPath(paths, path) {
+  if (!paths.includes(path))
+    paths.push(path);
+}
+function reportedPath(plan, path) {
+  return plan.reportedPathByCanonical.get(path) ?? path;
+}
+function changedPathsForMutation(mutation) {
+  return mutation.kind === "rename" ? [mutation.oldPath, mutation.newPath] : [mutation.path];
+}
+function mutationDelta(operations) {
+  const changedPaths = new Set;
+  for (const operation of operations) {
+    for (const path of changedPathsForMutation(operation))
+      changedPaths.add(path);
+  }
+  return { operations, changedPaths: [...changedPaths].sort() };
+}
+function resolveIo(overrides) {
+  return {
+    writeFile: overrides?.writeFile ?? DEFAULT_IO.writeFile,
+    rename: overrides?.rename ?? DEFAULT_IO.rename,
+    remove: overrides?.remove ?? DEFAULT_IO.remove
+  };
+}
+function commitOperation(context, operation) {
+  const { plan, io, accumulator } = context;
+  if (operation.kind === "noop")
+    return;
+  if (operation.kind === "text") {
+    io.writeFile(operation.path, operation.afterText);
+    accumulator.mutations.push({
+      kind: "text",
+      path: operation.path,
+      beforeText: operation.beforeText,
+      afterText: operation.afterText
+    });
+    addModifiedPath(accumulator.filesModified, reportedPath(plan, operation.path));
+    accumulator.totalEdits += operation.editCount;
+    return;
+  }
+  if (operation.kind === "create") {
+    io.writeFile(operation.path, "");
+    accumulator.mutations.push({ kind: "create", path: operation.path, replaced: operation.replaced });
+    addModifiedPath(accumulator.filesModified, reportedPath(plan, operation.path));
+    return;
+  }
+  if (operation.kind === "rename") {
+    if (operation.replaceDestination) {
+      const targetKind = existsSync3(operation.newPath) && lstatSync2(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));
+    }
+    io.rename(operation.oldPath, operation.newPath);
+    accumulator.mutations.push({
+      kind: "rename",
+      oldPath: operation.oldPath,
+      newPath: operation.newPath,
+      sourceKind: operation.sourceKind
+    });
+    addModifiedPath(accumulator.filesModified, reportedPath(plan, operation.newPath));
+    return;
+  }
+  io.remove(operation.path, operation.recursive);
+  accumulator.mutations.push({
+    kind: "delete",
+    path: operation.path,
+    targetKind: operation.targetKind
+  });
+  addModifiedPath(accumulator.filesModified, reportedPath(plan, operation.path));
+}
+function commitWorkspaceEditPlan(plan, options = {}) {
+  if (options.signal?.aborted) {
+    return failedCommit(plan, { message: "cancelled before commit", changeIndex: firstOperationIndex(plan) });
+  }
+  const stale = verifySnapshots(plan);
+  if (stale)
+    return stale;
+  if (options.signal?.aborted) {
+    return failedCommit(plan, { message: "cancelled before commit", changeIndex: firstOperationIndex(plan) });
+  }
+  const io = resolveIo(options.io);
+  const accumulator = { mutations: [], filesModified: [], totalEdits: 0 };
+  const context = { plan, io, accumulator };
+  let lateAbort = false;
+  for (const operation of plan.operations) {
+    try {
+      commitOperation(context, operation);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      return failedCommit(plan, {
+        message: `I/O failure during ${operation.kind}: ${detail}`,
+        changeIndex: operation.changeIndex,
+        mutations: accumulator.mutations,
+        filesModified: accumulator.filesModified,
+        totalEdits: accumulator.totalEdits,
+        lateAbort: lateAbort || options.signal?.aborted === true
+      });
+    }
+    if (options.signal?.aborted)
+      lateAbort = true;
+  }
+  const result = {
+    success: true,
+    filesModified: accumulator.filesModified,
+    totalEdits: accumulator.totalEdits,
+    errors: [],
+    ...lateAbort ? { lateAbort: true } : {}
+  };
+  return { result, delta: mutationDelta(accumulator.mutations), fingerprint: plan.fingerprint };
+}
+
+// ../lsp-core/src/lsp/workspace-edit-fingerprint.ts
+import { createHash } from "node:crypto";
+function canonicalFingerprint(operations) {
+  const canonical = operations.map((operation) => {
+    switch (operation.kind) {
+      case "text":
+        return {
+          kind: operation.kind,
+          changeIndex: operation.changeIndex,
+          path: operation.path,
+          edits: operation.edits,
+          version: operation.version
+        };
+      case "rename":
+        return {
+          kind: operation.kind,
+          changeIndex: operation.changeIndex,
+          oldPath: operation.oldPath,
+          newPath: operation.newPath,
+          overwrite: operation.overwrite,
+          ignoreIfExists: operation.ignoreIfExists
+        };
+      case "create":
+        return {
+          kind: operation.kind,
+          changeIndex: operation.changeIndex,
+          path: operation.path,
+          overwrite: operation.overwrite,
+          ignoreIfExists: operation.ignoreIfExists
+        };
+      case "delete":
+        return {
+          kind: operation.kind,
+          changeIndex: operation.changeIndex,
+          path: operation.path,
+          recursive: operation.recursive,
+          ignoreIfNotExists: operation.ignoreIfNotExists
+        };
+    }
+  });
+  return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+
+// ../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;
+  }
+}
+
+// ../lsp-core/src/lsp/workspace-edit-parse-helpers.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsePosition(value) {
+  if (!isRecord2(value) || typeof value["line"] !== "number" || typeof value["character"] !== "number") {
+    return null;
+  }
+  return { line: value["line"], character: value["character"] };
+}
+function parseRange(value) {
+  if (!isRecord2(value))
+    return null;
+  const start = parsePosition(value["start"]);
+  const end = parsePosition(value["end"]);
+  return start && end ? { start, end } : null;
+}
+function parseTextEdits(value, changeIndex) {
+  if (!Array.isArray(value)) {
+    throw new WorkspaceEditValidationError(changeIndex, "text edits must be an array");
+  }
+  const edits = [];
+  for (const candidate of value) {
+    if (!isRecord2(candidate) || typeof candidate["newText"] !== "string") {
+      throw new WorkspaceEditValidationError(changeIndex, "text edit requires range and newText");
+    }
+    if ("annotationId" in candidate) {
+      throw new WorkspaceEditValidationError(changeIndex, "annotated text edits are unsupported");
+    }
+    const range = parseRange(candidate["range"]);
+    if (!range)
+      throw new WorkspaceEditValidationError(changeIndex, "text edit range is malformed");
+    edits.push({ range, newText: candidate["newText"] });
+  }
+  return edits;
+}
+function parseBooleanOption(options, key, changeIndex) {
+  const value = options[key];
+  if (value === undefined)
+    return false;
+  if (typeof value !== "boolean") {
+    throw new WorkspaceEditValidationError(changeIndex, `${key} must be boolean`);
+  }
+  return value;
+}
+function parseOptions(value, allowed, changeIndex) {
+  if (value === undefined)
+    return {};
+  if (!isRecord2(value))
+    throw new WorkspaceEditValidationError(changeIndex, "resource options must be an object");
+  for (const key of Object.keys(value)) {
+    if (!allowed.includes(key))
+      throw new WorkspaceEditValidationError(changeIndex, `unsupported resource option ${key}`);
+  }
+  const parsed = {};
+  for (const key of allowed)
+    parsed[key] = parseBooleanOption(value, key, changeIndex);
+  return parsed;
+}
+
+// ../lsp-core/src/lsp/workspace-edit-resource-parser.ts
+function parseResourceChange(input) {
+  const kind = input.change["kind"];
+  if (kind === "create" || kind === "delete") {
+    parseSinglePathResource(input, kind);
+    return;
+  }
+  if (kind !== "rename") {
+    throw new WorkspaceEditValidationError(input.changeIndex, `unsupported resource operation ${String(kind)}`);
+  }
+  parseRename(input);
+}
+function parseSinglePathResource(input, kind) {
+  const { change, changeIndex, workspaceRoot, target } = input;
+  if (typeof change["uri"] !== "string")
+    throw new WorkspaceEditValidationError(changeIndex, `${kind}.uri is required`);
+  const resolvedPath = uriToCanonicalWorkspacePath(change["uri"], workspaceRoot);
+  if (!resolvedPath.success) {
+    target.failures.push({ changeIndex, message: resolvedPath.error });
+    return;
+  }
+  if (kind === "create") {
+    const options2 = 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,
+      followedSymbolicLink: resolvedPath.followedSymbolicLink
+    });
+    return;
+  }
+  const options = parseOptions(change["options"], ["recursive", "ignoreIfNotExists"], changeIndex);
+  target.operations.push({
+    kind,
+    changeIndex,
+    path: resolvedPath.path,
+    reportedPath: resolvedPath.requestedPath,
+    recursive: options["recursive"] ?? false,
+    ignoreIfNotExists: options["ignoreIfNotExists"] ?? false,
+    followedSymbolicLink: resolvedPath.followedSymbolicLink
+  });
+}
+function parseRename(input) {
+  const { change, changeIndex, workspaceRoot, target } = input;
+  if (typeof change["oldUri"] !== "string" || typeof change["newUri"] !== "string") {
+    throw new WorkspaceEditValidationError(changeIndex, "rename requires oldUri and newUri");
+  }
+  const oldPath = uriToCanonicalWorkspacePath(change["oldUri"], workspaceRoot);
+  const newPath = uriToCanonicalWorkspacePath(change["newUri"], workspaceRoot);
+  if (!oldPath.success || !newPath.success) {
+    target.failures.push({
+      changeIndex,
+      message: !oldPath.success ? oldPath.error : !newPath.success ? newPath.error : "invalid rename path"
+    });
+    return;
+  }
+  const options = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
+  target.operations.push({
+    kind: "rename",
+    changeIndex,
+    oldPath: oldPath.path,
+    newPath: newPath.path,
+    reportedOldPath: oldPath.requestedPath,
+    reportedNewPath: newPath.requestedPath,
+    overwrite: options["overwrite"] ?? false,
+    ignoreIfExists: options["ignoreIfExists"] ?? false,
+    followedSymbolicLink: oldPath.followedSymbolicLink || newPath.followedSymbolicLink
+  });
+}
+
+// ../lsp-core/src/lsp/workspace-edit-parser.ts
+function failureResult(failures) {
+  const sorted = [...failures].sort((left, right) => left.changeIndex - right.changeIndex);
+  const first = sorted[0];
+  return {
+    success: false,
+    filesModified: [],
+    totalEdits: 0,
+    errors: sorted.map((failure) => `change ${failure.changeIndex}: ${failure.message}`),
+    ...first ? { failedChange: first.changeIndex } : {}
+  };
+}
+function parseWorkspaceEdit(edit, workspaceRoot) {
+  if (!isRecord2(edit))
+    return { operations: [], failures: [{ changeIndex: 0, message: "No edit provided" }] };
+  if (edit["changeAnnotations"] !== undefined) {
+    return { operations: [], failures: [{ changeIndex: 0, message: "change annotations are unsupported" }] };
+  }
+  const hasChanges = edit["changes"] !== undefined;
+  const hasDocumentChanges = edit["documentChanges"] !== undefined;
+  if (hasChanges && hasDocumentChanges) {
+    return {
+      operations: [],
+      failures: [{ changeIndex: 0, message: "changes and documentChanges cannot be combined" }]
+    };
+  }
+  const target = { operations: [], failures: [] };
+  if (hasChanges)
+    return parseChanges(edit["changes"], workspaceRoot, target);
+  return parseDocumentChanges(edit["documentChanges"], workspaceRoot, target);
+}
+function parseChanges(value, workspaceRoot, target) {
+  if (!isRecord2(value))
+    return { ...target, failures: [{ changeIndex: 0, message: "changes must be an object" }] };
+  const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+  for (const [changeIndex, [uri, rawEdits]] of entries.entries()) {
+    const resolvedPath = uriToCanonicalWorkspacePath(uri, workspaceRoot);
+    if (!resolvedPath.success) {
+      target.failures.push({ changeIndex, message: resolvedPath.error });
+      continue;
+    }
+    try {
+      target.operations.push({
+        kind: "text",
+        changeIndex,
+        path: resolvedPath.path,
+        reportedPath: resolvedPath.requestedPath,
+        edits: parseTextEdits(rawEdits, changeIndex),
+        version: null
+      });
+    } catch (error) {
+      if (error instanceof WorkspaceEditValidationError) {
+        target.failures.push({ changeIndex, message: error.detail });
+        continue;
+      }
+      throw error;
+    }
+  }
+  return target;
+}
+function parseDocumentChanges(value, workspaceRoot, target) {
+  if (value === undefined)
+    return target;
+  if (!Array.isArray(value)) {
+    return { ...target, failures: [{ changeIndex: 0, message: "documentChanges must be an array" }] };
+  }
+  for (const [changeIndex, change] of value.entries()) {
+    try {
+      parseDocumentChange({ change, changeIndex, workspaceRoot, target });
+    } catch (error) {
+      if (error instanceof WorkspaceEditValidationError) {
+        target.failures.push({ changeIndex, message: error.detail });
+        continue;
+      }
+      throw error;
+    }
+  }
+  return target;
+}
+function parseDocumentChange(input) {
+  const { change, changeIndex, workspaceRoot, target } = input;
+  if (!isRecord2(change))
+    throw new WorkspaceEditValidationError(changeIndex, "document change must be an object");
+  if ("annotationId" in change) {
+    throw new WorkspaceEditValidationError(changeIndex, "annotated resource operations are unsupported");
+  }
+  if (typeof change["kind"] === "string") {
+    parseResourceChange({ change, changeIndex, workspaceRoot, target });
+    return;
+  }
+  const identifier = change["textDocument"];
+  if (!isRecord2(identifier) || typeof identifier["uri"] !== "string") {
+    throw new WorkspaceEditValidationError(changeIndex, "textDocument.uri is required");
+  }
+  const version = identifier["version"];
+  if (version !== null && (!Number.isInteger(version) || typeof version !== "number" || version < 0)) {
+    throw new WorkspaceEditValidationError(changeIndex, "document version must be null or a non-negative integer");
+  }
+  const resolvedPath = uriToCanonicalWorkspacePath(identifier["uri"], workspaceRoot);
+  if (!resolvedPath.success) {
+    target.failures.push({ changeIndex, message: resolvedPath.error });
+    return;
+  }
+  target.operations.push({
+    kind: "text",
+    changeIndex,
+    path: resolvedPath.path,
+    reportedPath: resolvedPath.requestedPath,
+    edits: parseTextEdits(change["edits"], changeIndex),
+    version
+  });
+}
+
+// ../lsp-core/src/lsp/workspace-edit-simulation.ts
+import { dirname as dirname2, relative as relative3, resolve as resolve3 } from "node:path";
+
+// ../lsp-core/src/lsp/workspace-edit-text.ts
+function comparePosition(left, right) {
+  return left.line === right.line ? left.character - right.character : left.line - right.line;
+}
+function positionsEqual(left, right) {
+  return left.line === right.line && left.character === right.character;
+}
+function rangesEqual(left, right) {
+  return positionsEqual(left.start, right.start) && positionsEqual(left.end, right.end);
+}
+function isEmptyRange(range) {
+  return positionsEqual(range.start, range.end);
+}
+function formatRange(range) {
+  return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
+}
+function validatePosition(position, label, context) {
+  const { lines, changeIndex } = context;
+  if (!Number.isInteger(position.line) || !Number.isInteger(position.character)) {
+    throw new WorkspaceEditValidationError(changeIndex, `${label} position must use integer line and character`);
+  }
+  if (position.line < 0 || position.character < 0) {
+    throw new WorkspaceEditValidationError(changeIndex, `${label} position cannot be negative`);
+  }
+  const line = lines[position.line];
+  if (line === undefined) {
+    throw new WorkspaceEditValidationError(changeIndex, `${label} line ${position.line} is outside the document`);
+  }
+  if (position.character > line.length) {
+    throw new WorkspaceEditValidationError(changeIndex, `${label} character ${position.character} is outside line ${position.line}`);
+  }
+}
+function validateRange(range, lines, changeIndex) {
+  const context = { lines, changeIndex };
+  validatePosition(range.start, "start", context);
+  validatePosition(range.end, "end", context);
+  if (comparePosition(range.start, range.end) > 0) {
+    throw new WorkspaceEditValidationError(changeIndex, `range ${formatRange(range)} ends before it starts`);
+  }
+}
+function sortAndDeduplicate(edits) {
+  const sorted = edits.map((edit, index) => ({ edit, index })).sort((left, right) => {
+    const positionOrder = comparePosition(right.edit.range.start, left.edit.range.start);
+    return positionOrder === 0 ? right.index - left.index : positionOrder;
+  });
+  const unique = [];
+  for (const entry of sorted) {
+    const previous = unique.at(-1);
+    if (previous !== undefined && !isEmptyRange(entry.edit.range) && rangesEqual(previous.range, entry.edit.range) && previous.newText === entry.edit.newText) {
+      continue;
+    }
+    unique.push(entry.edit);
+  }
+  return unique;
+}
+function validateNoOverlap(edits, changeIndex) {
+  for (let index = 0;index < edits.length - 1; index += 1) {
+    const later = edits[index];
+    const earlier = edits[index + 1];
+    if (later === undefined || earlier === undefined)
+      continue;
+    if (comparePosition(earlier.range.end, later.range.start) > 0) {
+      throw new WorkspaceEditValidationError(changeIndex, `overlapping edits ${formatRange(earlier.range)} and ${formatRange(later.range)}`);
+    }
+  }
+}
+function applyNormalizedTextEdits(content, edits) {
+  const lines = content.split(`
+`);
+  for (const edit of edits) {
+    const { start, end } = edit.range;
+    const startLine = lines[start.line];
+    const endLine = lines[end.line];
+    if (startLine === undefined || endLine === undefined)
+      continue;
+    const replacement = startLine.slice(0, start.character) + edit.newText + endLine.slice(end.character);
+    lines.splice(start.line, end.line - start.line + 1, ...replacement.split(`
+`));
+  }
+  return lines.join(`
+`);
+}
+function normalizeTextEdits(content, edits, changeIndex) {
+  const lines = content.split(`
+`);
+  for (const edit of edits) {
+    validateRange(edit.range, lines, changeIndex);
+  }
+  const normalized = sortAndDeduplicate(edits);
+  validateNoOverlap(normalized, changeIndex);
+  return { edits: normalized, text: applyNormalizedTextEdits(content, normalized) };
+}
+
+// ../lsp-core/src/lsp/workspace-edit-simulation.ts
+function isSameOrDescendant2(candidate, parent) {
+  const relativePath = relative3(parent, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && relativePath !== "..";
+}
+function removeVirtualSubtree(virtual, path) {
+  for (const candidate of [...virtual.keys()]) {
+    if (isSameOrDescendant2(candidate, path))
+      virtual.delete(candidate);
+  }
+  virtual.set(path, { kind: "missing" });
+}
+function moveVirtualSubtree(virtual, oldPath, newPath) {
+  const moved = [...virtual.entries()].filter(([candidate]) => isSameOrDescendant2(candidate, oldPath));
+  removeVirtualSubtree(virtual, oldPath);
+  removeVirtualSubtree(virtual, newPath);
+  for (const [candidate, entry] of moved) {
+    const suffix = relative3(oldPath, candidate);
+    virtual.set(suffix === "" ? newPath : resolve3(newPath, suffix), entry);
+  }
+}
+function virtualDirectoryHasChildren(virtual, path) {
+  for (const [candidate, entry] of virtual) {
+    if (candidate !== path && entry.kind !== "missing" && isSameOrDescendant2(candidate, path))
+      return true;
+  }
+  return false;
+}
+function requireVirtualParent(virtual, path, changeIndex) {
+  if (virtual.get(dirname2(path))?.kind !== "directory") {
+    throw new WorkspaceEditValidationError(changeIndex, `parent directory does not exist for ${path}`);
+  }
+}
+function simulateOperations(parsed, snapshots) {
+  const virtual = new Map(snapshots);
+  const planned = [];
+  const failures = [];
+  for (const operation of parsed) {
+    try {
+      planned.push(simulateOperation(operation, virtual));
+    } catch (error) {
+      if (error instanceof WorkspaceEditValidationError) {
+        failures.push({ changeIndex: operation.changeIndex, message: error.detail });
+        continue;
+      }
+      throw error;
+    }
+  }
+  return { operations: planned, failures };
+}
+function simulateOperation(operation, virtual) {
+  switch (operation.kind) {
+    case "text":
+      return simulateText(operation, virtual);
+    case "create":
+      return simulateCreate(operation, virtual);
+    case "rename":
+      return simulateRename(operation, virtual);
+    case "delete":
+      return simulateDelete(operation, virtual);
+  }
+}
+function rejectSymbolicLink(operation) {
+  if (operation.followedSymbolicLink) {
+    throw new WorkspaceEditValidationError(operation.changeIndex, "resource operations through symbolic links are unsupported");
+  }
+}
+function simulateText(operation, virtual) {
+  const entry = virtual.get(operation.path);
+  if (entry?.kind !== "file")
+    throw new WorkspaceEditValidationError(operation.changeIndex, `${operation.path} is not a file`);
+  const normalized = normalizeTextEdits(entry.content, operation.edits, operation.changeIndex);
+  virtual.set(operation.path, { kind: "file", content: normalized.text });
+  return {
+    kind: "text",
+    changeIndex: operation.changeIndex,
+    path: operation.path,
+    beforeText: entry.content,
+    afterText: normalized.text,
+    editCount: normalized.edits.length,
+    documentVersion: operation.version
+  };
+}
+function simulateCreate(operation, virtual) {
+  rejectSymbolicLink(operation);
+  requireVirtualParent(virtual, operation.path, operation.changeIndex);
+  const target = virtual.get(operation.path) ?? { kind: "missing" };
+  if (target.kind !== "missing") {
+    if (operation.overwrite && target.kind === "file") {
+      virtual.set(operation.path, { kind: "file", content: "" });
+      return { kind: "create", changeIndex: operation.changeIndex, path: operation.path, replaced: true };
+    }
+    if (operation.ignoreIfExists)
+      return { kind: "noop", changeIndex: operation.changeIndex };
+    throw new WorkspaceEditValidationError(operation.changeIndex, `create target already exists: ${operation.path}`);
+  }
+  virtual.set(operation.path, { kind: "file", content: "" });
+  return { kind: "create", changeIndex: operation.changeIndex, path: operation.path, replaced: false };
+}
+function simulateRename(operation, virtual) {
+  rejectSymbolicLink(operation);
+  const source = virtual.get(operation.oldPath) ?? { kind: "missing" };
+  if (source.kind === "missing") {
+    throw new WorkspaceEditValidationError(operation.changeIndex, `rename source does not exist: ${operation.oldPath}`);
+  }
+  if (operation.oldPath === operation.newPath)
+    return { kind: "noop", changeIndex: operation.changeIndex };
+  if (isSameOrDescendant2(operation.newPath, operation.oldPath)) {
+    throw new WorkspaceEditValidationError(operation.changeIndex, "cannot rename a path into its own subtree");
+  }
+  requireVirtualParent(virtual, operation.newPath, operation.changeIndex);
+  const destination = virtual.get(operation.newPath) ?? { kind: "missing" };
+  if (destination.kind !== "missing" && !operation.overwrite) {
+    if (operation.ignoreIfExists)
+      return { kind: "noop", changeIndex: operation.changeIndex };
+    throw new WorkspaceEditValidationError(operation.changeIndex, `rename target already exists: ${operation.newPath}`);
+  }
+  moveVirtualSubtree(virtual, operation.oldPath, operation.newPath);
+  return {
+    kind: "rename",
+    changeIndex: operation.changeIndex,
+    oldPath: operation.oldPath,
+    newPath: operation.newPath,
+    sourceKind: source.kind,
+    replaceDestination: destination.kind !== "missing"
+  };
+}
+function simulateDelete(operation, virtual) {
+  rejectSymbolicLink(operation);
+  const target = virtual.get(operation.path) ?? { kind: "missing" };
+  if (target.kind === "missing") {
+    if (operation.ignoreIfNotExists)
+      return { kind: "noop", changeIndex: operation.changeIndex };
+    throw new WorkspaceEditValidationError(operation.changeIndex, `delete target does not exist: ${operation.path}`);
+  }
+  if (target.kind === "directory" && !operation.recursive && virtualDirectoryHasChildren(virtual, operation.path)) {
+    throw new WorkspaceEditValidationError(operation.changeIndex, `directory is not empty: ${operation.path}`);
+  }
+  removeVirtualSubtree(virtual, operation.path);
+  return {
+    kind: "delete",
+    changeIndex: operation.changeIndex,
+    path: operation.path,
+    targetKind: target.kind,
+    recursive: operation.recursive
+  };
+}
+
+// ../lsp-core/src/lsp/workspace-edit-snapshot.ts
+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;
+  }
+  build(operations) {
+    this.add(this.workspaceRoot, false);
+    for (const operation of operations) {
+      switch (operation.kind) {
+        case "rename":
+          this.add(operation.oldPath, true);
+          this.add(operation.newPath, true);
+          break;
+        case "delete":
+          this.add(operation.path, true);
+          break;
+        case "text":
+        case "create":
+          this.add(operation.path, false);
+          break;
+      }
+    }
+    return this.snapshots;
+  }
+  add(path, includeChildren) {
+    let candidate = path;
+    while (true) {
+      const existing = this.snapshots.get(candidate);
+      if (existing === undefined || includeChildren && existing.kind === "directory" && existing.children === undefined) {
+        this.snapshots.set(candidate, snapshotPath(candidate, includeChildren && candidate === path));
+      }
+      if (candidate === this.workspaceRoot)
+        break;
+      candidate = dirname3(candidate);
+    }
+    if (!includeChildren || !existsSync4(path) || !lstatSync3(path).isDirectory())
+      return;
+    for (const child of readdirSync2(path))
+      this.add(resolve4(path, child), true);
+  }
+}
+function snapshotOperations(operations, workspaceRoot) {
+  return new WorkspaceSnapshotBuilder(workspaceRoot).build(operations);
+}
+
+// ../lsp-core/src/lsp/workspace-edit-plan.ts
+class PlanPathIndex {
+  firstChangeByPath = new Map;
+  reportedPathByCanonical = new Map;
+  build(operations) {
+    for (const operation of operations) {
+      switch (operation.kind) {
+        case "rename":
+          this.add(operation.oldPath, operation.reportedOldPath, operation.changeIndex);
+          this.add(operation.newPath, operation.reportedNewPath, operation.changeIndex);
+          break;
+        case "text":
+        case "create":
+        case "delete":
+          this.add(operation.path, operation.reportedPath, operation.changeIndex);
+          break;
+      }
+    }
+  }
+  add(path, reportedPath2, changeIndex) {
+    if (!this.firstChangeByPath.has(path))
+      this.firstChangeByPath.set(path, changeIndex);
+    if (!this.reportedPathByCanonical.has(path))
+      this.reportedPathByCanonical.set(path, reportedPath2);
+  }
+}
+function fingerprintWorkspaceEdit(edit, workspaceRoot) {
+  const root = canonicalWorkspaceRoot(workspaceRoot);
+  if (!root.success)
+    return { success: false, result: failureResult([{ changeIndex: 0, message: root.error }]) };
+  const parsed = parseWorkspaceEdit(edit, root.path);
+  if (parsed.failures.length > 0)
+    return { success: false, result: failureResult(parsed.failures) };
+  return { success: true, fingerprint: canonicalFingerprint(parsed.operations) };
+}
+function planWorkspaceEdit(edit, workspaceRoot) {
+  const root = canonicalWorkspaceRoot(workspaceRoot);
+  if (!root.success)
+    return { success: false, result: failureResult([{ changeIndex: 0, message: root.error }]) };
+  const parsed = parseWorkspaceEdit(edit, root.path);
+  if (parsed.failures.length > 0)
+    return { success: false, result: failureResult(parsed.failures) };
+  let snapshots;
+  try {
+    snapshots = snapshotOperations(parsed.operations, root.path);
+  } catch (error) {
+    return {
+      success: false,
+      result: failureResult([{ changeIndex: 0, message: error instanceof Error ? error.message : String(error) }])
+    };
+  }
+  const simulated = simulateOperations(parsed.operations, snapshots);
+  if (simulated.failures.length > 0)
+    return { success: false, result: failureResult(simulated.failures) };
+  const paths = new PlanPathIndex;
+  paths.build(parsed.operations);
+  const plan = {
+    workspaceRoot: root.path,
+    operations: simulated.operations,
+    snapshots,
+    firstChangeByPath: paths.firstChangeByPath,
+    reportedPathByCanonical: paths.reportedPathByCanonical,
+    fingerprint: canonicalFingerprint(parsed.operations)
+  };
+  return { success: true, plan };
+}
+
+// ../lsp-core/src/lsp/workspace-mutation-controller.ts
+function failure(message, failedChange, base) {
+  return {
+    success: false,
+    filesModified: base?.filesModified ?? [],
+    totalEdits: base?.totalEdits ?? 0,
+    errors: [message],
+    ...failedChange === undefined ? {} : { failedChange },
+    ...base?.lateAbort ? { lateAbort: true } : {}
+  };
+}
+function responseFor(result) {
+  if (result.success)
+    return { applied: true };
+  return {
+    applied: false,
+    failureReason: result.errors[0] ?? "workspace edit failed",
+    ...result.failedChange === undefined ? {} : { failedChange: result.failedChange }
+  };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+class WorkspaceMutationController {
+  workspaceRoot;
+  documents;
+  activeLease = null;
+  nextLeaseId = 1;
+  io;
+  constructor(workspaceRoot, documents) {
+    this.workspaceRoot = workspaceRoot;
+    this.documents = documents;
+  }
+  setIo(io) {
+    this.io = io;
+  }
+  acquire(signal) {
+    if (this.activeLease)
+      return { success: false, result: failure("workspace mutation is already in progress") };
+    if (signal?.aborted)
+      return { success: false, result: failure("cancelled before mutating request") };
+    const lease = {
+      id: this.nextLeaseId,
+      phase: "idle",
+      ...signal === undefined ? {} : { signal }
+    };
+    this.nextLeaseId += 1;
+    this.activeLease = lease;
+    return { success: true, lease };
+  }
+  release(lease) {
+    if (this.activeLease?.id !== lease.id)
+      return;
+    this.activeLease.phase = "sealed";
+    this.activeLease = null;
+  }
+  isBeforeCommit(lease) {
+    return this.activeLease?.id === lease.id && this.activeLease.phase === "idle";
+  }
+  async handleApplyEdit(params) {
+    const lease = this.activeLease;
+    if (!lease)
+      return { applied: false, failureReason: "workspace/applyEdit requires an active workspace mutation" };
+    if (lease.phase !== "idle") {
+      return {
+        applied: false,
+        failureReason: workspaceApplyEditConcurrentFailureReason(lease.phase === "applying" ? "applying" : "settled")
+      };
+    }
+    lease.phase = "applying";
+    lease.applyCompletion = new Promise((resolve5) => {
+      lease.resolveApply = resolve5;
+    });
+    const edit = isRecord3(params) ? params["edit"] : undefined;
+    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(record.result);
+  }
+  async reconcileRename(leaseToken, edit) {
+    const lease = this.requireActiveLease(leaseToken);
+    if (!lease)
+      return { edit, apply: failure("workspace mutation lease ended before rename reconciliation") };
+    if (lease.phase === "applying")
+      await lease.applyCompletion;
+    if (lease.serverApply)
+      return this.reconcileServerApply(lease.serverApply, edit);
+    lease.phase = "sealed";
+    if (!edit)
+      return { edit, apply: failure("No edit provided") };
+    const applied = await this.applyEdit(edit, lease);
+    return { edit, apply: applied.result };
+  }
+  reconcileServerApply(record, edit) {
+    if (!edit)
+      return { edit, apply: record.result };
+    const fingerprint = fingerprintWorkspaceEdit(edit, this.workspaceRoot);
+    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, record.result)
+    };
+  }
+  async applyEdit(edit, lease) {
+    const planned = planWorkspaceEdit(edit, this.workspaceRoot);
+    if (!planned.success)
+      return { fingerprint: null, result: planned.result };
+    const versionFailure = this.documents.validateVersions(planned.plan.operations);
+    if (versionFailure) {
+      return {
+        fingerprint: planned.plan.fingerprint,
+        result: failure(versionFailure.message, versionFailure.changeIndex)
+      };
+    }
+    const commit = commitWorkspaceEditPlan(planned.plan, {
+      ...lease.signal === undefined ? {} : { signal: lease.signal },
+      ...this.io === undefined ? {} : { io: this.io }
+    });
+    let result = commit.result;
+    if (commit.delta.operations.length > 0) {
+      try {
+        await this.documents.synchronize(commit.delta);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result = failure(`document synchronization failed after filesystem commit: ${message}`, undefined, result);
+      }
+    }
+    if (lease.signal?.aborted && !result.lateAbort)
+      result = { ...result, lateAbort: true };
+    return { fingerprint: planned.plan.fingerprint, result };
+  }
+  requireActiveLease(lease) {
+    return this.activeLease?.id === lease.id ? this.activeLease : null;
+  }
+}
+
+// ../lsp-core/src/lsp/client.ts
+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.diagnosticsFreshnessTimeoutMs = options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
+    this.documents = new WorkspaceDocumentState((method, params) => this.sendNotification(method, params), (uri) => this.diagnosticsStore.delete(uri), {
+      versionlessPublishQuiescenceMs: options.versionlessPublishQuiescenceMs ?? VERSIONLESS_PUBLISH_QUIESCENCE_MS
+    });
+    this.workspaceMutations = new WorkspaceMutationController(root, this.documents);
+    this.setWorkspaceApplyEditHandler((params) => this.workspaceMutations.handleApplyEdit(params));
+  }
+  getDiagnosticPullErrors() {
+    return this.diagnosticPullErrors;
+  }
+  async openFile(filePath) {
+    const absPath = this.resolveWorkspacePath(filePath);
+    await this.documents.openFile(absPath);
+  }
+  getOpenDocumentVersion(filePath) {
+    return this.documents.getVersion(this.resolveWorkspacePath(filePath));
+  }
+  getStoredDiagnostics(uri) {
+    return [...this.documents.getStoredDiagnostics(uri)];
+  }
+  setWorkspaceEditIo(io) {
+    this.workspaceMutations.setIo(io);
+  }
+  handlePublishDiagnostics(params) {
+    super.handlePublishDiagnostics(params);
+    this.documents.recordPublishedDiagnostics(params);
+  }
+  async definition(filePath, line, character, signal) {
+    const absPath = this.resolveWorkspacePath(filePath);
+    await this.openFile(absPath);
+    const options = signal === undefined ? {} : { signal };
+    return this.sendRequest("textDocument/definition", {
+      textDocument: { uri: pathToFileURL3(absPath).href },
+      position: { line: line - 1, character }
+    }, options);
+  }
+  async references(filePath, line, character, includeDeclaration = true, signal) {
+    const absPath = this.resolveWorkspacePath(filePath);
+    await this.openFile(absPath);
+    const options = signal === undefined ? {} : { signal };
+    return this.sendRequest("textDocument/references", {
+      textDocument: { uri: pathToFileURL3(absPath).href },
+      position: { line: line - 1, character },
+      context: { includeDeclaration }
+    }, options);
+  }
+  async documentSymbols(filePath, signal) {
+    const absPath = this.resolveWorkspacePath(filePath);
+    await this.openFile(absPath);
+    const options = signal === undefined ? {} : { signal };
+    return this.sendRequest("textDocument/documentSymbol", {
+      textDocument: { uri: pathToFileURL3(absPath).href }
+    }, options);
+  }
+  async workspaceSymbols(query, signal) {
+    const options = signal === undefined ? {} : { signal };
+    return this.sendRequest("workspace/symbol", { query }, options);
+  }
+  isUnsupportedDiagnosticPullError(error) {
+    if (!(error instanceof Error))
+      return false;
+    const code = "code" in error && typeof error.code === "number" ? error.code : undefined;
+    if (code === -32601)
+      return true;
+    return /unsupported|not supported|method not found|unknown request/i.test(error.message);
+  }
+  freshnessTimeout(absPath) {
+    return {
+      items: [],
+      transientError: {
+        kind: "freshness_timeout",
+        message: `Timed out waiting for fresh diagnostics for ${absPath} within ${this.diagnosticsFreshnessTimeoutMs}ms.`
+      }
+    };
+  }
+  parseDiagnosticPullReport(value) {
+    if (value.kind === "unchanged") {
+      return {
+        type: "unchanged",
+        ...value.resultId === undefined ? {} : { resultId: value.resultId }
+      };
+    }
+    return {
+      type: "full",
+      diagnostics: value.items ?? [],
+      ...value.resultId === undefined ? {} : { resultId: value.resultId }
+    };
+  }
+  async diagnostics(filePath, signal) {
+    signal?.throwIfAborted();
+    const absPath = this.resolveWorkspacePath(filePath);
+    const uri = pathToFileURL3(absPath).href;
+    await this.openFile(absPath);
+    const deadlineAt = Date.now() + this.diagnosticsFreshnessTimeoutMs;
+    for (;; ) {
+      signal?.throwIfAborted();
+      const snapshot = this.documents.captureDiagnosticSnapshot(absPath);
+      if (!snapshot)
+        return this.freshnessTimeout(absPath);
+      const push = this.documents.resolvePushDiagnostics(snapshot);
+      if (push.status === "ready")
+        return { items: [...push.diagnostics] };
+      let pushFallbackOnly = !this.isDiagnosticPullSupported();
+      if (!pushFallbackOnly) {
+        const cached = this.documents.getPullCache(snapshot);
+        try {
+          const remainingMs2 = deadlineAt - Date.now();
+          if (remainingMs2 <= 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 } });
+          if (!this.documents.isCurrentSnapshot(snapshot))
+            continue;
+          const report = this.parseDiagnosticPullReport(result);
+          if (report.type === "full") {
+            this.documents.recordPullDiagnostics(snapshot, {
+              kind: "full",
+              diagnostics: report.diagnostics,
+              ...report.resultId === undefined ? {} : { resultId: report.resultId }
+            });
+            return { items: [...report.diagnostics] };
+          }
+          if (cached !== null && cached.documentVersion === snapshot.version && cached.resultId === report.resultId) {
+            return { items: [...cached.diagnostics] };
+          }
+        } catch (error) {
+          if (this.isUnsupportedDiagnosticPullError(error)) {
+            this.setDiagnosticPullSupported(false);
+            pushFallbackOnly = true;
+          } else if (error instanceof LspRequestTimeoutError) {
+            pushFallbackOnly = true;
+          } else {
+            this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+          }
+        }
+      }
+      if (!pushFallbackOnly)
+        continue;
+      const remainingMs = deadlineAt - Date.now();
+      if (remainingMs <= 0)
+        return this.freshnessTimeout(absPath);
+      const waitMs = push.status === "wait" ? Math.min(push.waitMs, remainingMs) : remainingMs;
+      await waitForDiagnosticsActivity(this.documents.waitForDiagnosticsActivity(snapshot, waitMs), signal);
+    }
+  }
+  async prepareRename(filePath, line, character, signal) {
+    const absPath = this.resolveWorkspacePath(filePath);
+    await this.openFile(absPath);
+    const options = signal === undefined ? {} : { signal };
+    return this.sendRequest("textDocument/prepareRename", {
+      textDocument: { uri: pathToFileURL3(absPath).href },
+      position: { line: line - 1, character }
+    }, options);
+  }
+  async rename(filePath, line, character, newName, signal) {
+    const absPath = this.resolveWorkspacePath(filePath);
+    await this.openFile(absPath);
+    const acquired = this.workspaceMutations.acquire(signal);
+    if (!acquired.success)
+      return { edit: null, apply: acquired.result };
+    const preCommitSignal = createPreCommitAbortSignal(signal, () => this.workspaceMutations.isBeforeCommit(acquired.lease));
+    try {
+      const renameParams = {
+        textDocument: { uri: pathToFileURL3(absPath).href },
+        position: { line: line - 1, character },
+        newName
+      };
+      const edit = preCommitSignal === undefined ? await this.sendRequest("textDocument/rename", renameParams) : await this.sendRequest("textDocument/rename", renameParams, {
+        signal: preCommitSignal.signal
+      });
+      return await this.workspaceMutations.reconcileRename(acquired.lease, edit);
+    } finally {
+      preCommitSignal?.dispose();
+      this.workspaceMutations.release(acquired.lease);
+    }
+  }
+  resolveWorkspacePath(filePath) {
+    return resolve5(this.root, filePath);
+  }
+}
+function waitForDiagnosticsActivity(wait, signal) {
+  if (!signal)
+    return wait;
+  if (signal.aborted)
+    return Promise.reject(abortError2(signal));
+  return new Promise((resolve6, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError2(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    wait.then(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve6();
+    }, (error) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(error);
+    });
+  });
+}
+function createPreCommitAbortSignal(source, isBeforeCommit) {
+  if (!source)
+    return;
+  const controller = new AbortController;
+  const onAbort = () => {
+    if (isBeforeCommit() && !controller.signal.aborted)
+      controller.abort(preCommitAbortReason(source));
+  };
+  if (source.aborted)
+    onAbort();
+  else
+    source.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: controller.signal,
+    dispose: () => source.removeEventListener("abort", onAbort)
+  };
+}
+function preCommitAbortReason(source) {
+  const reason = source.reason;
+  if (reason instanceof Error && reason.name !== "AbortError")
+    return reason;
+  return new Error("LSP request cancelled before workspace edit commit");
+}
+function abortError2(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error)
+    return reason;
+  const error = new Error(typeof reason === "string" ? reason : "operation cancelled");
+  error.name = "AbortError";
+  return error;
+}
+
+// ../lsp-core/src/lsp/process-signal-cleanup.ts
+function installProcessSignalCleanup(cleanup) {
+  const signals = process.platform === "win32" ? ["SIGINT", "SIGTERM", "SIGBREAK"] : ["SIGINT", "SIGTERM"];
+  const handler = () => {
+    cleanup().catch((error) => {
+      reportBestEffortCleanupError("signal cleanup", error);
+    });
+  };
+  for (const signal of signals) {
+    process.on(signal, handler);
+  }
+  return () => {
+    for (const signal of signals) {
+      process.removeListener(signal, handler);
+    }
+  };
+}
+
+// ../lsp-core/src/lsp/manager.ts
+async function stopClientBestEffort(client) {
+  try {
+    await client.stop();
+  } catch (error) {
+    reportBestEffortCleanupError("client stop", error);
+  }
+}
+function awaitWithSignal(promise, signal) {
+  if (!signal)
+    return promise;
+  return new Promise((resolve6, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve6(value);
+    }, (err) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+  });
+}
+
+class LspManager {
+  clients = new Map;
+  reaperHandle = null;
+  signalDisposer = null;
   disposed = false;
   idleTimeoutMs;
   initTimeoutMs;
@@ -1414,6 +3007,177 @@ async function disposeDefaultLspManager() {
 }
 // src/daemon-client.ts
 import { connect as connect2 } from "node:net";
+import { homedir as homedir3 } from "node:os";
+import { join as join7 } from "node:path";
+
+// ../lsp-core/src/request-context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync as existsSync5, realpathSync as realpathSync3, statSync as statSync2 } from "node:fs";
+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;
+  }
+}
+
+class LspRequestContextUnavailableError extends Error {
+  name = "LspRequestContextUnavailableError";
+  constructor() {
+    super("LSP request context is required. Standalone MCP startup must install one with runWithRequestContext(createStandaloneMcpRequestContext()).");
+  }
+}
+var storage = new AsyncLocalStorage;
+var CONTEXT_FIELDS = new Set(["cwd", "projectConfigPaths", "userConfigPath", "installDecisionsPath", "capabilities"]);
+var CAPABILITY_FIELDS = new Set(["installDecisionTool"]);
+function runWithRequestContext(context, fn) {
+  return storage.run(context, fn);
+}
+function lspRequestContext() {
+  const context = storage.getStore();
+  if (!context)
+    throw new LspRequestContextUnavailableError;
+  return context;
+}
+function contextCwd() {
+  return lspRequestContext().cwd;
+}
+function createStandaloneMcpRequestContext(input = {}) {
+  const env = input.env ?? process.env;
+  const cwd = canonicalCwd(input.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");
+  const installDecisionsPath = translateHomeConfigEnv(env["LSP_TOOLS_MCP_INSTALL_DECISIONS"], home, ".codex/lsp-install-decisions.json");
+  return parseLspRequestContext({
+    cwd,
+    projectConfigPaths,
+    userConfigPath,
+    installDecisionsPath,
+    capabilities: { installDecisionTool: true }
+  });
+}
+function parseLspRequestContext(value) {
+  if (!isRecord4(value)) {
+    throw new LspRequestContextParseError("invalid_context", "LSP request context must be an object.");
+  }
+  rejectUnknownFields(value, CONTEXT_FIELDS, "context");
+  const cwd = stringField(value, "cwd");
+  const projectConfigPaths = stringArrayField(value, "projectConfigPaths");
+  const userConfigPath = stringField(value, "userConfigPath");
+  const installDecisionsPath = stringField(value, "installDecisionsPath");
+  const capabilities = capabilitiesField(value["capabilities"]);
+  const canonical = canonicalCwd(cwd);
+  for (const path of projectConfigPaths) {
+    requireAbsolutePath(path, "projectConfigPaths");
+    const projectPath = canonicalizeExistingOrNearestAncestor(path);
+    if (!isPathInside(canonical, projectPath)) {
+      throw new LspRequestContextParseError("project_config_outside_cwd", `Project LSP config path must be inside cwd: ${path}`);
+    }
+  }
+  requireAbsolutePath(userConfigPath, "userConfigPath");
+  requireAbsolutePath(installDecisionsPath, "installDecisionsPath");
+  return {
+    cwd: canonical,
+    projectConfigPaths: projectConfigPaths.map((path) => canonicalizeExistingOrNearestAncestor(path)),
+    userConfigPath,
+    installDecisionsPath,
+    capabilities
+  };
+}
+function translateProjectConfigEnv(value, cwd) {
+  if (value === undefined || value.length === 0)
+    return [join2(cwd, ".codex", "lsp-client.json")];
+  return value.split(delimiter2).filter((entry) => entry.length > 0).map((entry) => isAbsolute2(entry) ? entry : join2(cwd, entry));
+}
+function translateHomeConfigEnv(value, home, fallback) {
+  if (value === undefined || value.length === 0)
+    return join2(home, fallback);
+  return isAbsolute2(value) ? value : join2(home, value);
+}
+function canonicalCwd(cwd) {
+  const resolved = resolve6(cwd);
+  if (!existsSync5(resolved) || !statSync2(resolved).isDirectory()) {
+    throw new LspRequestContextParseError("invalid_cwd", `LSP request cwd must be an existing directory: ${cwd}`);
+  }
+  return realpathSync3(resolved);
+}
+function canonicalizeExistingOrNearestAncestor(path) {
+  let current = resolve6(path);
+  const suffix = [];
+  while (true) {
+    try {
+      const existing = realpathSync3(current);
+      return suffix.length === 0 ? existing : join2(existing, ...suffix);
+    } catch (error) {
+      if (!isMissingPathError(error))
+        throw error;
+      const parent = dirname4(current);
+      if (parent === current)
+        throw error;
+      suffix.unshift(basename2(current));
+      current = parent;
+    }
+  }
+}
+function capabilitiesField(value) {
+  if (!isRecord4(value)) {
+    throw new LspRequestContextParseError("invalid_capabilities", "LSP request capabilities must be an object.");
+  }
+  rejectUnknownFields(value, CAPABILITY_FIELDS, "capabilities");
+  const installDecisionTool = value["installDecisionTool"];
+  if (typeof installDecisionTool !== "boolean") {
+    throw new LspRequestContextParseError("invalid_install_decision_capability", "LSP request capabilities.installDecisionTool must be a boolean.");
+  }
+  return { installDecisionTool };
+}
+function stringField(value, field) {
+  const fieldValue = value[field];
+  if (typeof fieldValue !== "string" || fieldValue.length === 0) {
+    throw new LspRequestContextParseError("invalid_field", `LSP request context.${field} must be a non-empty string.`);
+  }
+  return fieldValue;
+}
+function stringArrayField(value, field) {
+  const fieldValue = value[field];
+  if (!Array.isArray(fieldValue) || !fieldValue.every((item) => typeof item === "string" && item.length > 0)) {
+    throw new LspRequestContextParseError("invalid_field", `LSP request context.${field} must be a non-empty string array.`);
+  }
+  return fieldValue;
+}
+function requireAbsolutePath(path, field) {
+  if (!isAbsolute2(path)) {
+    throw new LspRequestContextParseError("relative_path", `LSP request context.${field} must be absolute: ${path}`);
+  }
+}
+function isPathInside(parent, child) {
+  const childPath = resolve6(child);
+  const relativePath = relative4(parent, childPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute2(relativePath);
+}
+function isMissingPathError(error) {
+  const code = errorCode(error);
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function rejectUnknownFields(value, allowed, scope) {
+  const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+  if (unknown.length > 0) {
+    throw new LspRequestContextParseError("unknown_field", `Unknown LSP request ${scope} field: ${unknown.join(", ")}`);
+  }
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error))
+    return;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" ? code : undefined;
+}
 
 // ../mcp-stdio-core/src/record.ts
 function isPlainRecord(value) {
@@ -1422,75 +3186,404 @@ function isPlainRecord(value) {
 
 // src/ensure-daemon.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
+import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
 import { connect } from "node:net";
-import { dirname as dirname2 } from "node:path";
+import { dirname as dirname6 } from "node:path";
 import { execPath } from "node:process";
-import { fileURLToPath } from "node:url";
 
-// src/lock.ts
-import { closeSync, mkdirSync, openSync, readFileSync as readFileSync2, unlinkSync, writeSync } from "node:fs";
-import { dirname } from "node:path";
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false;
+// src/ipc-protocol.ts
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  fchmodSync,
+  fstatSync,
+  lstatSync as lstatSync4,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync3,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { dirname as dirname5 } 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 {
-    process.kill(pid, 0);
-    return true;
+    const token = readFileSync3(paths.auth, "utf8").trim();
+    return token.length > 0 ? token : null;
   } catch (error) {
-    return error.code === "EPERM";
+    if (error instanceof Error)
+      return null;
+    throw error;
   }
 }
-function readLockPid(lockPath) {
+function readOrCreateAuthToken(paths) {
+  const existing = readAuthToken(paths);
+  if (existing)
+    return existing;
+  return createAuthToken(paths);
+}
+function rotateAuthToken(paths) {
   try {
-    const pid = Number.parseInt(readFileSync2(lockPath, "utf8").trim(), 10);
-    return Number.isInteger(pid) ? pid : null;
-  } catch {
-    return null;
+    unlinkSync(paths.auth);
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
   }
+  return createAuthToken(paths);
 }
-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;
+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 = openSync(path, "w", 384);
+  try {
+    writeSync(fd, data);
+  } finally {
+    closeSync(fd);
   }
-  return null;
+  setPrivateFileMode(path);
 }
-function writeLockFile(lockPath, ownerPid) {
+function ensurePrivateDirectory(path, options = {}) {
   try {
-    const fd = openSync(lockPath, "wx");
-    writeSync(fd, `${ownerPid}
-`);
+    mkdirSync(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);
-    return { release: () => unlinkQuietly(lockPath) };
+  }
+}
+function setPrivateFileMode(path) {
+  if (process.platform !== "win32")
+    chmodSync(path, 384);
+}
+function createAuthToken(paths) {
+  ensurePrivateDirectory(dirname5(paths.auth));
+  const token = randomBytes(AUTH_TOKEN_BYTES).toString("base64url");
+  let fd;
+  try {
+    fd = openSync(paths.auth, "wx", 384);
   } catch (error) {
-    if (error.code === "EEXIST")
-      return null;
+    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 reapStaleLock(lockPath) {
-  const pid = readLockPid(lockPath);
-  if (pid !== null && isProcessAlive(pid))
-    return false;
-  unlinkQuietly(lockPath);
-  return true;
+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 lstatSync4(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/paths.ts
+import { createHash as createHash2 } from "node:crypto";
+import { createRequire } from "node:module";
+import { homedir as homedir2, tmpdir, userInfo } from "node:os";
+import * as path from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/runtime-contract.ts
+import { statSync as statSync3 } from "node:fs";
+import { isAbsolute as isAbsolute3 } 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.name = "InvalidRuntimeOverrideError";
+    this.reason = reason;
+  }
 }
-function unlinkQuietly(path) {
+
+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.name = "InvalidDaemonVersionError";
+    this.version = version;
+  }
+}
+function validateDaemonVersion(version) {
+  if (!DAEMON_VERSION_PATTERN.test(version))
+    throw new InvalidDaemonVersionError(version);
+  return version;
+}
+function resolveDaemonRuntime(env, defaults) {
+  const cliOverride = env[OMO_LSP_DAEMON_CLI];
+  const versionOverride = env[OMO_LSP_DAEMON_VERSION];
+  const hasCliOverride = cliOverride !== undefined;
+  const hasVersionOverride = versionOverride !== undefined;
+  if (hasCliOverride !== hasVersionOverride) {
+    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)) {
+      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)) {
+    throw new InvalidRuntimeOverrideError("cli_must_be_absolute", `${OMO_LSP_DAEMON_CLI} must be an absolute path to an existing regular file`);
+  }
+  let cliStats;
   try {
-    unlinkSync(path);
-  } catch (error) {}
+    cliStats = statSync3(cliOverride);
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+    throw new InvalidRuntimeOverrideError("cli_not_found", `${OMO_LSP_DAEMON_CLI} must name an existing regular file`);
+  }
+  if (!cliStats.isFile()) {
+    throw new InvalidRuntimeOverrideError("cli_not_file", `${OMO_LSP_DAEMON_CLI} must name an existing regular file`);
+  }
+  return { cliPath: cliOverride, version: validateDaemonVersion(versionOverride) };
+}
+
+// src/paths.ts
+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.name = "InvalidDaemonDirectoryError";
+    this.directory = directory;
+  }
+}
+function resolveDaemonVersion(requireFn = requireFromHere) {
+  for (const candidate of ["./package.json", "../package.json"]) {
+    let loaded;
+    try {
+      loaded = requireFn(candidate);
+    } catch (error) {
+      if (!(error instanceof Error))
+        throw error;
+      continue;
+    }
+    if (typeof loaded === "object" && loaded !== null && "version" in loaded) {
+      const version = Reflect.get(loaded, "version");
+      if (typeof version === "string")
+        return validateDaemonVersion(version);
+    }
+  }
+  return "0";
+}
+function packagedRuntimeDefaults() {
+  return {
+    cliPath: fileURLToPath2(new URL("./cli.js", import.meta.url)),
+    version: resolveDaemonVersion()
+  };
+}
+function daemonBaseDir(env = process.env, platform = defaultDaemonPlatform()) {
+  const override = env[OMO_LSP_DAEMON_DIR];
+  if (override !== undefined) {
+    if (!platform.path.isAbsolute(override))
+      throw new InvalidDaemonDirectoryError(override);
+    return platform.path.resolve(override);
+  }
+  return platform.path.resolve(platform.path.join(platform.homedir(), ".omo", "lsp-daemon"));
+}
+function daemonPaths(env = process.env, runtimeDefaults = packagedRuntimeDefaults(), platform = defaultDaemonPlatform()) {
+  const runtime = resolveDaemonRuntime(env, runtimeDefaults);
+  const baseDir = daemonBaseDir(env, platform);
+  const dir = platform.path.resolve(platform.path.join(baseDir, `v${runtime.version}`));
+  return {
+    version: runtime.version,
+    cliPath: runtime.cliPath,
+    dir,
+    socket: resolveSocketPath(dir, runtime.version, platform),
+    lock: platform.path.join(dir, "daemon.lock"),
+    pid: platform.path.join(dir, "daemon.pid"),
+    auth: platform.path.join(dir, "daemon.auth"),
+    endpoint: platform.path.join(dir, "daemon.endpoint"),
+    owner: platform.path.join(dir, "daemon.owner"),
+    log: platform.path.join(dir, "daemon.log")
+  };
+}
+function defaultDaemonPlatform() {
+  return {
+    platform: process.platform,
+    homedir: homedir2,
+    tmpdir,
+    getuid: () => typeof process.getuid === "function" ? process.getuid() : undefined,
+    username: () => userInfo().username,
+    path
+  };
+}
+function resolveSocketPath(dir, version, platform) {
+  const canonicalVersionDir = platform.path.resolve(dir);
+  if (platform.platform === "win32") {
+    const currentUserDiscriminator = `${platform.getuid() ?? "win"}:${platform.username()}:${platform.path.resolve(platform.homedir())}`;
+    const digest = shortDigest(`${canonicalVersionDir}\x00${currentUserDiscriminator}`);
+    return `\\\\.\\pipe\\omo-lsp-${version}-${digest}`;
+  }
+  const natural = platform.path.join(canonicalVersionDir, "daemon.sock");
+  if (natural.length < MAX_SOCKET_PATH_LENGTH)
+    return natural;
+  return platform.path.join(platform.tmpdir(), `omo-lsp-${version}-${shortDigest(canonicalVersionDir)}`, "daemon.sock");
+}
+function shortDigest(value) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, 16);
+}
+
+// src/socket-jsonrpc.ts
+function encodeJsonLine(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+function createLineDecoder(onMessage, onParseError) {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      let index = buffer.indexOf(`
+`);
+      while (index !== -1) {
+        const raw = buffer.slice(0, index).trim();
+        buffer = buffer.slice(index + 1);
+        if (raw.length > 0) {
+          try {
+            onMessage(JSON.parse(raw));
+          } catch (error) {
+            if (error instanceof Error) {
+              onParseError?.(raw, error);
+            } else {
+              throw error;
+            }
+          }
+        }
+        index = buffer.indexOf(`
+`);
+      }
+    }
+  };
 }
 
 // src/ensure-daemon.ts
 var PROBE_TIMEOUT_MS = 500;
 var DEFAULT_READY_TIMEOUT_MS = 5000;
 var DEFAULT_POLL_INTERVAL_MS = 100;
-var CODEX_LSP_DAEMON_CLI_ENV = "CODEX_LSP_DAEMON_CLI";
 
 class DaemonUnreachableError extends Error {
   constructor(socketPath) {
@@ -1498,61 +3591,62 @@ class DaemonUnreachableError extends Error {
     this.name = "DaemonUnreachableError";
   }
 }
-async function ensureDaemonRunning(paths, deps = defaultEnsureDaemonDeps(), options = {}) {
-  const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
-  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  if (await deps.probe(paths.socket))
-    return;
-  const lock = deps.acquireLock(paths.lock);
-  if (!lock) {
-    await waitUntilReachable(paths.socket, deps, readyTimeoutMs, pollIntervalMs);
-    return;
-  }
-  try {
-    if (await deps.probe(paths.socket))
-      return;
-    deps.cleanupStaleSocket(paths.socket);
-    deps.spawnDaemon(paths);
-    await waitUntilReachable(paths.socket, deps, readyTimeoutMs, pollIntervalMs);
-  } finally {
-    lock.release();
-  }
-}
-async function waitUntilReachable(socketPath, deps, readyTimeoutMs, pollIntervalMs) {
+async function ensureDaemonRunning(paths, deps = defaultEnsureDaemonDeps(), options = {}) {
+  const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  if (await deps.probe(paths))
+    return;
+  deps.spawnDaemon(paths);
+  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs);
+}
+async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs) {
   const deadline = deps.now() + readyTimeoutMs;
   for (;; ) {
-    if (await deps.probe(socketPath))
+    if (await deps.probe(paths))
       return;
     if (deps.now() >= deadline)
-      throw new DaemonUnreachableError(socketPath);
+      throw new DaemonUnreachableError(paths.socket);
     await deps.sleep(pollIntervalMs);
   }
 }
-function probeSocket(socketPath, timeoutMs = PROBE_TIMEOUT_MS) {
-  return new Promise((resolve2) => {
-    const socket = connect(socketPath);
-    const finish = (ok) => {
+async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS) {
+  const token = readAuthToken(paths);
+  if (!token)
+    return false;
+  return await pingDaemon(paths, token, timeoutMs) !== null;
+}
+function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
+  return new Promise((resolve7) => {
+    const socket = connect(paths.socket);
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
       socket.destroy();
-      resolve2(ok);
+      resolve7(value);
     };
-    const timer = setTimeout(() => finish(false), timeoutMs);
+    const timer = setTimeout(() => finish(null), timeoutMs);
     timer.unref?.();
-    socket.once("connect", () => {
+    const decoder = createLineDecoder((message) => {
       clearTimeout(timer);
-      finish(true);
+      finish(parsePingResponse(message));
+    });
+    socket.once("connect", () => {
+      socket.write(encodeJsonLine({ jsonrpc: "2.0", id: 1, method: "omo/ping", params: { _omo: authEnvelope(token) } }));
     });
+    socket.on("data", (chunk) => decoder.push(chunk));
     socket.once("error", () => {
       clearTimeout(timer);
-      finish(false);
+      finish(null);
     });
   });
 }
 function spawnDaemonProcess(paths) {
-  mkdirSync2(dirname2(paths.log), { recursive: true });
+  mkdirSync2(dirname6(paths.log), { recursive: true });
   const logFd = openSync2(paths.log, "a");
   try {
-    const cliPath = resolveDaemonCliPath();
-    const child = spawn2(execPath, [cliPath, "daemon"], {
+    const child = spawn2(execPath, [paths.cliPath, "daemon"], {
       detached: true,
       stdio: ["ignore", logFd, logFd]
     });
@@ -1561,81 +3655,44 @@ function spawnDaemonProcess(paths) {
     closeSync2(logFd);
   }
 }
-function resolveDaemonCliPath(env = process.env) {
-  const override = env[CODEX_LSP_DAEMON_CLI_ENV]?.trim();
-  if (override)
-    return override;
-  return fileURLToPath(new URL("./cli.js", import.meta.url));
-}
 function defaultEnsureDaemonDeps() {
   return {
-    probe: (socketPath) => probeSocket(socketPath),
-    acquireLock: (lockPath) => tryAcquireLock(lockPath),
-    cleanupStaleSocket: (socketPath) => {
-      if (existsSync2(socketPath))
-        unlinkQuietly(socketPath);
-    },
+    probe: (paths) => probeDaemon(paths),
     spawnDaemon: (paths) => spawnDaemonProcess(paths),
-    sleep: (ms) => new Promise((resolve2) => {
-      setTimeout(resolve2, ms);
+    sleep: (ms) => new Promise((resolve7) => {
+      setTimeout(resolve7, ms);
     }),
     now: () => Date.now()
   };
 }
-
-// src/paths.ts
-import { createHash } from "node:crypto";
-import { createRequire } from "node:module";
-import { homedir, tmpdir } from "node:os";
-import { join as join2 } from "node:path";
-var requireFromHere = createRequire(import.meta.url);
-var MAX_SOCKET_PATH_LENGTH = 100;
-var CODEX_LSP_DAEMON_VERSION_ENV = "CODEX_LSP_DAEMON_VERSION";
-function resolveDaemonVersion(requireFn = requireFromHere) {
-  for (const candidate of ["./package.json", "../package.json"]) {
-    try {
-      const pkg = requireFn(candidate);
-      if (typeof pkg.version === "string" && pkg.version.length > 0)
-        return pkg.version;
-    } catch {}
-  }
-  return "0";
-}
-function daemonBaseDir(env = process.env) {
-  const explicit = env["CODEX_LSP_DAEMON_DIR"]?.trim();
-  if (explicit)
-    return explicit;
-  const pluginData = env["PLUGIN_DATA"]?.trim();
-  if (pluginData)
-    return join2(pluginData, "daemon");
-  const codexHome = env["CODEX_HOME"]?.trim();
-  const home = codexHome && codexHome.length > 0 ? codexHome : join2(homedir(), ".codex");
-  return join2(home, "codex-lsp", "daemon");
-}
-function daemonPaths(env = process.env, version = resolveDaemonVersionFromEnv(env) ?? resolveDaemonVersion()) {
-  const dir = join2(daemonBaseDir(env), `v${version}`);
-  return {
-    version,
-    dir,
-    socket: resolveSocketPath(dir, version),
-    lock: join2(dir, "daemon.lock"),
-    pid: join2(dir, "daemon.pid"),
-    log: join2(dir, "daemon.log")
-  };
-}
-function resolveDaemonVersionFromEnv(env = process.env) {
-  const version = env[CODEX_LSP_DAEMON_VERSION_ENV]?.trim();
-  return version && version.length > 0 ? version : null;
-}
-function resolveSocketPath(dir, version) {
-  const digest = createHash("sha256").update(dir).digest("hex").slice(0, 16);
-  if (process.platform === "win32") {
-    return `\\\\.\\pipe\\omo-lsp-${version}-${digest}`;
+function parsePingResponse(message) {
+  if (!message || typeof message !== "object" || Array.isArray(message))
+    return null;
+  const result = Reflect.get(message, "result");
+  if (!result || typeof result !== "object" || Array.isArray(result))
+    return null;
+  const pid = Reflect.get(result, "pid");
+  const nonce = Reflect.get(result, "nonce");
+  const startedAt = Reflect.get(result, "startedAt");
+  const endpoint = Reflect.get(result, "endpoint");
+  if (typeof pid !== "number" || typeof nonce !== "string" || typeof startedAt !== "string")
+    return null;
+  if (!endpoint || typeof endpoint !== "object" || Array.isArray(endpoint))
+    return null;
+  const path2 = Reflect.get(endpoint, "path");
+  const kind = Reflect.get(endpoint, "kind");
+  if (typeof path2 !== "string")
+    return null;
+  if (kind === "windows")
+    return { pid, nonce, startedAt, endpoint: { kind, path: path2 } };
+  if (kind === "missing")
+    return { pid, nonce, startedAt, endpoint: { kind, path: path2 } };
+  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 } };
   }
-  const natural = join2(dir, "daemon.sock");
-  if (natural.length < MAX_SOCKET_PATH_LENGTH)
-    return natural;
-  return join2(tmpdir(), `omo-lsp-${version}-${digest}.sock`);
+  return null;
 }
 // ../mcp-stdio-core/src/responses.ts
 function successResponse(id, result) {
@@ -1644,12 +3701,9 @@ 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) {
-  return error instanceof Error ? error.message : String(error);
-}
 // ../mcp-stdio-core/src/transport.ts
 var HEADER_SEPARATOR2 = Buffer.from(`\r
 \r
@@ -1796,7 +3850,7 @@ 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 });
   try {
@@ -1836,29 +3890,22 @@ function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
     closed: () => isClosed
   };
 }
-// ../lsp-core/src/tools/diagnostics.ts
-import { resolve as resolve4 } from "node:path";
-
 // ../lsp-core/src/lsp/client-wrapper.ts
-import { existsSync as existsSync6, statSync as statSync2 } from "node:fs";
-import { dirname as dirname4, join as join6, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync9, statSync as statSync4 } from "node:fs";
+import { dirname as dirname8, join as join4, resolve as resolve7 } from "node:path";
 
 // ../lsp-core/src/lsp/server-install-state.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, isAbsolute, join as join3 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
 function getInstallDecisionsPath() {
-  const override = contextEnv("LSP_TOOLS_MCP_INSTALL_DECISIONS");
-  if (!override)
-    return join3(homedir2(), ".codex", "lsp-install-decisions.json");
-  return isAbsolute(override) ? override : join3(homedir2(), override);
+  return lspRequestContext().installDecisionsPath;
 }
 function loadInstallDecisions() {
-  const path = getInstallDecisionsPath();
-  if (!existsSync3(path))
+  const path2 = getInstallDecisionsPath();
+  if (!existsSync6(path2))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path2, "utf8"));
     return isInstallDecisions(parsed) ? parsed : {};
   } catch {
     return {};
@@ -1876,29 +3923,27 @@ function isInstallDecision(value) {
   return value === "declined" || value === "allowed";
 }
 function writeInstallDecisions(decisions) {
-  const path = getInstallDecisionsPath();
-  mkdirSync3(dirname3(path), { recursive: true });
-  const tmpPath = `${path}.tmp`;
-  writeFileSync(tmpPath, `${JSON.stringify(decisions, null, 2)}
+  const path2 = getInstallDecisionsPath();
+  mkdirSync3(dirname7(path2), { recursive: true });
+  const tmpPath = `${path2}.tmp`;
+  writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
 `, "utf8");
-  renameSync(tmpPath, path);
+  renameSync2(tmpPath, path2);
 }
 function isInstallDecisions(value) {
-  return isRecord2(value) && Object.values(value).every(isInstallDecisionRecord);
+  return isRecord5(value) && Object.values(value).every(isInstallDecisionRecord);
 }
 function isInstallDecisionRecord(value) {
-  if (!isRecord2(value))
+  if (!isRecord5(value))
     return false;
   return isInstallDecision(value["decision"]) && typeof value["decidedAt"] === "string";
 }
-function isRecord2(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // ../lsp-core/src/lsp/config-loader.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { delimiter as delimiter2, isAbsolute as isAbsolute2, join as join4 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
 
 // ../lsp-core/src/lsp/server-definitions.ts
 var LSP_INSTALL_HINTS = {
@@ -2048,27 +4093,17 @@ var BUILTIN_SERVERS = {
 };
 
 // ../lsp-core/src/lsp/config-loader.ts
-function resolveProjectConfigPath(path) {
-  return isAbsolute2(path) ? path : join4(contextCwd(), path);
-}
 function getProjectConfigPaths() {
-  const projectOverride = contextEnv("LSP_TOOLS_MCP_PROJECT_CONFIG");
-  if (projectOverride) {
-    return projectOverride.split(delimiter2).filter(Boolean).map(resolveProjectConfigPath);
-  }
-  return [join4(contextCwd(), ".codex", "lsp-client.json")];
+  return lspRequestContext().projectConfigPaths;
 }
 function getUserConfigPath() {
-  const userOverride = contextEnv("LSP_TOOLS_MCP_USER_CONFIG");
-  if (!userOverride)
-    return join4(homedir3(), ".codex", "lsp-client.json");
-  return isAbsolute2(userOverride) ? userOverride : join4(homedir3(), userOverride);
+  return lspRequestContext().userConfigPath;
 }
-function loadJsonFile(path) {
-  if (!existsSync4(path))
+function loadJsonFile(path2) {
+  if (!existsSync7(path2))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(path2, "utf-8"));
     return isConfigJson(parsed) ? parsed : null;
   } catch {
     return null;
@@ -2085,8 +4120,8 @@ function loadAllConfigs() {
   return configs;
 }
 function loadFirstJsonFile(paths) {
-  for (const path of paths) {
-    const config = loadJsonFile(path);
+  for (const path2 of paths) {
+    const config = loadJsonFile(path2);
     if (config)
       return config;
   }
@@ -2207,16 +4242,16 @@ function applyOptionalServerFields(server2, entry) {
   }
 }
 function isConfigJson(value) {
-  if (!isRecord3(value))
+  if (!isRecord6(value))
     return false;
   const lsp = value["lsp"];
-  return lsp === undefined || isRecord3(lsp);
+  return lsp === undefined || isRecord6(lsp);
 }
 function parseLspEntry(value) {
   return isLspEntry(value) ? value : null;
 }
 function isLspEntry(value) {
-  if (!isRecord3(value))
+  if (!isRecord6(value))
     return false;
   const disabled = value["disabled"];
   const command = value["command"];
@@ -2224,15 +4259,15 @@ function isLspEntry(value) {
   const priority = value["priority"];
   const env = value["env"];
   const initialization = value["initialization"];
-  return (disabled === undefined || typeof disabled === "boolean") && (command === undefined || isStringArray(command)) && (extensions === undefined || isStringArray(extensions)) && (priority === undefined || typeof priority === "number") && (env === undefined || isStringRecord(env)) && (initialization === undefined || isRecord3(initialization));
+  return (disabled === undefined || typeof disabled === "boolean") && (command === undefined || isStringArray(command)) && (extensions === undefined || isStringArray(extensions)) && (priority === undefined || typeof priority === "number") && (env === undefined || isStringRecord(env)) && (initialization === undefined || isRecord6(initialization));
 }
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
 function isStringRecord(value) {
-  return isRecord3(value) && Object.values(value).every((item) => typeof item === "string");
+  return isRecord6(value) && Object.values(value).every((item) => typeof item === "string");
 }
-function isRecord3(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function getDisabledServerIds() {
@@ -2253,8 +4288,8 @@ function getDisabledServerIds() {
 }
 
 // ../lsp-core/src/lsp/server-installation.ts
-import { existsSync as existsSync5 } from "node:fs";
-import { delimiter as delimiter3, join as join5 } from "node:path";
+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;
@@ -2262,7 +4297,7 @@ function isServerInstalled(command, _workingDirectory) {
   if (!cmd)
     return false;
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync5(cmd))
+    if (existsSync8(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -2283,7 +4318,7 @@ function isServerInstalled(command, _workingDirectory) {
   const paths = pathEnv.split(delimiter3);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync5(join5(p, cmd + suffix))) {
+      if (existsSync8(join3(p, cmd + suffix))) {
         return true;
       }
     }
@@ -2382,39 +4417,50 @@ function getAllServers() {
 var WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
 function isDirectoryPath(filePath) {
   try {
-    return statSync2(filePath).isDirectory();
+    return statSync4(filePath).isDirectory();
   } catch {
     return false;
   }
 }
 function findWorkspaceRoot(filePath) {
-  const abs = resolve2(contextCwd(), filePath);
+  const abs = resolvePathInsideContext(filePath);
   let dir = abs;
   if (!isDirectoryPath(dir)) {
-    dir = dirname4(dir);
+    dir = dirname8(dir);
   }
   let prevDir = "";
   while (dir !== prevDir) {
     for (const marker of WORKSPACE_MARKERS) {
-      if (existsSync6(join6(dir, marker))) {
+      if (existsSync9(join4(dir, marker))) {
         return dir;
       }
     }
     prevDir = dir;
-    dir = dirname4(dir);
+    dir = dirname8(dir);
+  }
+  return dirname8(abs);
+}
+function resolvePathInsideContext(filePath) {
+  const cwd = contextCwd();
+  const abs = resolve7(cwd, filePath);
+  const canonical = canonicalizeExistingOrNearestAncestor(abs);
+  if (!isPathInside(cwd, canonical)) {
+    throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
   }
-  return dirname4(abs);
+  return canonical;
 }
 function formatServerLookupError(result) {
   if (result.status === "not_installed") {
     return formatNotInstalled(result);
   }
+  const context = lspRequestContext();
+  const firstProjectConfigPath = context.projectConfigPaths[0] ?? "<project lsp config>";
   return [
     `No LSP server configured for extension: ${result.extension}`,
     "",
     `Available servers: ${result.availableServers.slice(0, 10).join(", ")}${result.availableServers.length > 10 ? "..." : ""}`,
     "",
-    "Configure a custom server in '.codex/lsp-client.json':",
+    `Configure a custom server in '${firstProjectConfigPath}' or '${context.userConfigPath}':`,
     "  {",
     '    "lsp": {',
     '      "my-server": {',
@@ -2430,6 +4476,7 @@ function formatNotInstalled(result) {
   const { server: server2, installHint } = result;
   const extensions = server2.extensions.join(", ");
   const decision = loadInstallDecision(server2.id)?.decision;
+  const context = lspRequestContext();
   if (decision === "declined") {
     return `LSP server '${server2.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
   }
@@ -2445,6 +4492,17 @@ function formatNotInstalled(result) {
       "The user has pre-authorized LSP installation. Run the install command, then retry this tool:",
       `  ${installHint}`
     ].join(`
+`);
+  }
+  if (!context.capabilities.installDecisionTool) {
+    return [
+      ...header,
+      "To install, run:",
+      `  ${installHint}`,
+      "",
+      "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."
+    ].join(`
 `);
   }
   return [
@@ -2456,6 +4514,7 @@ function formatNotInstalled(result) {
     "- 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" },`,
+    `    which writes to ${context.installDecisionsPath},`,
     "    then ignore this message and proceed WITHOUT LSP."
   ].join(`
 `);
@@ -2469,14 +4528,14 @@ var READ_ONLY_RETRY_TOOLS = new Set([
   "prepareRename"
 ]);
 async function withLspClient(filePath, fn, toolName, options = {}) {
-  const absPath = resolve2(contextCwd(), filePath);
+  const absPath = 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.");
   }
   const ext = effectiveExtension(absPath);
   const result = findServerForExtension(ext);
   if (result.status !== "found") {
-    throw new LspServerLookupError(formatServerLookupError(result));
+    throw new LspServerLookupError(formatServerLookupError(result), result);
   }
   const server2 = result.server;
   const root = findWorkspaceRoot(absPath);
@@ -2504,11 +4563,11 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
 }
 
 // ../lsp-core/src/lsp/directory-diagnostics.ts
-import { existsSync as existsSync7, lstatSync, readdirSync } from "node:fs";
-import { join as join7, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync10, lstatSync as lstatSync5, readdirSync as readdirSync3 } from "node:fs";
+import { join as join5, resolve as resolve8 } from "node:path";
 
 // ../lsp-core/src/lsp/formatters.ts
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 var DIAGNOSTIC_SEVERITY_FILTERS = {
   error: 1,
   warning: 2,
@@ -2516,7 +4575,7 @@ var DIAGNOSTIC_SEVERITY_FILTERS = {
   hint: 4
 };
 function uriToPath(uri) {
-  return fileURLToPath2(uri);
+  return fileURLToPath3(uri);
 }
 function formatLocation(loc) {
   if ("targetUri" in loc) {
@@ -2602,6 +4661,9 @@ function formatApplyResult(result) {
     for (const file of result.filesModified) {
       lines.push(`  - ${file}`);
     }
+    if (result.lateAbort) {
+      lines.push("Cancellation arrived after the filesystem commit began; the committed edit completed.");
+    }
   } else {
     lines.push("Failed to apply some changes:");
     for (const err of result.errors) {
@@ -2617,6 +4679,7 @@ function formatApplyResult(result) {
 
 // ../lsp-core/src/lsp/directory-diagnostics.ts
 var SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
+var DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY = 4;
 function collectFilesWithExtension(dir, extension, maxFiles) {
   const files = [];
   function walk(currentDir) {
@@ -2624,17 +4687,17 @@ function collectFilesWithExtension(dir, extension, maxFiles) {
       return;
     let entries = [];
     try {
-      entries = readdirSync(currentDir);
+      entries = readdirSync3(currentDir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (files.length >= maxFiles)
         return;
-      const fullPath = join7(currentDir, entry);
+      const fullPath = join5(currentDir, entry);
       let stat;
       try {
-        stat = lstatSync(fullPath);
+        stat = lstatSync5(fullPath);
       } catch {
         continue;
       }
@@ -2652,52 +4715,65 @@ function collectFilesWithExtension(dir, extension, maxFiles) {
   walk(dir);
   return files;
 }
-async function aggregateDiagnosticsForDirectory(directory, extension, severity, maxFiles = DEFAULT_MAX_DIRECTORY_FILES) {
+async function aggregateDiagnosticsForDirectory(directory, extension, severity, maxFiles = DEFAULT_MAX_DIRECTORY_FILES, options = {}) {
   if (!extension.startsWith(".")) {
     throw new LspInvalidPathError(`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`);
   }
-  const absDir = resolve3(contextCwd(), directory);
-  if (!existsSync7(absDir)) {
+  const absDir = resolve8(options.workspaceRoot ?? contextCwd(), directory);
+  if (!existsSync10(absDir)) {
     throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
   }
-  const serverResult = findServerForExtension(extension);
+  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 allFiles = collectFilesWithExtension(absDir, extension, maxFiles + 1);
+  const allFiles = (options.listFiles ?? collectFilesWithExtension)(absDir, extension, maxFiles + 1);
   const wasCapped = allFiles.length > maxFiles;
   const filesToProcess = allFiles.slice(0, maxFiles);
   if (filesToProcess.length === 0) {
-    return [
+    const output = [
       `Directory: ${absDir}`,
       `Extension: ${extension}`,
       "Files scanned: 0",
       `No files found with extension "${extension}".`
     ].join(`
 `);
+    return { output, totalDiagnostics: 0, fileFailures: [] };
   }
-  const root = findWorkspaceRoot(absDir);
-  const manager = getLspManager();
+  const root = options.workspaceRoot ?? findWorkspaceRoot(absDir);
+  const manager = options.manager ?? getLspManager();
   const allDiagnostics = [];
   const fileErrors = [];
+  const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
+  options.signal?.throwIfAborted();
   const client = await manager.getClient(root, server2);
   try {
-    for (const file of filesToProcess) {
-      try {
-        const result = await client.diagnostics(file);
-        const filtered = filterDiagnosticsBySeverity(result.items, severity);
-        allDiagnostics.push(...filtered.map((diagnostic) => ({
-          filePath: file,
-          diagnostic
-        })));
-      } catch (e) {
-        fileErrors.push({
-          file,
-          error: e instanceof Error ? e.message : String(e)
-        });
+    let nextIndex = 0;
+    const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
+      for (;; ) {
+        if (options.signal?.aborted)
+          return;
+        const file = filesToProcess[nextIndex];
+        nextIndex += 1;
+        if (file === undefined)
+          return;
+        try {
+          const result = await client.diagnostics(file, options.signal);
+          const filtered = filterDiagnosticsBySeverity(result.items, severity);
+          allDiagnostics.push(...filtered.map((diagnostic) => ({
+            filePath: file,
+            diagnostic
+          })));
+        } catch (e) {
+          fileErrors.push({
+            file,
+            error: e instanceof Error ? e.message : String(e)
+          });
+        }
       }
-    }
+    });
+    await Promise.all(workers);
   } finally {
     manager.releaseClient(root, server2.id);
   }
@@ -2725,13 +4801,13 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
       lines.push("", `... (${allDiagnostics.length - DEFAULT_MAX_DIAGNOSTICS} more diagnostics not shown)`);
     }
   }
-  return lines.join(`
-`);
+  return { output: lines.join(`
+`), totalDiagnostics: allDiagnostics.length, fileFailures: fileErrors };
 }
 
 // ../lsp-core/src/lsp/infer-extension.ts
-import { lstatSync as lstatSync2, readdirSync as readdirSync2 } from "node:fs";
-import { join as join8 } from "node:path";
+import { lstatSync as lstatSync6, readdirSync as readdirSync4 } from "node:fs";
+import { join as join6 } from "node:path";
 var SKIP_DIRECTORIES2 = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
 var MAX_SCAN_ENTRIES = 500;
 function inferExtensionFromDirectory(directory) {
@@ -2742,17 +4818,17 @@ function inferExtensionFromDirectory(directory) {
       return;
     let entries;
     try {
-      entries = readdirSync2(dir);
+      entries = readdirSync4(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (scanned >= MAX_SCAN_ENTRIES)
         return;
-      const fullPath = join8(dir, entry);
+      const fullPath = join6(dir, entry);
       let stat;
       try {
-        stat = lstatSync2(fullPath);
+        stat = lstatSync6(fullPath);
       } catch {
         continue;
       }
@@ -2826,13 +4902,48 @@ function missingDependencyResult(error, details) {
     details: {
       ...details,
       error: message,
-      errorKind: "missing_dependency"
+      errorKind: "missing_dependency",
+      ...availabilityDetails(error)
     }
   };
 }
+function availabilityDetails(error) {
+  const availability = missingDependencyAvailability(error);
+  return availability === null ? {} : { availability };
+}
+function missingDependencyAvailability(error) {
+  if (!(error instanceof LspServerLookupError) || error.lookup === undefined)
+    return null;
+  const context = lspRequestContext();
+  switch (error.lookup.status) {
+    case "not_configured":
+      return {
+        kind: "not_configured",
+        extension: error.lookup.extension,
+        availableServers: [...error.lookup.availableServers],
+        projectConfigPaths: [...context.projectConfigPaths],
+        userConfigPath: context.userConfigPath,
+        installDecisionTool: context.capabilities.installDecisionTool
+      };
+    case "not_installed":
+      return {
+        kind: "not_installed",
+        serverId: error.lookup.server.id,
+        command: [...error.lookup.server.command],
+        extensions: [...error.lookup.server.extensions],
+        installHint: error.lookup.installHint,
+        installDecisionTool: context.capabilities.installDecisionTool,
+        installDecisionsPath: context.installDecisionsPath
+      };
+    default: {
+      const exhaustive = error.lookup;
+      return exhaustive;
+    }
+  }
+}
 
 // ../lsp-core/src/tools/parameters.ts
-function isRecord4(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function requireString(params, key) {
@@ -2889,7 +5000,7 @@ async function executeLspDiagnostics(params, signal) {
   const filePath = requireString(params, "filePath");
   const severity = severityFilter(params);
   try {
-    const absPath = resolve4(contextCwd(), filePath);
+    const absPath = resolvePathInsideContext(filePath);
     if (isDirectoryPath(absPath)) {
       const extension = inferExtensionFromDirectory(absPath);
       if (!extension) {
@@ -2906,18 +5017,33 @@ async function executeLspDiagnostics(params, signal) {
         };
         return text(message, details3);
       }
-      const output2 = await aggregateDiagnosticsForDirectory(absPath, extension, severity);
+      const output2 = await aggregateDiagnosticsForDirectory(absPath, extension, severity, undefined, signal === undefined ? {} : { signal });
       const details2 = {
         filePath,
         severity,
         mode: "directory",
         diagnostics: [],
+        totalDiagnostics: output2.totalDiagnostics,
+        truncated: false,
+        fileFailures: [...output2.fileFailures]
+      };
+      return text(output2.output, details2);
+    }
+    const result = await withLspClient(filePath, async (client) => client.diagnostics(filePath, signal), "diagnostics", clientOptions(signal));
+    if (result.transientError) {
+      const message = result.transientError.message;
+      const details2 = {
+        filePath,
+        severity,
+        mode: "file",
+        diagnostics: [],
         totalDiagnostics: 0,
-        truncated: false
+        truncated: false,
+        error: message,
+        errorKind: result.transientError.kind
       };
-      return text(output2, details2);
+      return text(message, details2, true);
     }
-    const result = await withLspClient(filePath, async (client) => client.diagnostics(filePath), "diagnostics", clientOptions(signal));
     const diagnostics = filterDiagnosticsBySeverity(asDiagnosticArray(result), severity);
     const total = diagnostics.length;
     const truncated = total > DEFAULT_MAX_DIAGNOSTICS;
@@ -2978,7 +5104,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), "definition", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client) => client.definition(filePath, line, character, signal), "definition", clientOptions(signal));
     const locations = !result ? [] : Array.isArray(result) ? result : [result];
     const details = { filePath, line, character, locations };
     if (locations.length === 0)
@@ -3003,7 +5129,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), "references", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client) => client.references(filePath, line, character, includeDeclaration, signal), "references", clientOptions(signal));
     const references = Array.isArray(result) ? result : [];
     const total = references.length;
     const truncated = total > DEFAULT_MAX_REFERENCES;
@@ -3039,181 +5165,13 @@ async function executeLspFindReferences(params, signal) {
   }
 }
 
-// ../lsp-core/src/lsp/workspace-edit.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5, realpathSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname5, isAbsolute as isAbsolute3, relative, resolve as resolve5 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-function errorMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function isPathInsideWorkspace(filePath, workspaceRoot) {
-  const relativePath = relative(workspaceRoot, filePath);
-  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute3(relativePath);
-}
-function realpathForValidation(filePath) {
-  if (existsSync8(filePath))
-    return realpathSync(filePath);
-  const parent = dirname5(filePath);
-  return resolve5(realpathSync(parent), relative(parent, filePath));
-}
-function uriToWorkspacePath(uri, workspaceRoot) {
-  let filePath;
-  try {
-    filePath = fileURLToPath3(uri);
-  } catch (error) {
-    return { success: false, error: `non-file URI ${uri}: ${errorMessage2(error)}` };
-  }
-  let validatedPath;
-  try {
-    validatedPath = realpathForValidation(filePath);
-  } catch (error) {
-    return { success: false, error: `${filePath}: ${errorMessage2(error)}` };
-  }
-  if (!isPathInsideWorkspace(validatedPath, workspaceRoot)) {
-    return { success: false, error: `${filePath}: outside workspace ${workspaceRoot}` };
-  }
-  return { success: true, path: filePath };
-}
-function applyTextEditsToFile(filePath, edits) {
-  try {
-    const content = readFileSync5(filePath, "utf-8");
-    const lines = content.split(`
-`);
-    const sortedEdits = [...edits].sort((a, b) => {
-      if (b.range.start.line !== a.range.start.line) {
-        return b.range.start.line - a.range.start.line;
-      }
-      return b.range.start.character - a.range.start.character;
-    });
-    for (const edit of sortedEdits) {
-      const startLine = edit.range.start.line;
-      const startChar = edit.range.start.character;
-      const endLine = edit.range.end.line;
-      const endChar = edit.range.end.character;
-      if (startLine === endLine) {
-        const line = lines[startLine] ?? "";
-        lines[startLine] = line.substring(0, startChar) + edit.newText + line.substring(endChar);
-      } else {
-        const firstLine = lines[startLine] ?? "";
-        const lastLine = lines[endLine] ?? "";
-        const newContent = firstLine.substring(0, startChar) + edit.newText + lastLine.substring(endChar);
-        lines.splice(startLine, endLine - startLine + 1, ...newContent.split(`
-`));
-      }
-    }
-    writeFileSync2(filePath, lines.join(`
-`), "utf-8");
-    return { success: true, editCount: edits.length };
-  } catch (err) {
-    return {
-      success: false,
-      editCount: 0,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-function applyWorkspaceEdit(edit, options = {}) {
-  if (!edit) {
-    return { success: false, filesModified: [], totalEdits: 0, errors: ["No edit provided"] };
-  }
-  const result = { success: true, filesModified: [], totalEdits: 0, errors: [] };
-  const workspaceRoot = realpathSync(options.workspaceRoot ?? contextCwd());
-  if (edit.changes) {
-    for (const [uri, edits] of Object.entries(edit.changes)) {
-      const validatedPath = uriToWorkspacePath(uri, workspaceRoot);
-      if (!validatedPath.success) {
-        result.success = false;
-        result.errors.push(validatedPath.error);
-        continue;
-      }
-      const applyResult = applyTextEditsToFile(validatedPath.path, edits);
-      if (applyResult.success) {
-        result.filesModified.push(validatedPath.path);
-        result.totalEdits += applyResult.editCount;
-      } else {
-        result.success = false;
-        result.errors.push(`${validatedPath.path}: ${applyResult.error}`);
-      }
-    }
-  }
-  if (edit.documentChanges) {
-    for (const change of edit.documentChanges) {
-      if (!("kind" in change)) {
-        const validatedPath = uriToWorkspacePath(change.textDocument.uri, workspaceRoot);
-        if (!validatedPath.success) {
-          result.success = false;
-          result.errors.push(validatedPath.error);
-          continue;
-        }
-        const applyResult = applyTextEditsToFile(validatedPath.path, change.edits);
-        if (applyResult.success) {
-          result.filesModified.push(validatedPath.path);
-          result.totalEdits += applyResult.editCount;
-        } else {
-          result.success = false;
-          result.errors.push(`${validatedPath.path}: ${applyResult.error}`);
-        }
-        continue;
-      }
-      if (change.kind === "create") {
-        try {
-          const validatedPath = uriToWorkspacePath(change.uri, workspaceRoot);
-          if (!validatedPath.success) {
-            result.success = false;
-            result.errors.push(`Create ${change.uri}: ${validatedPath.error}`);
-            continue;
-          }
-          writeFileSync2(validatedPath.path, "", "utf-8");
-          result.filesModified.push(validatedPath.path);
-        } catch (err) {
-          result.success = false;
-          result.errors.push(`Create ${change.uri}: ${String(err)}`);
-        }
-      } else if (change.kind === "rename") {
-        try {
-          const oldPath = uriToWorkspacePath(change.oldUri, workspaceRoot);
-          const newPath = uriToWorkspacePath(change.newUri, workspaceRoot);
-          if (!oldPath.success || !newPath.success) {
-            const error = oldPath.success ? newPath.success ? "invalid URI" : newPath.error : oldPath.error;
-            result.success = false;
-            result.errors.push(`Rename ${change.oldUri}: ${error}`);
-            continue;
-          }
-          const content = readFileSync5(oldPath.path, "utf-8");
-          writeFileSync2(newPath.path, content, "utf-8");
-          unlinkSync2(oldPath.path);
-          result.filesModified.push(newPath.path);
-        } catch (err) {
-          result.success = false;
-          result.errors.push(`Rename ${change.oldUri}: ${String(err)}`);
-        }
-      } else if (change.kind === "delete") {
-        try {
-          const validatedPath = uriToWorkspacePath(change.uri, workspaceRoot);
-          if (!validatedPath.success) {
-            result.success = false;
-            result.errors.push(`Delete ${change.uri}: ${validatedPath.error}`);
-            continue;
-          }
-          unlinkSync2(validatedPath.path);
-          result.filesModified.push(validatedPath.path);
-        } catch (err) {
-          result.success = false;
-          result.errors.push(`Delete ${change.uri}: ${String(err)}`);
-        }
-      }
-    }
-  }
-  return result;
-}
-
 // ../lsp-core/src/tools/rename.ts
 async function executeLspPrepareRename(params, signal) {
   const filePath = requireString(params, "filePath");
   const line = requireNumber(params, "line");
   const character = requireNumber(params, "character");
   try {
-    const result = await withLspClient(filePath, async (client) => client.prepareRename(filePath, line, character), "prepareRename", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client) => client.prepareRename(filePath, line, character, signal), "prepareRename", clientOptions(signal));
     const details = { filePath, line, character, result };
     return text(formatPrepareRenameResult(result), details);
   } catch (error) {
@@ -3234,13 +5192,9 @@ async function executeLspRename(params, signal) {
   const character = requireNumber(params, "character");
   const newName = requireString(params, "newName");
   try {
-    const edit = await withLspClient(filePath, async (client, workspaceRoot) => ({
-      edit: await client.rename(filePath, line, character, newName),
-      workspaceRoot
-    }), "rename", clientOptions(signal));
-    const apply = applyWorkspaceEdit(edit.edit, { workspaceRoot: edit.workspaceRoot });
-    const details = { filePath, line, character, newName, apply, edit: edit.edit };
-    return text(formatApplyResult(apply), details, !apply.success);
+    const result = await withLspClient(filePath, async (client) => client.rename(filePath, 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) {
     const missingDependency = missingDependencyResult(error, {
       filePath,
@@ -3315,10 +5269,10 @@ async function executeLspSymbols(params, signal) {
           errorKind: "missing_query"
         });
       }
-      const symbols2 = await withLspClient(filePath, async (client) => client.workspaceSymbols(query), "workspaceSymbols", clientOptions(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), "documentSymbols", clientOptions(signal));
+    const symbols = await withLspClient(filePath, async (client) => client.documentSymbols(filePath, signal), "documentSymbols", clientOptions(signal));
     return formatSymbolsResult(filePath, scope, symbols, limit);
   } catch (error) {
     const query = optionalString(params, "query");
@@ -3484,16 +5438,16 @@ function matchesToolName(tool, name) {
   return tool.name === name || (tool.aliases?.includes(name) ?? false);
 }
 function coerceToolArguments(value) {
-  return isRecord4(value) ? value : {};
+  return isRecord7(value) ? value : {};
 }
 // ../lsp-core/src/mcp.ts
 var SERVER_NAME = "lsp";
 var SERVER_VERSION = "0.1.0";
-async function handleLspMcpRequest(input) {
+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;
@@ -3511,24 +5465,27 @@ async function handleLspMcpRequest(input) {
     return successResponse(id, { tools: LSP_MCP_TOOLS.map(describeTool) });
   }
   if (method === "tools/call") {
-    return handleToolCall(id, input["params"]);
+    return handleToolCall(id, input["params"], options.signal);
   }
   return errorResponse(id, -32601, `Method not found: ${String(method)}`);
 }
-async function handleToolCall(id, params) {
+async function handleToolCall(id, params, signal) {
   if (!isPlainRecord(params) || typeof params["name"] !== "string") {
     return errorResponse(id, -32602, "tools/call requires params.name");
   }
   try {
-    const result = await executeLspTool(params["name"], coerceToolArguments(params["arguments"]));
+    const result = await executeLspTool(params["name"], coerceToolArguments(params["arguments"]), signal);
     return successResponse(id, {
       content: result.content,
       isError: result.isError ?? false,
       details: result.details
     });
   } catch (error) {
+    if (!(error instanceof Error)) {
+      throw error;
+    }
     return successResponse(id, {
-      content: [{ type: "text", text: messageFromError(error) }],
+      content: [{ type: "text", text: error.message }],
       isError: true
     });
   }
@@ -3549,77 +5506,91 @@ function requestedProtocolVersion(params) {
 
 // src/request-routing.ts
 var CONTEXT_KEY = "_context";
+
+class InvalidDaemonRequestError extends Error {
+  name = "InvalidDaemonRequestError";
+}
 function extractRequestContext(raw) {
   if (!isPlainRecord(raw) || raw["method"] !== "tools/call")
     return { input: raw, context: undefined };
   const params = raw["params"];
   if (!isPlainRecord(params))
-    return { input: raw, context: undefined };
+    throw new InvalidDaemonRequestError("Daemon tools/call params must be an object.");
   const args = params["arguments"];
   if (!isPlainRecord(args))
-    return { input: raw, context: undefined };
+    throw new InvalidDaemonRequestError("Daemon tools/call arguments must be an object.");
+  if (!Object.hasOwn(args, CONTEXT_KEY)) {
+    throw new InvalidDaemonRequestError("Daemon tools/call arguments must include _context.");
+  }
   const context = parseContext(args[CONTEXT_KEY]);
-  if (!context)
-    return { input: raw, context: undefined };
   const cleanedArgs = { ...args };
   delete cleanedArgs[CONTEXT_KEY];
   const cleaned = { ...raw, params: { ...params, arguments: cleanedArgs } };
   return { input: cleaned, context };
 }
-function handleDaemonMessage(raw) {
-  const { input, context } = extractRequestContext(raw);
-  if (context)
-    return runWithRequestContext(context, () => handleLspMcpRequest(input));
-  return handleLspMcpRequest(input);
-}
-function parseContext(value) {
-  if (!isPlainRecord(value))
-    return;
-  const context = {};
-  const cwd = value["cwd"];
-  if (typeof cwd === "string")
-    context.cwd = cwd;
-  const env = value["env"];
-  if (isStringRecord2(env))
-    context.env = env;
-  return context.cwd === undefined && context.env === undefined ? undefined : context;
+function handleDaemonMessage(raw, state) {
+  const authenticated = authenticateMessage(raw, state.token);
+  if ("error" in authenticated)
+    return Promise.resolve(authenticated);
+  if (authenticated.method === "omo/ping") {
+    return Promise.resolve({
+      jsonrpc: "2.0",
+      id: authenticated.id,
+      result: { protocolVersion: OMO_DAEMON_PROTOCOL_VERSION, ...state.owner }
+    });
+  }
+  if (authenticated.method === "$/cancelRequest") {
+    const targetId = cancellationTargetId(authenticated.input);
+    if (targetId !== undefined)
+      state.activeRequests?.get(String(targetId))?.abort();
+    return Promise.resolve(undefined);
+  }
+  let routed;
+  try {
+    routed = extractRequestContext(authenticated.input);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "invalid daemon request";
+    return Promise.resolve({
+      jsonrpc: "2.0",
+      id: authenticated.id,
+      error: { code: -32602, message, data: { code: "invalid_daemon_request" } }
+    });
+  }
+  const { input, context } = routed;
+  const key = routeRequestKey(authenticated.id);
+  if (key === undefined || !state.activeRequests) {
+    if (context)
+      return runWithRequestContext(context, () => handleLspMcpRequest(input));
+    return handleLspMcpRequest(input);
+  }
+  const controller = new AbortController;
+  state.activeRequests.set(key, controller);
+  const options = { signal: controller.signal };
+  const run = context ? runWithRequestContext(context, () => handleLspMcpRequest(input, options)) : handleLspMcpRequest(input, options);
+  return run.finally(() => {
+    if (state.activeRequests?.get(key) === controller)
+      state.activeRequests.delete(key);
+  });
 }
-function isStringRecord2(value) {
-  return isPlainRecord(value) && Object.values(value).every((item) => typeof item === "string");
+function routeRequestKey(id) {
+  return typeof id === "string" || typeof id === "number" ? String(id) : undefined;
 }
-
-// src/socket-jsonrpc.ts
-function encodeJsonLine(message) {
-  return `${JSON.stringify(message)}
-`;
+function cancellationTargetId(input) {
+  const params = input["params"];
+  if (!isPlainRecord(params))
+    return;
+  const id = params["id"];
+  return typeof id === "string" || typeof id === "number" ? id : undefined;
 }
-function createLineDecoder(onMessage, onParseError) {
-  let buffer = "";
-  return {
-    push(chunk) {
-      buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-      let index = buffer.indexOf(`
-`);
-      while (index !== -1) {
-        const raw = buffer.slice(0, index).trim();
-        buffer = buffer.slice(index + 1);
-        if (raw.length > 0) {
-          try {
-            onMessage(JSON.parse(raw));
-          } catch (error) {
-            onParseError?.(raw, error);
-          }
-        }
-        index = buffer.indexOf(`
-`);
-      }
-    }
-  };
+function parseContext(value) {
+  if (!isPlainRecord(value))
+    throw new InvalidDaemonRequestError("LSP request _context must be an object.");
+  return parseLspRequestContext(value);
 }
 
 // src/daemon-client.ts
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
-var REQUEST_ID = 1;
+var nextProxyRequestId = 1;
 
 class DaemonRequestError extends Error {
   requestWritten;
@@ -3629,44 +5600,70 @@ class DaemonRequestError extends Error {
     this.requestWritten = requestWritten;
   }
 }
-async function callToolViaDaemon(name, args, options = {}) {
+
+class DaemonAuthenticationRejectedError extends DaemonRequestError {
+  constructor() {
+    super("daemon authentication failed before dispatch", true);
+    this.name = "DaemonAuthenticationRejectedError";
+  }
+}
+
+class DaemonRequestCancelledError extends DaemonRequestError {
+  constructor(requestWritten) {
+    super("daemon request cancelled", requestWritten);
+    this.name = "DaemonRequestCancelledError";
+  }
+}
+async function callToolViaDaemon(name, args, options) {
+  const context = requireContext(options.context);
   const paths = options.paths ?? daemonPaths();
   const ensure = options.ensure ?? ensureDaemonRunning;
   const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-  const requestArgs = withContext(args, options.context);
+  const requestArgs = withContext(args, context);
   let lastError;
-  for (let attempt = 0;attempt < 2; attempt += 1) {
+  let authRefreshUsed = false;
+  for (let attempt = 0;attempt < 3; attempt += 1) {
     try {
       await ensure(paths);
-      return await sendToolCall(paths.socket, name, requestArgs, timeoutMs);
+      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) {
       lastError = error;
-      if (error instanceof DaemonRequestError && error.requestWritten)
+      if (error instanceof DaemonAuthenticationRejectedError && !authRefreshUsed) {
+        authRefreshUsed = true;
+        continue;
+      }
+      if (error instanceof DaemonRequestCancelledError)
+        break;
+      if (error instanceof DaemonRequestError && (error.requestWritten || !isRetryableTool(name)))
         break;
     }
   }
   return daemonUnreachableResult(paths, lastError);
 }
-function callDiagnosticsViaDaemon(filePath, options = {}) {
+function callDiagnosticsViaDaemon(filePath, options) {
   return callToolViaDaemon("diagnostics", { filePath, severity: "error" }, options);
 }
-var FORWARDED_ENV_KEYS = [
-  "LSP_TOOLS_MCP_PROJECT_CONFIG",
-  "LSP_TOOLS_MCP_USER_CONFIG",
-  "LSP_TOOLS_MCP_INSTALL_DECISIONS"
-];
 function currentRequestContext(env = process.env) {
-  const forwarded = {};
-  for (const key of FORWARDED_ENV_KEYS) {
-    const value = env[key];
-    if (value !== undefined)
-      forwarded[key] = value;
-  }
-  return { cwd: process.cwd(), env: forwarded };
+  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"),
+    capabilities: { installDecisionTool: true }
+  });
+}
+function requireContext(context) {
+  if (!context)
+    throw new DaemonRequestError("daemon tool context is required", false);
+  return parseLspRequestContext(context);
 }
 function withContext(args, context) {
-  if (!context || context.cwd === undefined && context.env === undefined)
-    return args;
   return { ...args, [CONTEXT_KEY]: context };
 }
 function daemonUnreachableResult(paths, error) {
@@ -3680,39 +5677,84 @@ function daemonUnreachableResult(paths, error) {
 `);
   return { content: [{ type: "text", text: text2 }], isError: true };
 }
-function sendToolCall(socketPath, name, args, timeoutMs) {
-  return new Promise((resolve6, reject) => {
-    const socket = connect2(socketPath);
+function sendToolCall(paths, token, name, args, options) {
+  return new Promise((resolve9, reject) => {
+    const socket = connect2(paths.socket);
+    const requestId = allocateProxyRequestId();
     let settled = false;
     let requestWritten = false;
+    let cancelAfterWrite = false;
+    const cancelPayload = () => encodeJsonLine({
+      jsonrpc: "2.0",
+      method: "$/cancelRequest",
+      params: { _omo: authEnvelope(token), id: requestId }
+    });
     const finish = (run) => {
       if (settled)
         return;
       settled = true;
       clearTimeout(timer);
-      socket.destroy();
+      options.signal?.removeEventListener("abort", onAbort);
+      destroyAfterCancel();
       run();
     };
-    const timer = setTimeout(() => finish(() => reject(new DaemonRequestError("daemon request timed out", requestWritten))), timeoutMs);
+    const sendCancel = () => {
+      if (!requestWritten) {
+        cancelAfterWrite = true;
+        return;
+      }
+      if (!socket.writable)
+        return;
+      socket.write(cancelPayload());
+    };
+    const destroyAfterCancel = () => {
+      socket.destroy();
+    };
+    const onAbort = () => {
+      sendCancel();
+      finish(() => reject(new DaemonRequestCancelledError(requestWritten)));
+    };
+    const timer = setTimeout(() => {
+      sendCancel();
+      finish(() => reject(new DaemonRequestError("daemon request timed out", requestWritten)));
+    }, options.timeoutMs);
     timer.unref();
+    if (options.signal?.aborted) {
+      onAbort();
+      return;
+    }
+    options.signal?.addEventListener("abort", onAbort, { once: true });
     const decoder = createLineDecoder((message) => {
-      const result = toToolResult(message);
+      if (isAuthErrorResponse(message)) {
+        finish(() => reject(new DaemonAuthenticationRejectedError));
+        return;
+      }
+      const result = toToolResult(message, requestId);
       if (result)
-        finish(() => resolve6(result));
+        finish(() => resolve9(result));
       else
         finish(() => reject(new DaemonRequestError("invalid daemon response", requestWritten)));
     });
     socket.once("connect", () => {
-      requestWritten = true;
-      socket.write(encodeJsonLine({ jsonrpc: "2.0", id: REQUEST_ID, method: "tools/call", params: { name, arguments: args } }));
+      const payload = encodeJsonLine({
+        jsonrpc: "2.0",
+        id: requestId,
+        method: "tools/call",
+        params: { _omo: authEnvelope(token), name, arguments: args }
+      });
+      socket.write(payload, () => {
+        requestWritten = true;
+        if (cancelAfterWrite && socket.writable)
+          socket.write(cancelPayload());
+      });
     });
     socket.on("data", (chunk) => decoder.push(chunk));
     socket.once("error", (error) => finish(() => reject(new DaemonRequestError(error.message, requestWritten))));
     socket.once("close", () => finish(() => reject(new DaemonRequestError("daemon connection closed", requestWritten))));
   });
 }
-function toToolResult(message) {
-  if (!isPlainRecord(message) || message["id"] !== REQUEST_ID)
+function toToolResult(message, requestId) {
+  if (!isPlainRecord(message) || message["id"] !== requestId)
     return null;
   const result = message["result"];
   if (!isPlainRecord(result) || !Array.isArray(result["content"]))
@@ -3723,21 +5765,41 @@ function toToolResult(message) {
     details: result["details"]
   };
 }
+function allocateProxyRequestId() {
+  const id = nextProxyRequestId;
+  nextProxyRequestId += 1;
+  if (nextProxyRequestId > Number.MAX_SAFE_INTEGER)
+    nextProxyRequestId = 1;
+  return id;
+}
+function isRetryableTool(name) {
+  return name !== "rename" && name !== "lsp_rename";
+}
 function errorText(error) {
   return error instanceof Error ? error.message : String(error);
 }
 // src/proxy.ts
+import { existsSync as existsSync11, realpathSync as realpathSync4 } from "node:fs";
+import { basename as basename3, delimiter as delimiter4, dirname as dirname9, isAbsolute as isAbsolute4 } from "node:path";
 async function runMcpStdioProxy(options = {}) {
   const input = options.input ?? process.stdin;
   const output = options.output ?? process.stdout;
   const paths = options.paths ?? daemonPaths();
-  const context = options.context ?? currentRequestContext();
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? inferOpenCodeProjectCwd(env["LSP_TOOLS_MCP_PROJECT_CONFIG"]);
+  const contextEnv = cwd === undefined ? env : canonicalizeContextEnv(env);
+  const contextInput = {
+    env: contextEnv,
+    ...cwd === undefined ? {} : { cwd },
+    ...options.homeDir === undefined ? {} : { homeDir: options.homeDir }
+  };
+  const context = options.context ?? createStandaloneMcpRequestContext(contextInput);
   const callOptions = { paths, context, ...options.ensure ? { ensure: options.ensure } : {} };
   await runJsonRpcStdioServer({
     input,
     output,
     idleTimeoutMs: 0,
-    handler: handleProxyRequest,
+    handler: (request, requestOptions) => runWithRequestContext(context, () => handleProxyRequest(request, requestOptions)),
     handlerOptions: callOptions,
     onHandlerError: (error) => {
       process.stderr.write(`[lsp-daemon] proxy error: ${error instanceof Error ? error.message : String(error)}
@@ -3759,14 +5821,60 @@ 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)
+    return;
+  for (const entry of projectConfigEnv.split(delimiter4)) {
+    const projectRoot = projectRootFromOpenCodeConfigPath(entry);
+    if (projectRoot)
+      return projectRoot;
+  }
+  return;
+}
+function canonicalizeContextEnv(env) {
+  return {
+    ...env,
+    LSP_TOOLS_MCP_PROJECT_CONFIG: canonicalizePathList(env["LSP_TOOLS_MCP_PROJECT_CONFIG"]),
+    LSP_TOOLS_MCP_USER_CONFIG: canonicalizePath(env["LSP_TOOLS_MCP_USER_CONFIG"]),
+    LSP_TOOLS_MCP_INSTALL_DECISIONS: canonicalizePath(env["LSP_TOOLS_MCP_INSTALL_DECISIONS"])
+  };
+}
+function canonicalizePathList(value) {
+  if (value === undefined)
+    return;
+  return value.split(delimiter4).map((entry) => canonicalizePath(entry) ?? entry).join(delimiter4);
+}
+function canonicalizePath(value) {
+  if (value === undefined || !isAbsolute4(value) || !existsSync11(value))
+    return value;
+  return realpathSync4(value);
+}
+function projectRootFromOpenCodeConfigPath(path2) {
+  if (basename3(path2) !== "lsp.json" && basename3(path2) !== "lsp-client.json")
+    return;
+  const configDir = dirname9(path2);
+  const configDirName = basename3(configDir);
+  if (configDirName !== ".opencode" && configDirName !== ".omo")
+    return;
+  return dirname9(configDir);
 }
 export {
+  validateDaemonVersion,
   runMcpStdioProxy,
+  resolveDaemonRuntime,
+  probeDaemon,
   ensureDaemonRunning,
   disposeDefaultLspManager,
   daemonPaths,
   currentRequestContext,
   callToolViaDaemon,
-  callDiagnosticsViaDaemon
+  callDiagnosticsViaDaemon,
+  OMO_LSP_DAEMON_VERSION,
+  OMO_LSP_DAEMON_DIR,
+  OMO_LSP_DAEMON_CLI,
+  InvalidRuntimeOverrideError,
+  InvalidDaemonVersionError,
+  InvalidDaemonDirectoryError
 };