oh-my-opencode 4.18.0 → 4.18.2

package/packages/omo-codex/plugin/components/lsp/dist/cli.js

@@ -1,80 +1,603 @@
 #!/usr/bin/env node
 
-// components/lsp/src/cli.ts
+// src/cli.ts
 import { spawn as spawn3 } from "node:child_process";
 import { argv, execPath as execPath2, stderr } from "node:process";
 
-// components/lsp/src/codex-hook-cli.ts
+// src/codex-hook-cli.ts
 import { stdin as processStdin } from "node:process";
 
-// ../../lsp-daemon/dist/index.js
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { pathToFileURL } from "node:url";
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
-import { delimiter, join } from "node:path";
-import { basename, extname } from "node:path";
-import { connect as connect2 } from "node:net";
-import { spawn as spawn2 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
+// src/codex-hook.ts
+import { readFileSync as readFileSync9, realpathSync as realpathSync6 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join11, resolve as resolve11 } from "node:path";
+
+// ../../../../lsp-daemon/dist/client.js
 import { connect } from "node:net";
-import { dirname as dirname2 } from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
+import { Socket } from "node:net";
+import { dirname as dirname3 } from "node:path";
 import { execPath } from "node:process";
-import { fileURLToPath } from "node:url";
-import { closeSync, mkdirSync, openSync, readFileSync as readFileSync2, unlinkSync, writeSync } from "node:fs";
-import { dirname } from "node:path";
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  fchmodSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
 import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
-import { homedir, tmpdir } from "node:os";
-import { join as join2 } from "node:path";
-import { resolve as resolve4 } from "node:path";
-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 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 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 existsSync5 } from "node:fs";
-import { delimiter as delimiter3, join as join5 } from "node:path";
-import { existsSync as existsSync7, lstatSync, readdirSync } from "node:fs";
-import { join as join7, resolve as resolve3 } from "node:path";
+import { homedir as homedir2, tmpdir, userInfo } from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { statSync as statSync2 } from "node:fs";
+import { isAbsolute as isAbsolute2 } 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";
+import { basename as basename2, extname } from "node:path";
+import { resolve as resolve6 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+import { pathToFileURL } from "node:url";
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import { existsSync as existsSync2, statSync as statSync3 } from "node:fs";
+import { delimiter as delimiter2, join as join2 } from "node:path";
+import { readFileSync as readFileSync2, realpathSync as realpathSync2 } from "node:fs";
+import { relative as relative2, resolve as resolve2 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { existsSync as existsSync4, lstatSync as lstatSync3, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync3, lstatSync as lstatSync2, readFileSync as readFileSync3, readdirSync, realpathSync as realpathSync3 } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { lstatSync as lstatSync2, readdirSync as readdirSync2 } from "node:fs";
-import { join as join8 } from "node:path";
-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 { createHash as createHash2 } from "node:crypto";
+import { dirname as dirname5, relative as relative4, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync5, lstatSync as lstatSync4, readdirSync as readdirSync2 } from "node:fs";
+import { dirname as dirname6, resolve as resolve5 } 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";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
+import { delimiter as delimiter3, join as join3 } 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";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-function reportBestEffortCleanupError(operation, error) {
-  if (process.env["CODEX_LSP_DEBUG_CLEANUP"] !== "1")
-    return;
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`[codex-lsp] ignored ${operation} failure during cleanup: ${message}`);
+import { lstatSync as lstatSync6, readdirSync as readdirSync4 } from "node:fs";
+import { join as join6 } from "node:path";
+import { statSync as statSync5 } from "node:fs";
+import { isAbsolute as isAbsolute4 } 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 lspRequestContext() {
+  const context = storage.getStore();
+  if (!context)
+    throw new LspRequestContextUnavailableError;
+  return context;
+}
 function contextCwd() {
-  return storage.getStore()?.cwd ?? process.cwd();
+  return lspRequestContext().cwd;
+}
+function parseLspRequestContext(value) {
+  if (!isRecord(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 path2 of projectConfigPaths) {
+    requireAbsolutePath(path2, "projectConfigPaths");
+    const projectPath = canonicalizeExistingOrNearestAncestor(path2);
+    if (!isPathInside(canonical, projectPath)) {
+      throw new LspRequestContextParseError("project_config_outside_cwd", `Project LSP config path must be inside cwd: ${path2}`);
+    }
+  }
+  requireAbsolutePath(userConfigPath, "userConfigPath");
+  requireAbsolutePath(installDecisionsPath, "installDecisionsPath");
+  return {
+    cwd: canonical,
+    projectConfigPaths: projectConfigPaths.map((path2) => canonicalizeExistingOrNearestAncestor(path2)),
+    userConfigPath,
+    installDecisionsPath,
+    capabilities
+  };
 }
-function contextEnv(key) {
-  const store = storage.getStore();
-  if (store?.env)
-    return store.env[key];
-  return process.env[key];
+function canonicalCwd(cwd) {
+  const resolved = resolve(cwd);
+  if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+    throw new LspRequestContextParseError("invalid_cwd", `LSP request cwd must be an existing directory: ${cwd}`);
+  }
+  return realpathSync(resolved);
+}
+function canonicalizeExistingOrNearestAncestor(path2) {
+  let current = resolve(path2);
+  const suffix = [];
+  while (true) {
+    try {
+      const existing = realpathSync(current);
+      return suffix.length === 0 ? existing : join(existing, ...suffix);
+    } catch (error) {
+      if (!isMissingPathError(error))
+        throw error;
+      const parent = dirname(current);
+      if (parent === current)
+        throw error;
+      suffix.unshift(basename(current));
+      current = parent;
+    }
+  }
+}
+function capabilitiesField(value) {
+  if (!isRecord(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(path2, field) {
+  if (!isAbsolute(path2)) {
+    throw new LspRequestContextParseError("relative_path", `LSP request context.${field} must be absolute: ${path2}`);
+  }
+}
+function isPathInside(parent, child) {
+  const childPath = resolve(child);
+  const relativePath = relative(parent, childPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(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 isRecord(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;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var OMO_DAEMON_PROTOCOL_VERSION = 1;
+var AUTH_ERROR_CODE = -32001;
+function authEnvelope(token) {
+  return { protocolVersion: OMO_DAEMON_PROTOCOL_VERSION, token };
+}
+function readAuthToken(paths) {
+  try {
+    const token = readFileSync(paths.auth, "utf8").trim();
+    return token.length > 0 ? token : null;
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+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";
+}
+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;
+  }
+}
+
+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 (!isAbsolute2(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 (!isAbsolute2(cliOverride)) {
+    throw new InvalidRuntimeOverrideError("cli_must_be_absolute", `${OMO_LSP_DAEMON_CLI} must be an absolute path to an existing regular file`);
+  }
+  let cliStats;
+  try {
+    cliStats = statSync2(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) };
+}
+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: fileURLToPath(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 createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+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(`
+`);
+      }
+    }
+  };
+}
+var PROBE_TIMEOUT_MS = 500;
+var DEFAULT_READY_TIMEOUT_MS = 5000;
+var DEFAULT_POLL_INTERVAL_MS = 100;
+
+class DaemonUnreachableError extends Error {
+  constructor(socketPath) {
+    super(`LSP daemon did not become reachable at ${socketPath}`);
+    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;
+  const signal = options.signal;
+  throwIfAborted(signal);
+  if (await awaitWithSignal(deps.probe(paths, signal), signal))
+    return;
+  throwIfAborted(signal);
+  deps.spawnDaemon(paths);
+  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal);
+}
+async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal) {
+  const deadline = deps.now() + readyTimeoutMs;
+  for (;; ) {
+    throwIfAborted(signal);
+    if (await awaitWithSignal(deps.probe(paths, signal), signal))
+      return;
+    if (deps.now() >= deadline)
+      throw new DaemonUnreachableError(paths.socket);
+    await awaitWithSignal(deps.sleep(pollIntervalMs, signal), signal);
+  }
+}
+async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS, signal) {
+  const token = readAuthToken(paths);
+  if (!token)
+    return false;
+  return await pingDaemon(paths, token, timeoutMs, signal) !== null;
+}
+function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
+  return new Promise((resolve22) => {
+    const socket = new Socket;
+    let settled = false;
+    let timer;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      socket.destroy();
+      resolve22(value);
+    };
+    const onAbort = () => finish(null);
+    const decoder = createLineDecoder((message) => {
+      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", () => {
+      finish(null);
+    });
+    timer = setTimeout(() => finish(null), timeoutMs);
+    timer.unref?.();
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    socket.connect(paths.socket);
+  });
+}
+function spawnDaemonProcess(paths) {
+  mkdirSync2(dirname3(paths.log), { recursive: true });
+  const logFd = openSync2(paths.log, "a");
+  try {
+    const child = spawn(execPath, [paths.cliPath, "daemon"], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd]
+    });
+    child.unref();
+  } finally {
+    closeSync2(logFd);
+  }
+}
+function defaultEnsureDaemonDeps() {
+  return {
+    probe: (paths, signal) => probeDaemon(paths, PROBE_TIMEOUT_MS, signal),
+    spawnDaemon: (paths) => spawnDaemonProcess(paths),
+    sleep: (ms, signal) => sleepWithSignal(ms, signal),
+    now: () => Date.now()
+  };
+}
+function sleepWithSignal(ms, signal) {
+  return new Promise((resolve22) => {
+    let settled = false;
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", finish);
+      resolve22();
+    };
+    const timer = setTimeout(finish, ms);
+    if (signal?.aborted) {
+      finish();
+      return;
+    }
+    signal?.addEventListener("abort", finish, { once: true });
+  });
+}
+function awaitWithSignal(promise, signal) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    return Promise.reject(abortError(signal));
+  return new Promise((resolve22, reject) => {
+    let settled = false;
+    const finish = (run) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      run();
+    };
+    const onAbort = () => finish(() => reject(abortError(signal)));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then((value) => finish(() => resolve22(value)), (error) => finish(() => reject(error)));
+  });
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw abortError(signal);
+}
+function abortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error)
+    return reason;
+  const error = new Error(typeof reason === "string" ? reason : "daemon startup cancelled");
+  error.name = "AbortError";
+  return error;
+}
+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 } };
+  }
+  return null;
+}
+var HEADER_SEPARATOR = Buffer.from(`\r
+\r
+`);
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60000;
+var BASENAME_EXTENSIONS = {
+  Dockerfile: ".dockerfile",
+  Containerfile: ".dockerfile"
+};
+function effectiveExtension(filePath) {
+  return BASENAME_EXTENSIONS[basename2(filePath)] ?? extname(filePath);
 }
-var DEFAULT_MAX_REFERENCES = 200;
-var DEFAULT_MAX_SYMBOLS = 200;
-var DEFAULT_MAX_DIAGNOSTICS = 200;
-var DEFAULT_MAX_DIRECTORY_FILES = 50;
-var REQUEST_TIMEOUT_MS = 15000;
-var INIT_TIMEOUT_MS = 60000;
-var IDLE_TIMEOUT_MS = 5 * 60000;
-var REAPER_INTERVAL_MS = 60000;
-var STOP_HARD_KILL_TIMEOUT_MS = 5000;
-var STOP_SIGKILL_GRACE_MS = 1000;
 
 class LspConnectionClosedError extends Error {
   serverId;
@@ -122,7 +645,12 @@ class LspInvalidPathError extends Error {
 }
 
 class LspServerLookupError extends Error {
+  lookup;
   name = "LspServerLookupError";
+  constructor(message, lookup) {
+    super(message);
+    this.lookup = lookup;
+  }
 }
 
 class LspServerInitializingError extends Error {
@@ -140,7 +668,25 @@ class LspProcessSpawnError extends Error {
 function isLspDeadConnectionError(err) {
   return err instanceof LspConnectionClosedError || err instanceof LspProcessExitedError;
 }
-var HEADER_SEPARATOR = `\r
+function writeCleanupError(message) {
+  process.stderr.write(`${message}
+`);
+}
+function reportBestEffortCleanupError(operation, error, logger = writeCleanupError) {
+  const message = error instanceof Error ? error.message : String(error);
+  logger(`[lsp] ignored ${operation} failure during cleanup: ${message}`);
+}
+var DEFAULT_MAX_REFERENCES = 200;
+var DEFAULT_MAX_SYMBOLS = 200;
+var DEFAULT_MAX_DIAGNOSTICS = 200;
+var DEFAULT_MAX_DIRECTORY_FILES = 50;
+var REQUEST_TIMEOUT_MS = 15000;
+var INIT_TIMEOUT_MS = 60000;
+var IDLE_TIMEOUT_MS = 5 * 60000;
+var REAPER_INTERVAL_MS = 60000;
+var STOP_HARD_KILL_TIMEOUT_MS = 5000;
+var STOP_SIGKILL_GRACE_MS = 1000;
+var HEADER_SEPARATOR2 = `\r
 \r
 `;
 var PARSE_ERROR = -32700;
@@ -186,28 +732,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 };
-    const responsePromise = new Promise((resolve6, reject) => {
-      this.pendingRequests.set(String(id), {
+    let requestWritten = false;
+    let cancelAfterWrite = false;
+    let settled = false;
+    const writeCancel = () => this.writeMessage({ jsonrpc: "2.0", method: "$/cancelRequest", params: { id } });
+    const responsePromise = new Promise((resolve22, reject) => {
+      const cleanup = () => {
+        options.signal?.removeEventListener("abort", onAbort);
+      };
+      const settleCancel = () => {
+        if (settled)
+          return;
+        settled = true;
+        this.pendingRequests.delete(key);
+        cleanup();
+        const rejectCancelled = () => reject(abortError2(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) {
-          resolve6(result);
+          settled = true;
+          cleanup();
+          resolve22(result);
+        },
+        reject(error) {
+          settled = true;
+          cleanup();
+          reject(error);
         },
-        reject
+        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;
@@ -224,6 +822,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();
@@ -245,17 +844,17 @@ class JsonRpcConnection {
   };
   drainInputBuffer() {
     while (true) {
-      const headerEnd = this.inputBuffer.indexOf(HEADER_SEPARATOR);
+      const headerEnd = this.inputBuffer.indexOf(HEADER_SEPARATOR2);
       if (headerEnd === -1)
         return;
       const headers = this.inputBuffer.subarray(0, headerEnd).toString("ascii");
-      const contentLength = parseContentLength(headers);
+      const contentLength = parseContentLength2(headers);
       if (contentLength === null) {
         this.inputBuffer = Buffer.alloc(0);
         this.emitError(new Error("JSON-RPC message is missing Content-Length header"));
         return;
       }
-      const bodyStart = headerEnd + Buffer.byteLength(HEADER_SEPARATOR);
+      const bodyStart = headerEnd + Buffer.byteLength(HEADER_SEPARATOR2);
       const bodyEnd = bodyStart + contentLength;
       if (this.inputBuffer.length < bodyEnd)
         return;
@@ -299,6 +898,7 @@ class JsonRpcConnection {
     if (!pending)
       return;
     this.pendingRequests.delete(String(id));
+    pending.cleanup();
     if ("error" in message) {
       pending.reject(jsonRpcErrorToError(message["error"]));
       return;
@@ -312,7 +912,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) {
@@ -337,13 +941,13 @@ class JsonRpcConnection {
     const payload = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
 \r
 ${body}`;
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve22, reject) => {
       this.writer.write(payload, (error) => {
         if (error) {
           reject(error);
           return;
         }
-        resolve6();
+        resolve22();
       });
     });
   }
@@ -353,7 +957,15 @@ ${body}`;
     }
   }
 }
-function parseContentLength(headers) {
+function abortError2(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 parseContentLength2(headers) {
   for (const line of headers.split(`\r
 `)) {
     const separatorIndex = line.indexOf(":");
@@ -401,10 +1013,10 @@ function reportKillError(context, error) {
 }
 function validateCwd(cwd) {
   try {
-    if (!existsSync(cwd)) {
+    if (!existsSync2(cwd)) {
       return { valid: false, error: `Working directory does not exist: ${cwd}` };
     }
-    const stats = statSync(cwd);
+    const stats = statSync3(cwd);
     if (!stats.isDirectory()) {
       return { valid: false, error: `Path is not a directory: ${cwd}` };
     }
@@ -417,9 +1029,9 @@ function validateCwd(cwd) {
   }
 }
 function wrap(proc) {
-  const exitedPromise = new Promise((resolve6) => {
-    proc.once("close", (code) => resolve6(code ?? 0));
-    proc.once("error", () => resolve6(1));
+  const exitedPromise = new Promise((resolve22) => {
+    proc.once("close", (code) => resolve22(code ?? 0));
+    proc.once("error", () => resolve22(1));
   });
   if (!proc.stdin || !proc.stdout || !proc.stderr) {
     throw new LspProcessSpawnError("Spawned process is missing one of stdin/stdout/stderr pipes");
@@ -473,7 +1085,7 @@ function isWindowsShellShim(command) {
   return lowerCommand.endsWith(".cmd") || lowerCommand.endsWith(".bat");
 }
 function splitPath(pathValue, platform) {
-  const separator = platform === "win32" ? ";" : delimiter;
+  const separator = platform === "win32" ? ";" : delimiter2;
   return pathValue.split(separator).filter(Boolean);
 }
 function getWindowsPathExtensions(env) {
@@ -488,8 +1100,8 @@ function resolveWindowsCommand(command, env) {
   const extensions = getWindowsPathExtensions(env);
   for (const baseDirectory of baseDirectories) {
     for (const extension of extensions) {
-      const candidate = baseDirectory ? join(baseDirectory, `${command}${extension}`) : `${command}${extension}`;
-      if (existsSync(candidate))
+      const candidate = baseDirectory ? join2(baseDirectory, `${command}${extension}`) : `${command}${extension}`;
+      if (existsSync2(candidate))
         return candidate;
     }
   }
@@ -523,7 +1135,7 @@ function spawnProcess(command, options) {
     throw new LspProcessSpawnError("[lsp] empty command");
   }
   const preparedCommand = createSpawnCommand(command, process.platform, process.env["ComSpec"] ?? "cmd.exe", options.env);
-  const proc = spawn(preparedCommand.command, preparedCommand.args, {
+  const proc = spawn2(preparedCommand.command, preparedCommand.args, {
     cwd: options.cwd,
     env: options.env,
     stdio: ["pipe", "pipe", "pipe"],
@@ -533,15 +1145,15 @@ function spawnProcess(command, options) {
   });
   return wrap(proc);
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseConfigurationItems(params) {
-  if (!isRecord(params) || !Array.isArray(params["items"]))
+  if (!isRecord2(params) || !Array.isArray(params["items"]))
     return [];
   const items = [];
   for (const item of params["items"]) {
-    if (!isRecord(item))
+    if (!isRecord2(item))
       continue;
     const section = item["section"];
     items.push(section === undefined || typeof section !== "string" ? {} : { section });
@@ -549,10 +1161,34 @@ function parseConfigurationItems(params) {
   return items;
 }
 function parseDiagnosticsParams(params) {
-  if (!isRecord(params) || typeof params["uri"] !== "string")
+  if (!isRecord2(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 isRecord2(value) && isRange(value["range"]) && typeof value["message"] === "string";
+}
+function isRange(value) {
+  return isRecord2(value) && isPosition(value["start"]) && isPosition(value["end"]);
+}
+function isPosition(value) {
+  return isRecord2(value) && typeof value["line"] === "number" && typeof value["character"] === "number";
+}
+
+class LspClientNotStartedError extends Error {
+  serverId;
+  root;
+  name = "LspClientNotStartedError";
+  constructor(serverId, root) {
+    super("LSP client not started");
+    this.serverId = serverId;
+    this.root = root;
+  }
 }
 
 class LspClientTransport {
@@ -565,9 +1201,11 @@ class LspClientTransport {
   diagnosticsStore = new Map;
   requestTimeoutMs;
   initializeTimeoutMs;
-  constructor(root, server, timeouts = {}) {
+  workspaceApplyEditHandler = null;
+  diagnosticPullSupported = false;
+  constructor(root, server2, timeouts = {}) {
     this.root = root;
-    this.server = server;
+    this.server = server2;
     this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
     this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
   }
@@ -577,6 +1215,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,
@@ -587,7 +1240,6 @@ class LspClientTransport {
       env
     });
     this.startStderrReading();
-    await new Promise((resolve6) => setTimeout(resolve6, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -597,7 +1249,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) => {
@@ -610,6 +1262,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;
     });
@@ -638,30 +1293,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);
@@ -670,6 +1320,9 @@ class LspClientTransport {
         throw new LspConnectionClosedError(this.server.id, this.root, error.message);
       }
       throw error;
+    } finally {
+      clearTimeout(timeoutHandle);
+      combinedSignal.dispose();
     }
   }
   async sendNotification(method, ...args) {
@@ -698,17 +1351,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;
     }
@@ -719,8 +1372,8 @@ class LspClientTransport {
       try {
         proc.kill();
         let timeoutId;
-        const timeoutPromise = new Promise((resolve6) => {
-          timeoutId = setTimeout(resolve6, STOP_HARD_KILL_TIMEOUT_MS);
+        const timeoutPromise = new Promise((resolve22) => {
+          timeoutId = setTimeout(resolve22, STOP_HARD_KILL_TIMEOUT_MS);
         });
         await Promise.race([
           proc.exited.then(() => {
@@ -736,14 +1389,14 @@ class LspClientTransport {
             proc.kill("SIGKILL");
             await Promise.race([
               proc.exited,
-              new Promise((resolve6) => setTimeout(resolve6, STOP_SIGKILL_GRACE_MS))
+              new Promise((resolve22) => setTimeout(resolve22, 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;
@@ -753,24 +1406,43 @@ 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 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);
+    }
+  };
 }
-function isPosition(value) {
-  return isRecord(value) && typeof value["line"] === "number" && typeof value["character"] === "number";
+function supportsDiagnosticPull(capabilities) {
+  if (capabilities === undefined)
+    return false;
+  return Object.hasOwn(capabilities, "diagnosticProvider");
 }
-var INITIALIZE_SETTLE_MS = 300;
 
 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,
@@ -784,8 +1456,7 @@ class LspClientConnection extends LspClientTransport {
           publishDiagnostics: {},
           rename: {
             prepareSupport: true,
-            prepareSupportDefaultBehavior: 1,
-            honorsChangeAnnotations: true
+            prepareSupportDefaultBehavior: 1
           },
           codeAction: {
             codeActionLiteralSupport: {
@@ -814,28 +1485,22 @@ 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));
   }
 }
-var BASENAME_EXTENSIONS = {
-  Dockerfile: ".dockerfile",
-  Containerfile: ".dockerfile"
-};
-function effectiveExtension(filePath) {
-  return BASENAME_EXTENSIONS[basename(filePath)] ?? extname(filePath);
-}
 var SYMBOL_KIND_MAP = {
   1: "File",
   2: "Module",
@@ -1006,81 +1671,1384 @@ var EXT_TO_LANG = {
 function getLanguageId(ext) {
   return EXT_TO_LANG[ext] ?? "plaintext";
 }
-var POST_OPEN_DELAY_MS = 1000;
-var POST_DIAGNOSTICS_WAIT_MS = 500;
+var WATCHED_FILE_BATCH_SIZE = 128;
+var DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
+function canonicalPath(filePath) {
+  const absolute = resolve2(filePath);
+  try {
+    return realpathSync2(absolute);
+  } catch {
+    return absolute;
+  }
+}
+function isSameOrDescendant(candidate, parent) {
+  const suffix = relative2(parent, candidate);
+  return suffix === "" || !suffix.startsWith("..") && suffix !== "..";
+}
+function movedPath(candidate, oldPath, newPath) {
+  const suffix = relative2(oldPath, candidate);
+  return suffix === "" ? newPath : resolve2(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
+    const path2 = canonicalPath(filePath);
+    const existingOpen = this.openPromises.get(path2);
+    if (existingOpen) {
+      await existingOpen;
+      return this.openFile(path2);
+    }
+    const text = readFileSync2(path2, "utf-8");
+    const existing = this.openDocuments.get(path2);
+    if (!existing)
+      return this.openDocumentSingleFlight(path2, text);
+    if (existing.text === text)
+      return;
+    await this.changeDocument(existing, text);
+  }
+  getVersion(filePath) {
+    return this.openDocuments.get(canonicalPath(filePath))?.version;
+  }
+  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
+    };
+  }
+  isCurrentSnapshot(snapshot) {
+    const state = this.openDocuments.get(snapshot.path);
+    return state !== undefined && state.uri === snapshot.uri && state.version === snapshot.version && state.generation === snapshot.documentGeneration;
+  }
+  getPullCache(snapshot) {
+    const state = this.openByUri.get(snapshot.uri);
+    if (!state?.pullCache || state.pullCache.documentVersion !== snapshot.version)
+      return null;
+    return state.pullCache;
+  }
+  recordPullDiagnostics(snapshot, report) {
+    const state = this.openByUri.get(snapshot.uri);
+    if (!state)
+      return;
+    state.pullCache = {
+      documentVersion: snapshot.version,
+      diagnostics: [...report.diagnostics],
+      ...report.resultId === undefined ? {} : { resultId: report.resultId }
+    };
+  }
+  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(([path2, state]) => [path2, 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;
+      }
+      if (operation.kind === "rename") {
+        const moved = [...versions].filter(([path2]) => isSameOrDescendant(path2, operation.oldPath));
+        for (const [path2] of moved)
+          versions.delete(path2);
+        for (const [path2] of moved)
+          versions.set(movedPath(path2, operation.oldPath, operation.newPath), 1);
+        continue;
+      }
+      if (operation.kind === "delete") {
+        for (const path2 of [...versions.keys()]) {
+          if (isSameOrDescendant(path2, operation.path))
+            versions.delete(path2);
         }
+        continue;
+      }
+      if (operation.kind === "create" && operation.replaced && versions.has(operation.path)) {
+        versions.set(operation.path, 1);
+      }
+    }
+    return null;
+  }
+  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)
       });
-      this.openedFiles.add(absPath);
-      this.documentVersions.set(uri, version);
-      this.lastSyncedText.set(uri, text);
-      await new Promise((r) => setTimeout(r, POST_OPEN_DELAY_MS));
+    }
+  }
+  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, readFileSync2(mutation.path, "utf-8"));
+      } else {
+        watched.push({ uri: pathToFileURL2(mutation.path).href, type: mutation.replaced ? 2 : 1 });
+      }
       return;
     }
-    const prevText = this.lastSyncedText.get(uri);
-    if (prevText === text) {
+    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 path2 = movedPath(state.path, mutation.oldPath, mutation.newPath);
+        await this.openDocumentSingleFlight(path2, readFileSync2(path2, "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 nextVersion = (this.documentVersions.get(uri) ?? 1) + 1;
-    this.documentVersions.set(uri, nextVersion);
-    this.lastSyncedText.set(uri, text);
+    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(path2, text) {
+    const existing = this.openPromises.get(path2);
+    if (existing)
+      return existing;
+    const open = (async () => {
+      const state = {
+        path: path2,
+        uri: pathToFileURL2(path2).href,
+        languageId: getLanguageId(effectiveExtension(path2)),
+        text,
+        version: 1,
+        generation: 1,
+        publishGeneration: 0,
+        waiters: new Set
+      };
+      this.openDocuments.set(path2, 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(path2);
+    });
+    this.openPromises.set(path2, 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, version: nextVersion },
+      textDocument: { uri: state.uri, version: state.version },
       contentChanges: [{ text }]
     });
-    await this.sendNotification("textDocument/didSave", {
-      textDocument: { uri },
-      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();
+  }
+}
+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];
+}
+
+class WorkspaceEditPathError extends Error {
+  path;
+  detail;
+  name = "WorkspaceEditPathError";
+  constructor(path2, detail) {
+    super(`${detail}: ${path2}`);
+    this.path = path2;
+    this.detail = detail;
+  }
+}
+function isPathInsideWorkspace(filePath, workspaceRoot) {
+  const relativePath = relative3(workspaceRoot, filePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute3(relativePath);
+}
+function canonicalizeMissingPath(filePath) {
+  let ancestor = filePath;
+  while (!existsSync3(ancestor)) {
+    const parent = dirname4(ancestor);
+    if (parent === ancestor)
+      throw new WorkspaceEditPathError(filePath, "no existing ancestor");
+    ancestor = parent;
+  }
+  return resolve3(realpathSync3(ancestor), relative3(ancestor, filePath));
+}
+function canonicalWorkspaceRoot(workspaceRoot) {
+  try {
+    const canonical = realpathSync3(resolve3(workspaceRoot));
+    if (!lstatSync2(canonical).isDirectory()) {
+      return { success: false, error: `workspace root is not a directory: ${workspaceRoot}` };
+    }
+    return {
+      success: true,
+      path: canonical,
+      requestedPath: resolve3(workspaceRoot),
+      followedSymbolicLink: existsSync3(resolve3(workspaceRoot)) && lstatSync2(resolve3(workspaceRoot)).isSymbolicLink()
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `workspace root ${workspaceRoot}: ${detail}` };
+  }
+}
+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}` };
+    }
+    requestedPath = resolve3(fileURLToPath2(parsed));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `non-file URI ${uri}: ${detail}` };
+  }
+  try {
+    const canonical = existsSync3(requestedPath) ? realpathSync3(requestedPath) : canonicalizeMissingPath(requestedPath);
+    if (!isPathInsideWorkspace(canonical, workspaceRoot)) {
+      return { success: false, error: `${requestedPath}: outside workspace ${workspaceRoot}` };
+    }
+    return {
+      success: true,
+      path: canonical,
+      requestedPath,
+      followedSymbolicLink: existsSync3(requestedPath) && lstatSync2(requestedPath).isSymbolicLink()
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `${requestedPath}: ${detail}` };
+  }
+}
+function snapshotPath(path2, includeChildren) {
+  if (!existsSync3(path2))
+    return { kind: "missing" };
+  const stats = lstatSync2(path2);
+  if (stats.isFile())
+    return { kind: "file", content: readFileSync3(path2, "utf-8") };
+  if (stats.isDirectory()) {
+    return includeChildren ? { kind: "directory", children: readdirSync(path2).sort() } : { kind: "directory" };
+  }
+  throw new WorkspaceEditPathError(path2, "unsupported filesystem entry");
+}
+var DEFAULT_IO = {
+  writeFile(path2, content) {
+    writeFileSync(path2, content, "utf-8");
+  },
+  rename(oldPath, newPath) {
+    renameSync(oldPath, newPath);
+  },
+  remove(path2, recursive) {
+    rmSync(path2, { 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(path2, expected) {
+  return snapshotPath(path2, 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 [path2, expected] of plan.snapshots) {
+    let actual;
+    try {
+      actual = liveSnapshot(path2, expected);
+    } catch (error) {
+      const changeIndex = plan.firstChangeByPath.get(path2) ?? firstOperationIndex(plan);
+      const detail = error instanceof Error ? error.message : String(error);
+      return failedCommit(plan, { message: `cannot verify snapshot for ${path2}: ${detail}`, changeIndex });
+    }
+    if (!snapshotsEqual(expected, actual)) {
+      const changeIndex = plan.firstChangeByPath.get(path2) ?? firstOperationIndex(plan);
+      return failedCommit(plan, { message: `workspace state changed before commit: ${path2}`, changeIndex });
+    }
+  }
+  return null;
+}
+function addModifiedPath(paths, path2) {
+  if (!paths.includes(path2))
+    paths.push(path2);
+}
+function reportedPath(plan, path2) {
+  return plan.reportedPathByCanonical.get(path2) ?? path2;
+}
+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 path2 of changedPathsForMutation(operation))
+      changedPaths.add(path2);
+  }
+  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 = existsSync4(operation.newPath) && lstatSync3(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 };
+}
+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 createHash2("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+
+class WorkspaceEditValidationError extends Error {
+  changeIndex;
+  detail;
+  name = "WorkspaceEditValidationError";
+  constructor(changeIndex, detail) {
+    super(`change ${changeIndex}: ${detail}`);
+    this.changeIndex = changeIndex;
+    this.detail = detail;
+  }
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsePosition(value) {
+  if (!isRecord3(value) || typeof value["line"] !== "number" || typeof value["character"] !== "number") {
+    return null;
+  }
+  return { line: value["line"], character: value["character"] };
+}
+function parseRange(value) {
+  if (!isRecord3(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 (!isRecord3(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 (!isRecord3(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;
+}
+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
+  });
+}
+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 (!isRecord3(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 (!isRecord3(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 (!isRecord3(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 (!isRecord3(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
+  });
+}
+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) };
+}
+function isSameOrDescendant2(candidate, parent) {
+  const relativePath = relative4(parent, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && relativePath !== "..";
+}
+function removeVirtualSubtree(virtual, path2) {
+  for (const candidate of [...virtual.keys()]) {
+    if (isSameOrDescendant2(candidate, path2))
+      virtual.delete(candidate);
+  }
+  virtual.set(path2, { 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 = relative4(oldPath, candidate);
+    virtual.set(suffix === "" ? newPath : resolve4(newPath, suffix), entry);
+  }
+}
+function virtualDirectoryHasChildren(virtual, path2) {
+  for (const [candidate, entry] of virtual) {
+    if (candidate !== path2 && entry.kind !== "missing" && isSameOrDescendant2(candidate, path2))
+      return true;
+  }
+  return false;
+}
+function requireVirtualParent(virtual, path2, changeIndex) {
+  if (virtual.get(dirname5(path2))?.kind !== "directory") {
+    throw new WorkspaceEditValidationError(changeIndex, `parent directory does not exist for ${path2}`);
+  }
+}
+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
+  };
+}
+
+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(path2, includeChildren) {
+    let candidate = path2;
+    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 === path2));
+      }
+      if (candidate === this.workspaceRoot)
+        break;
+      candidate = dirname6(candidate);
+    }
+    if (!includeChildren || !existsSync5(path2) || !lstatSync4(path2).isDirectory())
+      return;
+    for (const child of readdirSync2(path2))
+      this.add(resolve5(path2, child), true);
+  }
+}
+function snapshotOperations(operations, workspaceRoot) {
+  return new WorkspaceSnapshotBuilder(workspaceRoot).build(operations);
+}
+
+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(path2, reportedPath2, changeIndex) {
+    if (!this.firstChangeByPath.has(path2))
+      this.firstChangeByPath.set(path2, changeIndex);
+    if (!this.reportedPathByCanonical.has(path2))
+      this.reportedPathByCanonical.set(path2, 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 };
+}
+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 isRecord4(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((resolve62) => {
+      lease.resolveApply = resolve62;
+    });
+    const edit = isRecord4(params) ? params["edit"] : undefined;
+    const record2 = edit === undefined ? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) } : await this.applyEdit(edit, lease);
+    lease.serverApply = record2;
+    lease.phase = "settled";
+    lease.resolveApply?.();
+    return responseFor(record2.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(record2, edit) {
+    if (!edit)
+      return { edit, apply: record2.result };
+    const fingerprint = fingerprintWorkspaceEdit(edit, this.workspaceRoot);
+    if (fingerprint.success && record2.fingerprint !== null && fingerprint.fingerprint === record2.fingerprint) {
+      return { edit, apply: record2.result };
+    }
+    return {
+      edit,
+      apply: failure("rename result conflicts with server-applied workspace edit", 0, record2.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;
+  }
+}
+var DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3000;
+var VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
+
+class LspClient extends LspClientConnection {
+  diagnosticPullErrors = [];
+  documents;
+  workspaceMutations;
+  diagnosticsFreshnessTimeoutMs;
+  constructor(root, server2, options = {}) {
+    super(root, server2, options);
+    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));
   }
-  async definition(filePath, line, character) {
-    const absPath = resolve(contextCwd(), filePath);
+  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: pathToFileURL2(absPath).href },
+      textDocument: { uri: pathToFileURL3(absPath).href },
       position: { line: line - 1, character }
-    });
+    }, options);
   }
-  async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve(contextCwd(), filePath);
+  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: pathToFileURL2(absPath).href },
+      textDocument: { uri: pathToFileURL3(absPath).href },
       position: { line: line - 1, character },
       context: { includeDeclaration }
-    });
+    }, options);
   }
-  async documentSymbols(filePath) {
-    const absPath = resolve(contextCwd(), filePath);
+  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: pathToFileURL2(absPath).href }
-    });
+      textDocument: { uri: pathToFileURL3(absPath).href }
+    }, options);
   }
-  async workspaceSymbols(query) {
-    return this.sendRequest("workspace/symbol", { query });
+  async workspaceSymbols(query, signal) {
+    const options = signal === undefined ? {} : { signal };
+    return this.sendRequest("workspace/symbol", { query }, options);
   }
   isUnsupportedDiagnosticPullError(error) {
     if (!(error instanceof Error))
@@ -1090,42 +3058,173 @@ class LspClient extends LspClientConnection {
       return true;
     return /unsupported|not supported|method not found|unknown request/i.test(error.message);
   }
-  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 };
+  freshnessTimeout(absPath) {
+    return {
+      items: [],
+      transientError: {
+        kind: "freshness_timeout",
+        message: `Timed out waiting for fresh diagnostics for ${absPath} within ${this.diagnosticsFreshnessTimeoutMs}ms.`
       }
-    } catch (error) {
-      if (!this.isUnsupportedDiagnosticPullError(error)) {
-        this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
+    };
+  }
+  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);
     }
-    return { items: this.getStoredDiagnostics(uri) };
   }
-  async prepareRename(filePath, line, character) {
-    const absPath = resolve(contextCwd(), filePath);
+  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: pathToFileURL2(absPath).href },
+      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 resolve6(this.root, filePath);
   }
-  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
+}
+function waitForDiagnosticsActivity(wait, signal) {
+  if (!signal)
+    return wait;
+  if (signal.aborted)
+    return Promise.reject(abortError3(signal));
+  return new Promise((resolve72, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError3(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    wait.then(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve72();
+    }, (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 abortError3(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;
 }
 function installProcessSignalCleanup(cleanup) {
   const signals = process.platform === "win32" ? ["SIGINT", "SIGTERM", "SIGBREAK"] : ["SIGINT", "SIGTERM"];
@@ -1150,10 +3249,10 @@ async function stopClientBestEffort(client) {
     reportBestEffortCleanupError("client stop", error);
   }
 }
-function awaitWithSignal(promise, signal) {
+function awaitWithSignal2(promise, signal) {
   if (!signal)
     return promise;
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve72, reject) => {
     let settled = false;
     const onAbort = () => {
       if (settled)
@@ -1171,7 +3270,7 @@ function awaitWithSignal(promise, signal) {
         return;
       settled = true;
       signal.removeEventListener("abort", onAbort);
-      resolve22(value);
+      resolve72(value);
     }, (err) => {
       if (settled)
         return;
@@ -1196,7 +3295,7 @@ class LspManager {
     this.idleTimeoutMs = options.idleTimeoutMs ?? IDLE_TIMEOUT_MS;
     this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS;
     this.reaperIntervalMs = options.reaperIntervalMs ?? REAPER_INTERVAL_MS;
-    this.clientFactory = options.clientFactory ?? ((root, server) => new LspClient(root, server));
+    this.clientFactory = options.clientFactory ?? ((root, server2) => new LspClient(root, server2));
     this.now = options.now ?? (() => Date.now());
     this.startReaper();
     this.signalDisposer = installProcessSignalCleanup(() => this.stopAll());
@@ -1234,12 +3333,12 @@ class LspManager {
       await stopClientBestEffort(managed.client);
     }
   }
-  async getClient(root, server, signal) {
+  async getClient(root, server2, signal) {
     if (this.disposed) {
       throw new Error("LspManager has been disposed");
     }
     signal?.throwIfAborted();
-    const key = this.getKey(root, server.id);
+    const key = this.getKey(root, server2.id);
     let managed = this.clients.get(key);
     if (managed) {
       const t = this.now();
@@ -1253,7 +3352,7 @@ class LspManager {
       if (managed.initPromise) {
         managed.pendingWaiters++;
         try {
-          await awaitWithSignal(managed.initPromise, signal);
+          await awaitWithSignal2(managed.initPromise, signal);
         } catch (err) {
           managed.pendingWaiters--;
           await this.tryDeleteIfOrphaned(key, managed);
@@ -1268,13 +3367,13 @@ class LspManager {
       if (!managed.client.isAlive()) {
         await stopClientBestEffort(managed.client);
         this.clients.delete(key);
-        return this.getClient(root, server, signal);
+        return this.getClient(root, server2, signal);
       }
       managed.refCount++;
       managed.lastUsedAt = this.now();
       return managed.client;
     }
-    const client = this.clientFactory(root, server);
+    const client = this.clientFactory(root, server2);
     const initStartedAt = this.now();
     const initPromise = (async () => {
       await client.start();
@@ -1291,7 +3390,7 @@ class LspManager {
     };
     this.clients.set(key, newManaged);
     try {
-      await awaitWithSignal(initPromise, signal);
+      await awaitWithSignal2(initPromise, signal);
     } catch (err) {
       newManaged.pendingWaiters--;
       if (this.clients.get(key) === newManaged) {
@@ -1330,13 +3429,13 @@ class LspManager {
     this.clients.delete(key);
     stopClientBestEffort(managed.client);
   }
-  warmupClient(root, server) {
+  warmupClient(root, server2) {
     if (this.disposed)
       return;
-    const key = this.getKey(root, server.id);
+    const key = this.getKey(root, server2.id);
     if (this.clients.has(key))
       return;
-    const client = this.clientFactory(root, server);
+    const client = this.clientFactory(root, server2);
     const initStartedAt = this.now();
     const initPromise = (async () => {
       await client.start();
@@ -1416,230 +3515,15 @@ function getLspManager() {
   }
   return _defaultInstance;
 }
-async function disposeDefaultLspManager() {
-  if (_defaultInstance) {
-    const m = _defaultInstance;
-    _defaultInstance = null;
-    await m.stopAll();
-  }
-}
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-function readLockPid(lockPath) {
-  try {
-    const pid = Number.parseInt(readFileSync2(lockPath, "utf8").trim(), 10);
-    return Number.isInteger(pid) ? pid : null;
-  } catch {
-    return null;
-  }
-}
-function tryAcquireLock(lockPath, ownerPid = process.pid) {
-  mkdirSync(dirname(lockPath), { recursive: true });
-  for (let attempt = 0;attempt < 2; attempt += 1) {
-    const handle = writeLockFile(lockPath, ownerPid);
-    if (handle)
-      return handle;
-    if (!reapStaleLock(lockPath))
-      return null;
-  }
-  return null;
-}
-function writeLockFile(lockPath, ownerPid) {
-  try {
-    const fd = openSync(lockPath, "wx");
-    writeSync(fd, `${ownerPid}
-`);
-    closeSync(fd);
-    return { release: () => unlinkQuietly(lockPath) };
-  } catch (error) {
-    if (error.code === "EEXIST")
-      return null;
-    throw error;
-  }
-}
-function reapStaleLock(lockPath) {
-  const pid = readLockPid(lockPath);
-  if (pid !== null && isProcessAlive(pid))
-    return false;
-  unlinkQuietly(lockPath);
-  return true;
-}
-function unlinkQuietly(path) {
-  try {
-    unlinkSync(path);
-  } catch (error) {}
-}
-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) {
-    super(`LSP daemon did not become reachable at ${socketPath}`);
-    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) {
-  const deadline = deps.now() + readyTimeoutMs;
-  for (;; ) {
-    if (await deps.probe(socketPath))
-      return;
-    if (deps.now() >= deadline)
-      throw new DaemonUnreachableError(socketPath);
-    await deps.sleep(pollIntervalMs);
-  }
-}
-function probeSocket(socketPath, timeoutMs = PROBE_TIMEOUT_MS) {
-  return new Promise((resolve22) => {
-    const socket = connect(socketPath);
-    const finish = (ok) => {
-      socket.destroy();
-      resolve22(ok);
-    };
-    const timer = setTimeout(() => finish(false), timeoutMs);
-    timer.unref?.();
-    socket.once("connect", () => {
-      clearTimeout(timer);
-      finish(true);
-    });
-    socket.once("error", () => {
-      clearTimeout(timer);
-      finish(false);
-    });
-  });
-}
-function spawnDaemonProcess(paths) {
-  mkdirSync2(dirname2(paths.log), { recursive: true });
-  const logFd = openSync2(paths.log, "a");
-  try {
-    const cliPath = resolveDaemonCliPath();
-    const child = spawn2(execPath, [cliPath, "daemon"], {
-      detached: true,
-      stdio: ["ignore", logFd, logFd]
-    });
-    child.unref();
-  } finally {
-    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);
-    },
-    spawnDaemon: (paths) => spawnDaemonProcess(paths),
-    sleep: (ms) => new Promise((resolve22) => {
-      setTimeout(resolve22, ms);
-    }),
-    now: () => Date.now()
-  };
-}
-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}`;
-  }
-  const natural = join2(dir, "daemon.sock");
-  if (natural.length < MAX_SOCKET_PATH_LENGTH)
-    return natural;
-  return join2(tmpdir(), `omo-lsp-${version}-${digest}.sock`);
-}
-var HEADER_SEPARATOR2 = Buffer.from(`\r
-\r
-`);
-var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60000;
 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 {};
@@ -1657,22 +3541,22 @@ 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);
 }
 var LSP_INSTALL_HINTS = {
@@ -1820,27 +3704,17 @@ var BUILTIN_SERVERS = {
     extensions: [".razor", ".cshtml"]
   }
 };
-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;
@@ -1857,8 +3731,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;
   }
@@ -1979,16 +3853,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"];
@@ -1996,15 +3870,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() {
@@ -2030,7 +3904,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";
@@ -2051,7 +3925,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;
       }
     }
@@ -2146,39 +4020,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 dirname4(abs);
+  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 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": {',
@@ -2194,6 +4079,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.`;
   }
@@ -2209,6 +4095,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 [
@@ -2220,6 +4117,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(`
 `);
@@ -2233,14 +4131,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);
@@ -2273,7 +4171,7 @@ var DIAGNOSTIC_SEVERITY_FILTERS = {
   hint: 4
 };
 function uriToPath(uri) {
-  return fileURLToPath2(uri);
+  return fileURLToPath3(uri);
 }
 function formatLocation(loc) {
   if ("targetUri" in loc) {
@@ -2359,6 +4257,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) {
@@ -2372,6 +4273,7 @@ function formatApplyResult(result) {
 `);
 }
 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) {
@@ -2379,17 +4281,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;
       }
@@ -2407,52 +4309,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 client = await manager.getClient(root, server2);
+  const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
+  options.signal?.throwIfAborted();
+  const client = await manager.getClient(root, server2, options.signal);
   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);
   }
@@ -2480,8 +4395,8 @@ 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 };
 }
 var SKIP_DIRECTORIES2 = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
 var MAX_SCAN_ENTRIES = 500;
@@ -2493,17 +4408,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;
       }
@@ -2574,10 +4489,45 @@ 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;
+    }
+  }
+}
 function requireString(params, key) {
   const value = params[key];
   if (typeof value !== "string" || value.length === 0) {
@@ -2628,7 +4578,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) {
@@ -2645,18 +4595,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;
@@ -2714,7 +4679,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)
@@ -2739,7 +4704,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;
@@ -2750,199 +4715,36 @@ async function executeLspFindReferences(params, signal) {
       character,
       references,
       totalReferences: total,
-      truncated
-    };
-    if (total === 0)
-      return text("No references found", details);
-    const output = [
-      ...truncated ? [`Found ${total} references (showing first ${DEFAULT_MAX_REFERENCES}):`] : [],
-      ...limited.map(formatLocation)
-    ].join(`
-`);
-    return text(output, details);
-  } catch (error) {
-    const missingDependency = missingDependencyResult(error, {
-      filePath,
-      line,
-      character,
-      references: [],
-      totalReferences: 0,
-      truncated: false
-    });
-    if (missingDependency)
-      return missingDependency;
-    throw error;
-  }
-}
-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)}`);
-        }
-      }
-    }
+      truncated
+    };
+    if (total === 0)
+      return text("No references found", details);
+    const output = [
+      ...truncated ? [`Found ${total} references (showing first ${DEFAULT_MAX_REFERENCES}):`] : [],
+      ...limited.map(formatLocation)
+    ].join(`
+`);
+    return text(output, details);
+  } catch (error) {
+    const missingDependency = missingDependencyResult(error, {
+      filePath,
+      line,
+      character,
+      references: [],
+      totalReferences: 0,
+      truncated: false
+    });
+    if (missingDependency)
+      return missingDependency;
+    throw error;
   }
-  return result;
 }
 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) {
@@ -2963,13 +4765,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,
@@ -3038,10 +4836,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");
@@ -3195,35 +4993,8 @@ var LSP_MCP_TOOLS = [
   }
 ];
 var CONTEXT_KEY = "_context";
-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) {
-            onParseError?.(raw, error);
-          }
-        }
-        index = buffer.indexOf(`
-`);
-      }
-    }
-  };
-}
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
-var REQUEST_ID = 1;
+var nextProxyRequestId = 1;
 
 class DaemonRequestError extends Error {
   requestWritten;
@@ -3233,46 +5004,82 @@ 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 ensure = options.ensure ?? ((ensurePaths, signal) => ensureDaemonRunning(ensurePaths, undefined, signal === undefined ? {} : { signal }));
   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);
+      await ensureDaemonAvailable(paths, ensure, options.signal);
+      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 };
+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 ensureDaemonAvailable(paths, ensure, signal) {
+  if (!signal)
+    return ensure(paths);
+  return new Promise((resolve9, reject) => {
+    let settled = false;
+    const finish = (run) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      run();
+    };
+    const onAbort = () => finish(() => reject(new DaemonRequestCancelledError(false)));
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve9()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
+  });
+}
 function daemonUnreachableResult(paths, error) {
   const text2 = [
     `LSP daemon unreachable: ${errorText(error)}.`,
@@ -3284,39 +5091,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 = connect(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"]))
@@ -3327,167 +5179,436 @@ 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);
 }
+var OMO_LSP_DAEMON_CLI2 = "OMO_LSP_DAEMON_CLI";
+var OMO_LSP_DAEMON_VERSION2 = "OMO_LSP_DAEMON_VERSION";
+var DAEMON_VERSION_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
+
+class InvalidRuntimeOverrideError2 extends Error {
+  code = "invalid_runtime_override";
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "InvalidRuntimeOverrideError";
+    this.reason = reason;
+  }
+}
+function validateDaemonVersion2(version) {
+  if (!DAEMON_VERSION_PATTERN2.test(version)) {
+    throw new Error("LSP daemon version must match [A-Za-z0-9][A-Za-z0-9._+-]{0,127}");
+  }
+  return version;
+}
+function resolveDaemonRuntime2(env, defaults) {
+  const cliOverride = env[OMO_LSP_DAEMON_CLI2];
+  const versionOverride = env[OMO_LSP_DAEMON_VERSION2];
+  const hasCliOverride = cliOverride !== undefined;
+  const hasVersionOverride = versionOverride !== undefined;
+  if (hasCliOverride !== hasVersionOverride) {
+    throw new InvalidRuntimeOverrideError2("paired_values_required", `${OMO_LSP_DAEMON_CLI2} and ${OMO_LSP_DAEMON_VERSION2} must be set together`);
+  }
+  if (!hasCliOverride || !hasVersionOverride) {
+    if (!isAbsolute4(defaults.cliPath)) {
+      throw new InvalidRuntimeOverrideError2("packaged_cli_must_be_absolute", "Packaged LSP daemon CLI path must be absolute");
+    }
+    return { cliPath: defaults.cliPath, version: validateDaemonVersion2(defaults.version) };
+  }
+  if (!isAbsolute4(cliOverride)) {
+    throw new InvalidRuntimeOverrideError2("cli_must_be_absolute", `${OMO_LSP_DAEMON_CLI2} must be an absolute path to an existing regular file`);
+  }
+  const stat = statSync5(cliOverride, { throwIfNoEntry: false });
+  if (!stat) {
+    throw new InvalidRuntimeOverrideError2("cli_not_found", `${OMO_LSP_DAEMON_CLI2} points to a missing file`);
+  }
+  if (!stat.isFile()) {
+    throw new InvalidRuntimeOverrideError2("cli_not_file", `${OMO_LSP_DAEMON_CLI2} must point to a regular file`);
+  }
+  return { cliPath: cliOverride, version: validateDaemonVersion2(versionOverride) };
+}
+function callDiagnosticsViaDaemon2(filePath, options) {
+  return callDiagnosticsViaDaemon(filePath, options);
+}
+
+// ../../../../lsp-core/src/post-edit/orchestration.ts
+import { extname as extname2 } from "node:path";
+var DEFAULT_MAX_CONCURRENCY = 4;
+var CLEAN_DIAGNOSTICS_TEXT = "No diagnostics found";
+function createPostEditNotConfiguredCache() {
+  return { notConfiguredExtensions: new Set };
+}
+async function collectPostEditDiagnostics(input) {
+  const cache = input.cache === undefined ? createPostEditNotConfiguredCache() : input.cache;
+  const filePaths = firstSeenDiagnosticTargets(input.filePaths, cache);
+  const results = await runBoundedDiagnostics(filePaths, input.runDiagnostics, input.maxConcurrency);
+  const blocks = [];
+  const observations = [];
+  for (const result of results) {
+    const classification = classifyDiagnostics(result.outcome);
+    switch (classification.kind) {
+      case "clean":
+        observations.push({ filePath: result.filePath, kind: "clean" });
+        break;
+      case "not_configured":
+        cache.notConfiguredExtensions.add(classification.extension);
+        observations.push({ filePath: result.filePath, kind: "not_configured" });
+        break;
+      case "block":
+        blocks.push({ filePath: result.filePath, diagnostics: classification.diagnostics });
+        observations.push({ filePath: result.filePath, kind: "block" });
+        break;
+      default: {
+        const exhaustive = classification;
+        return exhaustive;
+      }
+    }
+  }
+  return { blocks, observations };
+}
+function firstSeenDiagnosticTargets(filePaths, cache) {
+  const seen = new Set;
+  const targets = [];
+  for (const filePath of filePaths) {
+    if (filePath.length === 0 || seen.has(filePath))
+      continue;
+    seen.add(filePath);
+    const extension = extensionKey(filePath);
+    if (extension !== undefined && cache.notConfiguredExtensions.has(extension))
+      continue;
+    targets.push({ index: targets.length, filePath });
+  }
+  return targets;
+}
+async function runBoundedDiagnostics(filePaths, runDiagnostics, maxConcurrency) {
+  const results = [];
+  const workerCount = Math.min(Math.max(1, maxConcurrency ?? DEFAULT_MAX_CONCURRENCY), filePaths.length);
+  let nextIndex = 0;
+  async function worker() {
+    for (;; ) {
+      const target = filePaths[nextIndex];
+      nextIndex += 1;
+      if (target === undefined)
+        return;
+      results[target.index] = {
+        index: target.index,
+        filePath: target.filePath,
+        outcome: await collectFileDiagnostics(target.filePath, runDiagnostics)
+      };
+    }
+  }
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results.filter((result) => result !== undefined);
+}
+async function collectFileDiagnostics(filePath, runDiagnostics) {
+  try {
+    return normalizeDiagnosticsOutcome(await runDiagnostics(filePath));
+  } catch (error) {
+    if (error instanceof Error)
+      return formatDiagnosticsError(error);
+    return normalizeDiagnosticsText(String(error));
+  }
+}
+function normalizeDiagnosticsOutcome(outcome) {
+  if (typeof outcome === "string")
+    return normalizeDiagnosticsText(outcome);
+  return outcome;
+}
+function normalizeDiagnosticsText(text2) {
+  return text2.trim();
+}
+function formatDiagnosticsError(error) {
+  const message = normalizeDiagnosticsText(error.message);
+  return message.length > 0 ? message : normalizeDiagnosticsText(String(error));
+}
+function classifyDiagnostics(outcome) {
+  if (typeof outcome !== "string") {
+    return { kind: "not_configured", extension: outcome.extension };
+  }
+  const diagnostics = outcome;
+  if (diagnostics.length === 0 || diagnostics === CLEAN_DIAGNOSTICS_TEXT)
+    return { kind: "clean" };
+  return { kind: "block", diagnostics };
+}
+function extensionKey(filePath) {
+  const extension = extname2(filePath).toLowerCase();
+  return extension.length === 0 ? undefined : extension;
+}
+// ../../../../lsp-core/src/request-context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { existsSync as existsSync11, realpathSync as realpathSync4, statSync as statSync6 } from "node:fs";
+import { basename as basename3, delimiter as delimiter4, dirname as dirname2, isAbsolute as isAbsolute5, join as join7, relative as relative5, resolve as resolve9 } from "node:path";
 
-// components/lsp/src/codex-hook.ts
-import { readFileSync as readFileSync9 } from "node:fs";
+class LspRequestContextParseError2 extends Error {
+  code;
+  name = "LspRequestContextParseError";
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+var storage2 = new AsyncLocalStorage2;
+var CONTEXT_FIELDS2 = new Set(["cwd", "projectConfigPaths", "userConfigPath", "installDecisionsPath", "capabilities"]);
+var CAPABILITY_FIELDS2 = new Set(["installDecisionTool"]);
+function parseLspRequestContext2(value) {
+  if (!isRecord7(value)) {
+    throw new LspRequestContextParseError2("invalid_context", "LSP request context must be an object.");
+  }
+  rejectUnknownFields2(value, CONTEXT_FIELDS2, "context");
+  const cwd = stringField2(value, "cwd");
+  const projectConfigPaths = stringArrayField2(value, "projectConfigPaths");
+  const userConfigPath = stringField2(value, "userConfigPath");
+  const installDecisionsPath = stringField2(value, "installDecisionsPath");
+  const capabilities = capabilitiesField2(value["capabilities"]);
+  const canonical = canonicalCwd2(cwd);
+  for (const path2 of projectConfigPaths) {
+    requireAbsolutePath2(path2, "projectConfigPaths");
+    const projectPath = canonicalizeExistingOrNearestAncestor2(path2);
+    if (!isPathInside2(canonical, projectPath)) {
+      throw new LspRequestContextParseError2("project_config_outside_cwd", `Project LSP config path must be inside cwd: ${path2}`);
+    }
+  }
+  requireAbsolutePath2(userConfigPath, "userConfigPath");
+  requireAbsolutePath2(installDecisionsPath, "installDecisionsPath");
+  return {
+    cwd: canonical,
+    projectConfigPaths: projectConfigPaths.map((path2) => canonicalizeExistingOrNearestAncestor2(path2)),
+    userConfigPath,
+    installDecisionsPath,
+    capabilities
+  };
+}
+function canonicalCwd2(cwd) {
+  const resolved = resolve9(cwd);
+  if (!existsSync11(resolved) || !statSync6(resolved).isDirectory()) {
+    throw new LspRequestContextParseError2("invalid_cwd", `LSP request cwd must be an existing directory: ${cwd}`);
+  }
+  return realpathSync4(resolved);
+}
+function canonicalizeExistingOrNearestAncestor2(path2) {
+  let current = resolve9(path2);
+  const suffix = [];
+  while (true) {
+    try {
+      const existing = realpathSync4(current);
+      return suffix.length === 0 ? existing : join7(existing, ...suffix);
+    } catch (error) {
+      if (!isMissingPathError2(error))
+        throw error;
+      const parent = dirname2(current);
+      if (parent === current)
+        throw error;
+      suffix.unshift(basename3(current));
+      current = parent;
+    }
+  }
+}
+function capabilitiesField2(value) {
+  if (!isRecord7(value)) {
+    throw new LspRequestContextParseError2("invalid_capabilities", "LSP request capabilities must be an object.");
+  }
+  rejectUnknownFields2(value, CAPABILITY_FIELDS2, "capabilities");
+  const installDecisionTool = value["installDecisionTool"];
+  if (typeof installDecisionTool !== "boolean") {
+    throw new LspRequestContextParseError2("invalid_install_decision_capability", "LSP request capabilities.installDecisionTool must be a boolean.");
+  }
+  return { installDecisionTool };
+}
+function stringField2(value, field) {
+  const fieldValue = value[field];
+  if (typeof fieldValue !== "string" || fieldValue.length === 0) {
+    throw new LspRequestContextParseError2("invalid_field", `LSP request context.${field} must be a non-empty string.`);
+  }
+  return fieldValue;
+}
+function stringArrayField2(value, field) {
+  const fieldValue = value[field];
+  if (!Array.isArray(fieldValue) || !fieldValue.every((item) => typeof item === "string" && item.length > 0)) {
+    throw new LspRequestContextParseError2("invalid_field", `LSP request context.${field} must be a non-empty string array.`);
+  }
+  return fieldValue;
+}
+function requireAbsolutePath2(path2, field) {
+  if (!isAbsolute5(path2)) {
+    throw new LspRequestContextParseError2("relative_path", `LSP request context.${field} must be absolute: ${path2}`);
+  }
+}
+function isPathInside2(parent, child) {
+  const childPath = resolve9(child);
+  const relativePath = relative5(parent, childPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute5(relativePath);
+}
+function isMissingPathError2(error) {
+  const code = errorCode2(error);
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function rejectUnknownFields2(value, allowed, scope) {
+  const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+  if (unknown.length > 0) {
+    throw new LspRequestContextParseError2("unknown_field", `Unknown LSP request ${scope} field: ${unknown.join(", ")}`);
+  }
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorCode2(error) {
+  if (!error || typeof error !== "object" || !("code" in error))
+    return;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" ? code : undefined;
+}
 
-// components/lsp/src/daemon-cli-path.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
+// src/daemon-cli-path.ts
+import { existsSync as existsSync13, readFileSync as readFileSync6 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { dirname as dirname9, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var requireFromHere2 = createRequire2(import.meta.url);
-var PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
-var CODEX_LSP_DAEMON_CLI_ENV2 = "CODEX_LSP_DAEMON_CLI";
-var CODEX_LSP_DAEMON_VERSION_ENV2 = "CODEX_LSP_DAEMON_VERSION";
+var PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/cli";
 function ensureLspDaemonCliEnv(env = process.env) {
-  const configuredCli = env[CODEX_LSP_DAEMON_CLI_ENV2]?.trim();
-  const resolution = configuredCli ? resolveConfiguredLspDaemonCli(configuredCli) : resolveLspDaemonCli();
-  if (!configuredCli)
-    env[CODEX_LSP_DAEMON_CLI_ENV2] = resolution.cliPath;
-  if (!env[CODEX_LSP_DAEMON_VERSION_ENV2]?.trim() && resolution.version !== null) {
-    env[CODEX_LSP_DAEMON_VERSION_ENV2] = resolution.version;
-  }
-}
-function resolveLspDaemonCliPath() {
-  return resolveLspDaemonCli().cliPath;
+  const runtime = resolveDaemonRuntime2(env, resolveLspDaemonCli());
+  env[OMO_LSP_DAEMON_CLI2] = runtime.cliPath;
+  env[OMO_LSP_DAEMON_VERSION2] = runtime.version;
+}
+function resolveLspDaemonCliPath(env = process.env) {
+  const runtime = resolveDaemonRuntime2(env, resolveLspDaemonCli());
+  if (env[OMO_LSP_DAEMON_CLI2] === undefined)
+    env[OMO_LSP_DAEMON_CLI2] = runtime.cliPath;
+  if (env[OMO_LSP_DAEMON_VERSION2] === undefined)
+    env[OMO_LSP_DAEMON_VERSION2] = runtime.version;
+  return runtime.cliPath;
 }
 function resolveLspDaemonCli() {
   const packageCli = resolvePackageLspDaemonCliPath();
   if (packageCli !== null)
     return resolveConfiguredLspDaemonCli(packageCli);
   const bundledCli = fileURLToPath4(new URL("../../lsp-daemon/dist/cli.js", import.meta.url));
-  if (existsSync9(bundledCli))
+  if (existsSync13(bundledCli))
     return resolveConfiguredLspDaemonCli(bundledCli);
   return resolveConfiguredLspDaemonCli(bundledCli);
 }
 function resolvePackageLspDaemonCliPath() {
   try {
     return requireFromHere2.resolve(PACKAGE_LSP_DAEMON_CLI);
-  } catch {
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
     return null;
   }
 }
 function resolveConfiguredLspDaemonCli(cliPath) {
+  const version = readDaemonPackageVersion(cliPath);
+  if (version === null) {
+    throw new Error(`Unable to determine packaged LSP daemon version beside ${cliPath}`);
+  }
   return {
     cliPath,
-    version: readDaemonPackageVersion(cliPath)
+    version
   };
 }
 function readDaemonPackageVersion(cliPath) {
   try {
-    const parsed = JSON.parse(readFileSync6(join9(dirname6(cliPath), "package.json"), "utf8"));
-    if (isRecord4(parsed) && typeof parsed["version"] === "string" && parsed["version"].length > 0) {
+    const parsed = JSON.parse(readFileSync6(join9(dirname9(cliPath), "package.json"), "utf8"));
+    if (isRecord9(parsed) && typeof parsed["version"] === "string" && parsed["version"].length > 0) {
       return parsed["version"];
     }
-  } catch {}
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+  }
   return null;
 }
-function isRecord4(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// components/lsp/src/lsp-session-state.ts
+// src/lsp-session-state.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname8, extname as extname2, join as join11 } from "node:path";
+import { homedir } from "node:os";
+import { dirname as dirname11, join as join10 } from "node:path";
 function sessionIdFrom(input) {
   return typeof input.session_id === "string" && input.session_id.length > 0 ? input.session_id : undefined;
 }
-function shouldSkipUnavailableLspDiagnostics(filePath, sessionId) {
+function readLspPostEditCache(sessionId) {
   if (sessionId === undefined)
-    return false;
-  const state = readSessionState(sessionStatePath(sessionId));
-  const extension = extensionKey(filePath);
-  return extension !== undefined && state.postCompactProbePending !== true && state.unavailableExtensions.includes(extension);
-}
-function recordLspDiagnosticsObservations(sessionId, observations) {
-  if (sessionId === undefined || observations.length === 0)
-    return;
+    return { notConfiguredExtensions: new Set };
   const state = readSessionState(sessionStatePath(sessionId));
-  const unavailableExtensions = new Set(state.unavailableExtensions);
-  for (const observation of observations) {
-    const extension = extensionKey(observation.filePath);
-    if (extension === undefined)
-      continue;
-    if (observation.unavailable) {
-      unavailableExtensions.add(extension);
-    } else {
-      unavailableExtensions.delete(extension);
-    }
-  }
-  writeSessionState(sessionStatePath(sessionId), { unavailableExtensions: [...unavailableExtensions].sort() });
+  return { notConfiguredExtensions: new Set(state.notConfiguredExtensions) };
 }
-function markLspSessionCompacted(sessionId) {
+function writeLspPostEditCache(sessionId, cache) {
   if (sessionId === undefined)
     return;
-  const state = readSessionState(sessionStatePath(sessionId));
-  if (state.unavailableExtensions.length === 0)
-    return;
   writeSessionState(sessionStatePath(sessionId), {
-    unavailableExtensions: state.unavailableExtensions,
-    postCompactProbePending: true
+    notConfiguredExtensions: [...cache.notConfiguredExtensions].sort()
   });
 }
-function isUnavailableLspDiagnostics(diagnostics) {
-  const normalized = diagnostics.trim();
-  return normalized.includes("LSP request timeout (method: initialize)") || normalized.includes("LSP server is still initializing") || normalized.includes("NOT INSTALLED") || normalized.includes("Command not found:");
+function markLspSessionCompacted(sessionId) {
+  if (sessionId === undefined)
+    return;
+  writeSessionState(sessionStatePath(sessionId), emptyState());
 }
 function isLspDaemonUnreachableDiagnostics(diagnostics) {
   return diagnostics.includes("LSP daemon unreachable");
 }
 function sessionStatePath(sessionId) {
-  const root = process.env["PLUGIN_DATA"] ?? join11(homedir4(), ".codex", "codex-lsp");
-  return join11(root, "sessions", `${safePathSegment(sessionId)}.json`);
+  const root = process.env["PLUGIN_DATA"] ?? join10(homedir(), ".codex", "codex-lsp");
+  return join10(root, "sessions", `${safePathSegment(sessionId)}.json`);
 }
-function readSessionState(path) {
+function readSessionState(path2) {
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf8"));
-    if (isLspSessionState(parsed))
-      return parsed;
+    const parsed = JSON.parse(readFileSync8(path2, "utf8"));
+    if (isRecord10(parsed) && isLspSessionState(parsed))
+      return normalizeSessionState(parsed);
     return emptyState();
   } catch (error) {
-    if (error instanceof SyntaxError || isRecord6(error) && error["code"] === "ENOENT")
+    if (error instanceof SyntaxError || isRecord10(error) && error["code"] === "ENOENT")
       return emptyState();
     throw error;
   }
 }
-function writeSessionState(path, state) {
-  mkdirSync4(dirname8(path), { recursive: true });
-  writeFileSync3(path, `${JSON.stringify(state)}
+function writeSessionState(path2, state) {
+  mkdirSync4(dirname11(path2), { recursive: true });
+  writeFileSync3(path2, `${JSON.stringify(state)}
 `);
 }
 function emptyState() {
-  return { unavailableExtensions: [] };
-}
-function extensionKey(filePath) {
-  const extension = extname2(filePath).toLowerCase();
-  return extension.length === 0 ? undefined : extension;
+  return { notConfiguredExtensions: [] };
 }
 function safePathSegment(value) {
   return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
 }
 function isLspSessionState(value) {
-  if (!isRecord6(value) || !Array.isArray(value["unavailableExtensions"]))
-    return false;
-  const postCompactProbePending = value["postCompactProbePending"];
-  return value["unavailableExtensions"].every((item) => typeof item === "string") && (postCompactProbePending === undefined || typeof postCompactProbePending === "boolean");
+  const notConfiguredExtensions = value["notConfiguredExtensions"] ?? value["unavailableExtensions"];
+  return Array.isArray(notConfiguredExtensions) && notConfiguredExtensions.every((item) => typeof item === "string");
 }
-function isRecord6(value) {
+function normalizeSessionState(value) {
+  const notConfiguredExtensions = value["notConfiguredExtensions"] ?? value["unavailableExtensions"];
+  return {
+    notConfiguredExtensions: Array.isArray(notConfiguredExtensions) ? notConfiguredExtensions.filter((item) => typeof item === "string").sort() : []
+  };
+}
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// components/lsp/src/mutated-file-paths.ts
+// src/mutated-file-paths.ts
 var MUTATION_TOOL_NAMES = new Set(["apply_patch", "write", "edit", "multiedit", "multi_edit"]);
 function extractMutatedFilePaths(input) {
   if (!isMutationTool(input.tool_name))
     return [];
   if (isFailedToolResponse(input.tool_response))
     return [];
-  const toolInput = isRecord7(input.tool_input) ? input.tool_input : {};
+  const toolInput = isRecord11(input.tool_input) ? input.tool_input : {};
   const paths = new Set;
   addStringValue(paths, toolInput["path"]);
   addStringValue(paths, toolInput["filePath"]);
@@ -3506,7 +5627,7 @@ function isMutationTool(value) {
   return MUTATION_TOOL_NAMES.has(value.toLowerCase());
 }
 function isFailedToolResponse(value) {
-  if (!isRecord7(value))
+  if (!isRecord11(value))
     return false;
   return value["isError"] === true || value["is_error"] === true || value["error"] === true || value["status"] === "error";
 }
@@ -3532,9 +5653,9 @@ function addPatchInput(paths, value) {
     return;
   for (const line of value.split(`
 `)) {
-    const path = extractPatchHeaderPath(line);
-    if (path !== undefined)
-      paths.add(path);
+    const path2 = extractPatchHeaderPath(line);
+    if (path2 !== undefined)
+      paths.add(path2);
   }
 }
 function extractPatchHeaderPath(line) {
@@ -3549,7 +5670,7 @@ function addPatchFiles(paths, value) {
   if (!Array.isArray(value))
     return;
   for (const item of value) {
-    if (!isRecord7(item))
+    if (!isRecord11(item))
       continue;
     addStringValue(paths, item["path"]);
     addStringValue(paths, item["filePath"]);
@@ -3558,18 +5679,15 @@ function addPatchFiles(paths, value) {
     addStringValue(paths, item["move_path"]);
   }
 }
-function isRecord7(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// components/lsp/src/codex-hook.ts
-var CLEAN_DIAGNOSTICS_TEXT = "No diagnostics found";
-var UNSUPPORTED_EXTENSION_TEXT = "No LSP server configured for extension:";
+// src/codex-hook.ts
 var DIAGNOSTIC_START_PATTERN = /(?:error|warning|information|hint)\[[^\]\r\n]+\] \(\d+\) at \d+:\d+:/g;
 var DIAGNOSTIC_CHUNK_PATTERN = /^(?:error|warning|information|hint)\[[^\]\r\n]+\] \(\d+\) at \d+:\d+:/;
 var DEFAULT_MAX_HOOK_FEEDBACK_CHARS = 8000;
 var CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS = 1200;
-var MAX_CONCURRENT_DIAGNOSTICS = 4;
 var CONTEXT_PRESSURE_MARKERS = [
   "context compacted",
   "context_length_exceeded",
@@ -3581,29 +5699,47 @@ var CONTEXT_PRESSURE_MARKERS = [
 ];
 async function runLspDiagnosticsText(filePath) {
   ensureLspDaemonCliEnv();
-  const result = await callDiagnosticsViaDaemon(filePath, { context: currentRequestContext() });
+  const result = await callDiagnosticsViaDaemon2(filePath, { context: codexLspRequestContext() });
+  return postEditOutcomeFromDaemonResult(result);
+}
+function postEditOutcomeFromDaemonResult(result) {
+  const availability = notConfiguredAvailability(result.details);
+  if (availability !== undefined)
+    return { kind: "not_configured", extension: availability.extension };
   return result.content.map((block) => block.text).join(`
 `);
 }
+function notConfiguredAvailability(details) {
+  if (!isRecord12(details))
+    return;
+  const availability = details["availability"];
+  if (!isRecord12(availability))
+    return;
+  if (availability["kind"] !== "not_configured")
+    return;
+  const extension = availability["extension"];
+  return typeof extension === "string" && extension.length > 0 ? { extension } : undefined;
+}
+function codexLspRequestContext(env = process.env, cwd = process.cwd()) {
+  const canonicalCwd3 = realpathSync6(resolve11(cwd));
+  const codexHome = resolve11(env["CODEX_HOME"]?.trim() || join11(homedir3(), ".codex"));
+  return parseLspRequestContext2({
+    cwd: canonicalCwd3,
+    projectConfigPaths: [join11(canonicalCwd3, ".codex", "lsp-client.json")],
+    userConfigPath: join11(codexHome, "lsp-client.json"),
+    installDecisionsPath: join11(codexHome, "lsp-install-decisions.json"),
+    capabilities: { installDecisionTool: true }
+  });
+}
 async function runLspPostToolUseHook(input, runDiagnostics = runLspDiagnosticsText) {
   const sessionId = sessionIdFrom(input);
-  const filePaths = extractMutatedFilePaths(input).filter((filePath) => !shouldSkipUnavailableLspDiagnostics(filePath, sessionId));
+  const filePaths = extractMutatedFilePaths(input);
   if (filePaths.length === 0)
     return "";
-  const blocks = [];
-  const observations = [];
-  for (const { filePath, diagnostics } of await collectDiagnostics(filePaths, runDiagnostics)) {
-    if (isLspDaemonUnreachableDiagnostics(diagnostics))
-      continue;
-    const unavailable = isUnavailableLspDiagnostics(diagnostics);
-    observations.push({ filePath, unavailable });
-    if (isCleanDiagnostics(diagnostics))
-      continue;
-    if (unavailable)
-      continue;
-    blocks.push({ filePath, diagnostics });
-  }
-  recordLspDiagnosticsObservations(sessionId, observations);
+  const cache = readLspPostEditCache(sessionId);
+  const result = await collectPostEditDiagnostics({ filePaths, runDiagnostics, cache });
+  writeLspPostEditCache(sessionId, cache);
+  const blocks = result.blocks.filter(({ diagnostics }) => !isLspDaemonUnreachableDiagnostics(diagnostics));
   if (blocks.length === 0)
     return "";
   const rawReason = blocks.map(formatDiagnosticBlock).join(`
@@ -3625,38 +5761,6 @@ async function runLspPostCompactHook(input) {
   markLspSessionCompacted(sessionIdFrom(input));
   return "";
 }
-async function collectDiagnostics(filePaths, runDiagnostics) {
-  const results = [];
-  let nextIndex = 0;
-  const workerCount = Math.min(MAX_CONCURRENT_DIAGNOSTICS, filePaths.length);
-  async function worker() {
-    for (;; ) {
-      const index = nextIndex;
-      nextIndex += 1;
-      const filePath = filePaths[index];
-      if (filePath === undefined)
-        return;
-      results[index] = { filePath, diagnostics: await collectFileDiagnostics(filePath, runDiagnostics) };
-    }
-  }
-  await Promise.all(Array.from({ length: workerCount }, () => worker()));
-  return results;
-}
-async function collectFileDiagnostics(filePath, runDiagnostics) {
-  try {
-    return (await runDiagnostics(filePath)).trim();
-  } catch (error) {
-    return formatDiagnosticsError(error);
-  }
-}
-function formatDiagnosticsError(error) {
-  if (error instanceof Error) {
-    const message = error.message.trim();
-    if (message.length > 0)
-      return message;
-  }
-  return String(error).trim();
-}
 function formatDiagnosticBlock({ filePath, diagnostics }) {
   return `LSP diagnostics after editing ${filePath}:
 
@@ -3739,14 +5843,11 @@ function limitHookText(text2, maxChars) {
   const head = text2.slice(0, maxChars - marker.length).replace(/[ \t\r\n]+$/, "");
   return `${head}${marker}`;
 }
-function isCleanDiagnostics(diagnostics) {
-  return diagnostics.length === 0 || diagnostics === CLEAN_DIAGNOSTICS_TEXT || diagnostics.startsWith(UNSUPPORTED_EXTENSION_TEXT);
-}
-function isRecord8(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// components/lsp/src/codex-hook-cli.ts
+// src/codex-hook-cli.ts
 async function runPostToolUseHookCli(stdin = processStdin) {
   await runHookCli((input) => runLspPostToolUseHook(input), stdin);
 }
@@ -3759,16 +5860,12 @@ async function runHookCli(runHook, stdin) {
     if (!raw.trim())
       return;
     const parsed = JSON.parse(raw);
-    const input = isRecord8(parsed) ? parsed : {};
+    const input = isRecord12(parsed) ? parsed : {};
     const output = await runHook(input);
     if (output)
       process.stdout.write(output);
   } catch {
     return;
-  } finally {
-    await disposeDefaultLspManager().catch(() => {
-      return;
-    });
   }
 }
 async function readStdin(stdin) {
@@ -3780,7 +5877,7 @@ async function readStdin(stdin) {
   return raw;
 }
 
-// components/lsp/src/cli.ts
+// src/cli.ts
 async function main() {
   const [command = "mcp", subcommand = ""] = argv.slice(2);
   if (command === "hook" && subcommand === "post-tool-use") {
@@ -3807,14 +5904,14 @@ main().catch((error) => {
 async function runPackageLspMcpCli() {
   const cliPath = resolveLspDaemonCliPath();
   const child = spawn3(execPath2, [cliPath, "mcp"], { stdio: "inherit" });
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve10, reject) => {
     child.once("error", reject);
     child.once("exit", (code, signal) => {
       if (code !== null && code !== 0)
         process.exitCode = code;
       if (code === null && signal !== null)
         process.exitCode = 1;
-      resolve6();
+      resolve10();
     });
   });
 }