oh-my-opencode 5.0.0-beta.2 → 5.0.0-beta.21

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

@@ -4,8 +4,8 @@
 import { argv, stderr } from "node:process";
 
 // src/proxy.ts
-import { existsSync as existsSync12, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename3, delimiter as delimiter4, dirname as dirname9, isAbsolute as isAbsolute5 } from "node:path";
+import { existsSync as existsSync13, realpathSync as realpathSync6 } from "node:fs";
+import { basename as basename4, delimiter as delimiter4, dirname as dirname10, isAbsolute as isAbsolute5 } from "node:path";
 
 // ../mcp-stdio-core/src/record.ts
 function isPlainRecord(value) {
@@ -280,7 +280,11 @@ function createParentWatchdog(config, onDeadParent) {
   const probeAlive = config.probeAlive ?? isProcessAlive;
   let fired = false;
   const timer = setInterval(() => {
-    if (fired || probeAlive(parentPid))
+    if (fired)
+      return;
+    const alive = probeAlive(parentPid);
+    config.onPoll?.(alive);
+    if (alive)
       return;
     fired = true;
     onDeadParent(parentPid, pollIntervalMs);
@@ -315,8 +319,8 @@ function createIdleTimer(idleTimeoutMs, log, onTimeout) {
   };
 }
 // ../lsp-core/src/lsp/client-wrapper.ts
-import { existsSync as existsSync9, statSync as statSync3 } from "node:fs";
-import { dirname as dirname6, join as join4, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync10, realpathSync as realpathSync5, statSync as statSync3 } from "node:fs";
+import { basename as basename3, dirname as dirname7, join as join5, resolve as resolve7 } from "node:path";
 
 // ../lsp-core/src/request-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -325,18 +329,17 @@ import { homedir } from "node:os";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
 
 class LspRequestContextParseError extends Error {
-  code;
-  name = "LspRequestContextParseError";
   constructor(code, message) {
     super(message);
     this.code = code;
+    this.name = "LspRequestContextParseError";
   }
 }
 
 class LspRequestContextUnavailableError extends Error {
-  name = "LspRequestContextUnavailableError";
   constructor() {
     super("LSP request context is required. Standalone MCP startup must install one with runWithRequestContext(createStandaloneMcpRequestContext()).");
+    this.name = "LspRequestContextUnavailableError";
   }
 }
 var storage = new AsyncLocalStorage;
@@ -499,22 +502,15 @@ function effectiveExtension(filePath) {
 
 // ../lsp-core/src/lsp/errors.ts
 class LspConnectionClosedError extends Error {
-  serverId;
-  root;
-  name = "LspConnectionClosedError";
   constructor(serverId, root, message) {
     super(message ?? `LSP connection closed for ${serverId} at ${root}`);
     this.serverId = serverId;
     this.root = root;
+    this.name = "LspConnectionClosedError";
   }
 }
 
 class LspProcessExitedError extends Error {
-  serverId;
-  root;
-  exitCode;
-  stderrTail;
-  name = "LspProcessExitedError";
   constructor(serverId, root, exitCode, stderrTail) {
     const stderrSuffix = stderrTail ? `
 stderr tail: ${stderrTail}` : "";
@@ -523,46 +519,49 @@ stderr tail: ${stderrTail}` : "";
     this.root = root;
     this.exitCode = exitCode;
     this.stderrTail = stderrTail;
+    this.name = "LspProcessExitedError";
   }
 }
 
 class LspRequestTimeoutError extends Error {
-  method;
-  stderrTail;
-  name = "LspRequestTimeoutError";
   constructor(method, stderrTail) {
     const stderrSuffix = stderrTail ? `
 recent stderr: ${stderrTail}` : "";
     super(`LSP request timeout (method: ${method})${stderrSuffix}`);
     this.method = method;
     this.stderrTail = stderrTail;
+    this.name = "LspRequestTimeoutError";
   }
 }
 
 class LspInvalidPathError extends Error {
-  name = "LspInvalidPathError";
+  constructor() {
+    super(...arguments);
+    this.name = "LspInvalidPathError";
+  }
 }
 
 class LspServerLookupError extends Error {
-  lookup;
-  name = "LspServerLookupError";
   constructor(message, lookup) {
     super(message);
     this.lookup = lookup;
+    this.name = "LspServerLookupError";
   }
 }
 
 class LspServerInitializingError extends Error {
-  originalError;
-  name = "LspServerInitializingError";
   constructor(originalError) {
     super(`LSP server is still initializing. Please retry in a few seconds. Original error: ${originalError.message}`);
     this.originalError = originalError;
+    this.name = "LspServerInitializingError";
   }
 }
 
 class LspProcessSpawnError extends Error {
-  name = "LspProcessSpawnError";
+  constructor() {
+    super(...arguments);
+    this.name = "LspProcessSpawnError";
+  }
 }
 function isLspDeadConnectionError(err) {
   return err instanceof LspConnectionClosedError || err instanceof LspProcessExitedError;
@@ -607,20 +606,31 @@ var METHOD_NOT_FOUND = -32601;
 var INTERNAL_ERROR = -32603;
 
 class JsonRpcConnection {
-  reader;
-  writer;
-  pendingRequests = new Map;
-  notificationHandlers = new Map;
-  requestHandlers = new Map;
-  closeHandlers = [];
-  errorHandlers = [];
-  inputBuffer = Buffer.alloc(0);
-  nextRequestId = 1;
-  listening = false;
-  disposed = false;
   constructor(reader, writer) {
     this.reader = reader;
     this.writer = writer;
+    this.pendingRequests = new Map;
+    this.notificationHandlers = new Map;
+    this.requestHandlers = new Map;
+    this.closeHandlers = [];
+    this.errorHandlers = [];
+    this.inputBuffer = Buffer.alloc(0);
+    this.nextRequestId = 1;
+    this.listening = false;
+    this.disposed = false;
+    this.handleData = (chunk) => {
+      const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+      this.inputBuffer = Buffer.concat([this.inputBuffer, chunkBuffer]);
+      this.drainInputBuffer();
+    };
+    this.handleClose = () => {
+      for (const handler of this.closeHandlers) {
+        handler();
+      }
+    };
+    this.handleStreamError = (error) => {
+      this.emitError(error);
+    };
   }
   listen() {
     if (this.listening)
@@ -741,19 +751,6 @@ class JsonRpcConnection {
     this.notificationHandlers.clear();
     this.requestHandlers.clear();
   }
-  handleData = (chunk) => {
-    const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
-    this.inputBuffer = Buffer.concat([this.inputBuffer, chunkBuffer]);
-    this.drainInputBuffer();
-  };
-  handleClose = () => {
-    for (const handler of this.closeHandlers) {
-      handler();
-    }
-  };
-  handleStreamError = (error) => {
-    this.emitError(error);
-  };
   drainInputBuffer() {
     while (true) {
       const headerEnd = this.inputBuffer.indexOf(HEADER_SEPARATOR2);
@@ -1101,31 +1098,25 @@ function isPosition(value) {
 
 // ../lsp-core/src/lsp/transport.ts
 class LspClientNotStartedError extends Error {
-  serverId;
-  root;
-  name = "LspClientNotStartedError";
   constructor(serverId, root) {
     super("LSP client not started");
     this.serverId = serverId;
     this.root = root;
+    this.name = "LspClientNotStartedError";
   }
 }
 
 class LspClientTransport {
-  root;
-  server;
-  proc = null;
-  connection = null;
-  stderrBuffer = [];
-  processExited = false;
-  diagnosticsStore = new Map;
-  requestTimeoutMs;
-  initializeTimeoutMs;
-  workspaceApplyEditHandler = null;
-  diagnosticPullSupported = false;
   constructor(root, server2, timeouts = {}) {
     this.root = root;
     this.server = server2;
+    this.proc = null;
+    this.connection = null;
+    this.stderrBuffer = [];
+    this.processExited = false;
+    this.diagnosticsStore = new Map;
+    this.workspaceApplyEditHandler = null;
+    this.diagnosticPullSupported = false;
     this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
     this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
   }
@@ -1622,16 +1613,12 @@ function movedPath(candidate, oldPath, newPath) {
 }
 
 class WorkspaceDocumentState {
-  sendNotification;
-  clearDiagnostics;
-  openDocuments = new Map;
-  openByUri = new Map;
-  openPromises = new Map;
-  now;
-  versionlessPublishQuiescenceMs;
   constructor(sendNotification, clearDiagnostics, options = {}) {
     this.sendNotification = sendNotification;
     this.clearDiagnostics = clearDiagnostics;
+    this.openDocuments = new Map;
+    this.openByUri = new Map;
+    this.openPromises = new Map;
     this.now = options.now ?? (() => Date.now());
     this.versionlessPublishQuiescenceMs = options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
   }
@@ -1895,13 +1882,11 @@ import { dirname as dirname2, isAbsolute as isAbsolute2, relative as relative3,
 import { fileURLToPath } from "node:url";
 
 class WorkspaceEditPathError extends Error {
-  path;
-  detail;
-  name = "WorkspaceEditPathError";
   constructor(path, detail) {
     super(`${detail}: ${path}`);
     this.path = path;
     this.detail = detail;
+    this.name = "WorkspaceEditPathError";
   }
 }
 function isPathInsideWorkspace(filePath, workspaceRoot) {
@@ -2193,13 +2178,11 @@ function canonicalFingerprint(operations) {
 
 // ../lsp-core/src/lsp/workspace-edit-types.ts
 class WorkspaceEditValidationError extends Error {
-  changeIndex;
-  detail;
-  name = "WorkspaceEditValidationError";
   constructor(changeIndex, detail) {
     super(`change ${changeIndex}: ${detail}`);
     this.changeIndex = changeIndex;
     this.detail = detail;
+    this.name = "WorkspaceEditValidationError";
   }
 }
 
@@ -2697,10 +2680,9 @@ function simulateDelete(operation, virtual) {
 import { existsSync as existsSync5, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname4, resolve as resolve5 } from "node:path";
 class WorkspaceSnapshotBuilder {
-  workspaceRoot;
-  snapshots = new Map;
   constructor(workspaceRoot) {
     this.workspaceRoot = workspaceRoot;
+    this.snapshots = new Map;
   }
   build(operations) {
     this.add(this.workspaceRoot, false);
@@ -2744,8 +2726,10 @@ function snapshotOperations(operations, workspaceRoot) {
 
 // ../lsp-core/src/lsp/workspace-edit-plan.ts
 class PlanPathIndex {
-  firstChangeByPath = new Map;
-  reportedPathByCanonical = new Map;
+  constructor() {
+    this.firstChangeByPath = new Map;
+    this.reportedPathByCanonical = new Map;
+  }
   build(operations) {
     for (const operation of operations) {
       switch (operation.kind) {
@@ -2834,14 +2818,11 @@ function isRecord4(value) {
 }
 
 class WorkspaceMutationController {
-  workspaceRoot;
-  documents;
-  activeLease = null;
-  nextLeaseId = 1;
-  io;
   constructor(workspaceRoot, documents) {
     this.workspaceRoot = workspaceRoot;
     this.documents = documents;
+    this.activeLease = null;
+    this.nextLeaseId = 1;
   }
   setIo(io) {
     this.io = io;
@@ -2954,12 +2935,9 @@ 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.diagnosticPullErrors = [];
     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
@@ -3259,16 +3237,11 @@ function awaitWithSignal(promise, signal) {
 }
 
 class LspManager {
-  clients = new Map;
-  reaperHandle = null;
-  signalDisposer = null;
-  disposed = false;
-  idleTimeoutMs;
-  initTimeoutMs;
-  reaperIntervalMs;
-  clientFactory;
-  now;
   constructor(options = {}) {
+    this.clients = new Map;
+    this.reaperHandle = null;
+    this.signalDisposer = null;
+    this.disposed = false;
     this.idleTimeoutMs = options.idleTimeoutMs ?? IDLE_TIMEOUT_MS;
     this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS;
     this.reaperIntervalMs = options.reaperIntervalMs ?? REAPER_INTERVAL_MS;
@@ -3500,15 +3473,52 @@ async function disposeDefaultLspManager() {
   }
 }
 
+// ../lsp-core/src/lsp/outside-context-workspace.ts
+import { existsSync as existsSync6, realpathSync as realpathSync4 } from "node:fs";
+import { dirname as dirname5, join as join3 } from "node:path";
+
+// ../lsp-core/src/lsp/workspace-markers.ts
+var WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
+
+// ../lsp-core/src/lsp/outside-context-workspace.ts
+function findWorkspaceRootOutsideContext(directory) {
+  const marked = nearestMarkedAncestor(directory);
+  if (marked !== undefined)
+    return marked;
+  return realpathSync4(nearestExistingAncestor(directory));
+}
+function nearestMarkedAncestor(directory) {
+  let current = directory;
+  for (;; ) {
+    if (existsSync6(current) && WORKSPACE_MARKERS.some((marker) => existsSync6(join3(current, marker)))) {
+      return realpathSync4(current);
+    }
+    const parent = dirname5(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+}
+function nearestExistingAncestor(directory) {
+  let current = directory;
+  while (!existsSync6(current)) {
+    const parent = dirname5(current);
+    if (parent === current)
+      return current;
+    current = parent;
+  }
+  return current;
+}
+
 // ../lsp-core/src/lsp/server-install-state.ts
-import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { existsSync as existsSync7, mkdirSync, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname6 } from "node:path";
 function getInstallDecisionsPath() {
   return lspRequestContext().installDecisionsPath;
 }
 function loadInstallDecisions() {
   const path = getInstallDecisionsPath();
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return {};
   try {
     const parsed = JSON.parse(readFileSync3(path, "utf8"));
@@ -3530,7 +3540,7 @@ function isInstallDecision(value) {
 }
 function writeInstallDecisions(decisions) {
   const path = getInstallDecisionsPath();
-  mkdirSync(dirname5(path), { recursive: true });
+  mkdirSync(dirname6(path), { recursive: true });
   const tmpPath = `${path}.tmp`;
   writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
 `, "utf8");
@@ -3549,7 +3559,7 @@ function isRecord5(value) {
 }
 
 // ../lsp-core/src/lsp/config-loader.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4 } from "node:fs";
 
 // ../lsp-core/src/lsp/server-definitions.ts
 var LSP_INSTALL_HINTS = {
@@ -3706,7 +3716,7 @@ function getUserConfigPath() {
   return lspRequestContext().userConfigPath;
 }
 function loadJsonFile(path) {
-  if (!existsSync7(path))
+  if (!existsSync8(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf-8"));
@@ -3894,8 +3904,8 @@ function getDisabledServerIds() {
 }
 
 // ../lsp-core/src/lsp/server-installation.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { delimiter as delimiter3, join as join3 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { delimiter as delimiter3, join as join4 } from "node:path";
 function isServerInstalled(command, _workingDirectory) {
   if (command.length === 0)
     return false;
@@ -3903,7 +3913,7 @@ function isServerInstalled(command, _workingDirectory) {
   if (!cmd)
     return false;
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync8(cmd))
+    if (existsSync9(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -3924,7 +3934,7 @@ function isServerInstalled(command, _workingDirectory) {
   const paths = pathEnv.split(delimiter3);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync8(join3(p, cmd + suffix))) {
+      if (existsSync9(join4(p, cmd + suffix))) {
         return true;
       }
     }
@@ -4020,7 +4030,6 @@ function getAllServers() {
 }
 
 // ../lsp-core/src/lsp/client-wrapper.ts
-var WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
 function isDirectoryPath(filePath) {
   try {
     return statSync3(filePath).isDirectory();
@@ -4029,32 +4038,85 @@ function isDirectoryPath(filePath) {
   }
 }
 function findWorkspaceRoot(filePath) {
-  const abs = resolvePathInsideContext(filePath);
+  const cwd = contextCwd();
+  const abs = resolveReadablePathInsideContext(filePath);
   let dir = abs;
   if (!isDirectoryPath(dir)) {
-    dir = dirname6(dir);
-  }
-  let prevDir = "";
-  while (dir !== prevDir) {
-    for (const marker of WORKSPACE_MARKERS) {
-      if (existsSync9(join4(dir, marker))) {
-        return dir;
+    dir = dirname7(dir);
+  }
+  if (!isPathInside(cwd, abs))
+    return findWorkspaceRootOutsideContext(dir);
+  const fallbackRoot = nearestExistingDirectoryInsideContext(dir, cwd) ?? cwd;
+  while (isPathInside(cwd, dir)) {
+    const canonicalDir = existingDirectoryInsideContext(dir, cwd);
+    if (canonicalDir !== undefined) {
+      for (const marker of WORKSPACE_MARKERS) {
+        if (existsSync10(join5(dir, marker))) {
+          return canonicalDir;
+        }
       }
     }
-    prevDir = dir;
-    dir = dirname6(dir);
+    if (dir === cwd)
+      break;
+    dir = dirname7(dir);
   }
-  return dirname6(abs);
+  return fallbackRoot;
 }
-function resolvePathInsideContext(filePath) {
+function resolveReadablePathInsideContext(filePath) {
   const cwd = contextCwd();
   const abs = resolve7(cwd, filePath);
+  if (isPathInside(cwd, abs))
+    return abs;
+  const rebased = rebaseThroughCanonicalAncestor(abs, cwd);
+  if (rebased !== undefined)
+    return rebased;
+  return canonicalizeExistingOrNearestAncestor(abs);
+}
+function resolvePathInsideContext(filePath) {
+  const cwd = contextCwd();
+  const abs = resolveReadablePathInsideContext(filePath);
   const canonical = canonicalizeExistingOrNearestAncestor(abs);
   if (!isPathInside(cwd, canonical)) {
     throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
   }
   return canonical;
 }
+function rebaseThroughCanonicalAncestor(path, cwd) {
+  let current = path;
+  const suffix = [];
+  while (true) {
+    if (existsSync10(current)) {
+      const canonical = realpathSync5(current);
+      if (isPathInside(cwd, canonical))
+        return suffix.length === 0 ? canonical : join5(canonical, ...suffix);
+    }
+    const parent = dirname7(current);
+    if (parent === current)
+      return;
+    suffix.unshift(basename3(current));
+    current = parent;
+  }
+}
+function existingDirectoryInsideContext(directory, cwd) {
+  if (!existsSync10(directory))
+    return;
+  const canonical = realpathSync5(directory);
+  if (!statSync3(canonical).isDirectory())
+    return;
+  return isPathInside(cwd, canonical) ? canonical : undefined;
+}
+function nearestExistingDirectoryInsideContext(directory, cwd) {
+  let current = directory;
+  while (isPathInside(cwd, current)) {
+    const canonical = existingDirectoryInsideContext(current, cwd);
+    if (canonical !== undefined)
+      return canonical;
+    if (current === cwd)
+      return;
+    current = dirname7(current);
+  }
+  return;
+}
 function formatServerLookupError(result) {
   if (result.status === "not_installed") {
     return formatNotInstalled(result);
@@ -4125,7 +4187,7 @@ function formatNotInstalled(result) {
   ].join(`
 `);
 }
-var READ_ONLY_RETRY_TOOLS = new Set([
+var READ_ONLY_TOOLS = new Set([
   "diagnostics",
   "definition",
   "references",
@@ -4134,7 +4196,7 @@ var READ_ONLY_RETRY_TOOLS = new Set([
   "prepareRename"
 ]);
 async function withLspClient(filePath, fn, toolName, options = {}) {
-  const absPath = resolvePathInsideContext(filePath);
+  const absPath = READ_ONLY_TOOLS.has(toolName) ? resolveReadablePathInsideContext(filePath) : resolvePathInsideContext(filePath);
   if (isDirectoryPath(absPath)) {
     throw new LspInvalidPathError("Directory paths are not supported by this LSP tool. " + "Use lsp.diagnostics with a directory path for directory diagnostics.");
   }
@@ -4149,9 +4211,9 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
   const acquireAndCall = async (allowRetry) => {
     const client = await manager.getClient(root, server2, options.signal);
     try {
-      return await fn(client, root);
+      return await fn(client, root, absPath);
     } catch (err) {
-      if (allowRetry && READ_ONLY_RETRY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
+      if (allowRetry && READ_ONLY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
         manager.invalidateClient(root, server2.id, client);
         return acquireAndCall(false);
       }
@@ -4169,8 +4231,8 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
 }
 
 // ../lsp-core/src/lsp/directory-diagnostics.ts
-import { existsSync as existsSync10, lstatSync as lstatSync4, readdirSync as readdirSync3 } from "node:fs";
-import { join as join5, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync11, lstatSync as lstatSync4, readdirSync as readdirSync3 } from "node:fs";
+import { join as join6, resolve as resolve8 } from "node:path";
 
 // ../lsp-core/src/lsp/formatters.ts
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -4300,7 +4362,7 @@ function collectFilesWithExtension(dir, extension, maxFiles) {
     for (const entry of entries) {
       if (files.length >= maxFiles)
         return;
-      const fullPath = join5(currentDir, entry);
+      const fullPath = join6(currentDir, entry);
       let stat;
       try {
         stat = lstatSync4(fullPath);
@@ -4326,7 +4388,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
     throw new LspInvalidPathError(`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`);
   }
   const absDir = resolve8(options.workspaceRoot ?? contextCwd(), directory);
-  if (!existsSync10(absDir)) {
+  if (!existsSync11(absDir)) {
     throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
   }
   const serverResult = options.server === undefined ? findServerForExtension(extension) : { status: "found", server: options.server };
@@ -4413,7 +4475,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
 
 // ../lsp-core/src/lsp/infer-extension.ts
 import { lstatSync as lstatSync5, readdirSync as readdirSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var SKIP_DIRECTORIES2 = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
 var MAX_SCAN_ENTRIES = 500;
 function inferExtensionFromDirectory(directory) {
@@ -4431,7 +4493,7 @@ function inferExtensionFromDirectory(directory) {
     for (const entry of entries) {
       if (scanned >= MAX_SCAN_ENTRIES)
         return;
-      const fullPath = join6(dir, entry);
+      const fullPath = join7(dir, entry);
       let stat;
       try {
         stat = lstatSync5(fullPath);
@@ -4606,7 +4668,7 @@ async function executeLspDiagnostics(params, signal) {
   const filePath = requireString(params, "filePath");
   const severity = severityFilter(params);
   try {
-    const absPath = resolvePathInsideContext(filePath);
+    const absPath = resolveReadablePathInsideContext(filePath);
     if (isDirectoryPath(absPath)) {
       const extension = inferExtensionFromDirectory(absPath);
       if (!extension) {
@@ -4635,7 +4697,7 @@ async function executeLspDiagnostics(params, signal) {
       };
       return text(output2.output, details2);
     }
-    const result = await withLspClient(filePath, async (client) => client.diagnostics(filePath, signal), "diagnostics", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.diagnostics(resolvedFilePath, signal), "diagnostics", clientOptions(signal));
     if (result.transientError) {
       const message = result.transientError.message;
       const details2 = {
@@ -4710,7 +4772,7 @@ async function executeLspGotoDefinition(params, signal) {
   const line = requireNumber(params, "line");
   const character = requireNumber(params, "character");
   try {
-    const result = await withLspClient(filePath, async (client) => client.definition(filePath, line, character, signal), "definition", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.definition(resolvedFilePath, line, character, signal), "definition", clientOptions(signal));
     const locations = !result ? [] : Array.isArray(result) ? result : [result];
     const details = { filePath, line, character, locations };
     if (locations.length === 0)
@@ -4735,7 +4797,7 @@ async function executeLspFindReferences(params, signal) {
   const character = requireNumber(params, "character");
   const includeDeclaration = optionalBoolean(params, "includeDeclaration") ?? true;
   try {
-    const result = await withLspClient(filePath, async (client) => client.references(filePath, line, character, includeDeclaration, signal), "references", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.references(resolvedFilePath, line, character, includeDeclaration, signal), "references", clientOptions(signal));
     const references = Array.isArray(result) ? result : [];
     const total = references.length;
     const truncated = total > DEFAULT_MAX_REFERENCES;
@@ -4777,7 +4839,7 @@ async function executeLspPrepareRename(params, signal) {
   const line = requireNumber(params, "line");
   const character = requireNumber(params, "character");
   try {
-    const result = await withLspClient(filePath, async (client) => client.prepareRename(filePath, line, character, signal), "prepareRename", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.prepareRename(resolvedFilePath, line, character, signal), "prepareRename", clientOptions(signal));
     const details = { filePath, line, character, result };
     return text(formatPrepareRenameResult(result), details);
   } catch (error) {
@@ -4798,7 +4860,7 @@ async function executeLspRename(params, signal) {
   const character = requireNumber(params, "character");
   const newName = requireString(params, "newName");
   try {
-    const result = await withLspClient(filePath, async (client) => client.rename(filePath, line, character, newName, signal), "rename", clientOptions(signal));
+    const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.rename(resolvedFilePath, line, character, newName, signal), "rename", clientOptions(signal));
     const details = { filePath, line, character, newName, apply: result.apply, edit: result.edit };
     return text(formatApplyResult(result.apply), details, !result.apply.success);
   } catch (error) {
@@ -4878,7 +4940,7 @@ async function executeLspSymbols(params, signal) {
       const symbols2 = await withLspClient(filePath, async (client) => client.workspaceSymbols(query, signal), "workspaceSymbols", clientOptions(signal));
       return formatSymbolsResult(filePath, scope, symbols2, limit, query);
     }
-    const symbols = await withLspClient(filePath, async (client) => client.documentSymbols(filePath, signal), "documentSymbols", clientOptions(signal));
+    const symbols = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal), "documentSymbols", clientOptions(signal));
     return formatSymbolsResult(filePath, scope, symbols, limit);
   } catch (error) {
     const query = optionalString(params, "query");
@@ -5113,11 +5175,10 @@ function requestedProtocolVersion(params) {
 // src/daemon-client.ts
 import { connect } from "node:net";
 import { homedir as homedir3 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/daemon-request-error.ts
 class DaemonRequestError extends Error {
-  requestWritten;
   constructor(message, requestWritten) {
     super(message);
     this.name = "DaemonRequestError";
@@ -5140,7 +5201,6 @@ class DaemonRequestCancelledError extends DaemonRequestError {
 }
 
 class DaemonRequestTimedOutError extends DaemonRequestError {
-  timeoutMs;
   constructor(requestWritten, timeoutMs) {
     super("daemon request timed out", requestWritten);
     this.name = "DaemonRequestTimedOutError";
@@ -5192,9 +5252,9 @@ function errorText(error) {
 
 // src/ensure-daemon.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync11, mkdirSync as mkdirSync3, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync12, mkdirSync as mkdirSync3, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
 import { Socket } from "node:net";
-import { dirname as dirname8, isAbsolute as isAbsolute4 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute4 } from "node:path";
 import { argv0, execPath } from "node:process";
 
 // src/ipc-protocol.ts
@@ -5212,21 +5272,19 @@ import {
   unlinkSync,
   writeSync
 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { dirname as dirname8 } from "node:path";
 var OMO_DAEMON_PROTOCOL_VERSION = 1;
 var AUTH_ERROR_CODE = -32001;
 var PROTOCOL_ERROR_CODE = -32002;
 var AUTH_TOKEN_BYTES = 32;
 
 class UnsafePrivateDirectoryError extends Error {
-  path;
-  reason;
-  name = "UnsafePrivateDirectoryError";
-  code = "unsafe_private_directory";
   constructor(path, reason) {
     super(`unsafe private directory ${path}: ${reason}`);
     this.path = path;
     this.reason = reason;
+    this.name = "UnsafePrivateDirectoryError";
+    this.code = "unsafe_private_directory";
   }
 }
 function authEnvelope(token) {
@@ -5322,7 +5380,7 @@ function setPrivateFileMode(path) {
     chmodSync(path, 384);
 }
 function createAuthToken(paths) {
-  ensurePrivateDirectory(dirname7(paths.auth));
+  ensurePrivateDirectory(dirname8(paths.auth));
   const token = randomBytes(AUTH_TOKEN_BYTES).toString("base64url");
   let fd;
   try {
@@ -5410,20 +5468,18 @@ var OMO_LSP_DAEMON_VERSION = "OMO_LSP_DAEMON_VERSION";
 var DAEMON_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
 
 class InvalidRuntimeOverrideError extends Error {
-  code = "invalid_runtime_override";
-  reason;
   constructor(reason, message) {
     super(message);
+    this.code = "invalid_runtime_override";
     this.name = "InvalidRuntimeOverrideError";
     this.reason = reason;
   }
 }
 
 class InvalidDaemonVersionError extends Error {
-  code = "invalid_daemon_version";
-  version;
   constructor(version) {
     super("LSP daemon version must match [A-Za-z0-9][A-Za-z0-9._+-]{0,127}");
+    this.code = "invalid_daemon_version";
     this.name = "InvalidDaemonVersionError";
     this.version = version;
   }
@@ -5469,10 +5525,9 @@ var requireFromHere = createRequire(import.meta.url);
 var MAX_SOCKET_PATH_LENGTH = 100;
 
 class InvalidDaemonDirectoryError extends Error {
-  code = "invalid_daemon_directory";
-  directory;
   constructor(directory) {
     super(`${OMO_LSP_DAEMON_DIR} must be an absolute path`);
+    this.code = "invalid_daemon_directory";
     this.name = "InvalidDaemonDirectoryError";
     this.directory = directory;
   }
@@ -5662,12 +5717,13 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   });
 }
 function spawnDaemonProcess(paths) {
-  mkdirSync3(dirname8(paths.log), { recursive: true });
+  mkdirSync3(dirname9(paths.log), { recursive: true });
   const logFd = openSync2(paths.log, "a");
   try {
     const child = spawn2(resolveDaemonNodeExecutable(), [paths.cliPath, "daemon"], {
       detached: true,
-      stdio: ["ignore", logFd, logFd]
+      stdio: ["ignore", logFd, logFd],
+      windowsHide: true
     });
     child.once("spawn", () => closeSync2(logFd));
     child.once("error", (error) => {
@@ -5681,7 +5737,7 @@ function spawnDaemonProcess(paths) {
     throw error;
   }
 }
-function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync11) {
+function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync12) {
   if (pathExists(cachedExecPath))
     return cachedExecPath;
   if (isAbsolute4(originalArgv0) && pathExists(originalArgv0))
@@ -5780,7 +5836,10 @@ function parsePingResponse(message) {
 var CONTEXT_KEY = "_context";
 
 class InvalidDaemonRequestError extends Error {
-  name = "InvalidDaemonRequestError";
+  constructor() {
+    super(...arguments);
+    this.name = "InvalidDaemonRequestError";
+  }
 }
 function extractRequestContext(raw) {
   if (!isPlainRecord(raw) || raw["method"] !== "tools/call")
@@ -5901,9 +5960,9 @@ function currentRequestContext(env = process.env) {
   const home = env["HOME"] ?? homedir3();
   return parseLspRequestContext({
     cwd,
-    projectConfigPaths: [join7(cwd, ".codex", "lsp-client.json")],
-    userConfigPath: join7(home, ".codex", "lsp-client.json"),
-    installDecisionsPath: join7(home, ".codex", "lsp-install-decisions.json"),
+    projectConfigPaths: [join8(cwd, ".codex", "lsp-client.json")],
+    userConfigPath: join8(home, ".codex", "lsp-client.json"),
+    installDecisionsPath: join8(home, ".codex", "lsp-install-decisions.json"),
     capabilities: { installDecisionTool: true }
   });
 }
@@ -6158,18 +6217,18 @@ function canonicalizePathList(value) {
   return value.split(delimiter4).map((entry) => canonicalizePath(entry) ?? entry).join(delimiter4);
 }
 function canonicalizePath(value) {
-  if (value === undefined || !isAbsolute5(value) || !existsSync12(value))
+  if (value === undefined || !isAbsolute5(value) || !existsSync13(value))
     return value;
-  return realpathSync4(value);
+  return realpathSync6(value);
 }
 function projectRootFromOpenCodeConfigPath(path2) {
-  if (basename3(path2) !== "lsp.json" && basename3(path2) !== "lsp-client.json")
+  if (basename4(path2) !== "lsp.json" && basename4(path2) !== "lsp-client.json")
     return;
-  const configDir = dirname9(path2);
-  const configDirName = basename3(configDir);
+  const configDir = dirname10(path2);
+  const configDirName = basename4(configDir);
   if (configDirName !== ".opencode" && configDirName !== ".omo")
     return;
-  return dirname9(configDir);
+  return dirname10(configDir);
 }
 
 // src/daemon-server.ts
@@ -6178,12 +6237,12 @@ import { createServer as createServer2 } from "node:net";
 
 // src/ownership.ts
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync13, lstatSync as lstatSync7, readFileSync as readFileSync7, statSync as statSync5, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { existsSync as existsSync14, lstatSync as lstatSync7, readFileSync as readFileSync7, statSync as statSync5, unlinkSync as unlinkSync3 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
 
 // src/lock.ts
 import { closeSync as closeSync3, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeSync as writeSync3 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
+import { dirname as dirname11 } from "node:path";
 function isProcessAlive2(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return false;
@@ -6205,7 +6264,7 @@ function readLockPid(lockPath) {
   }
 }
 function tryAcquireLock(lockPath, ownerPid = process.pid) {
-  mkdirSync4(dirname10(lockPath), { recursive: true });
+  mkdirSync4(dirname11(lockPath), { recursive: true });
   for (let attempt = 0;attempt < 2; attempt += 1) {
     const handle = writeLockFile(lockPath, ownerPid);
     if (handle)
@@ -6253,17 +6312,19 @@ function errorCode3(error) {
 
 // src/ownership.ts
 class DaemonAlreadyRunningError extends Error {
-  name = "DaemonAlreadyRunningError";
-  code = "daemon_already_running";
+  constructor() {
+    super(...arguments);
+    this.name = "DaemonAlreadyRunningError";
+    this.code = "daemon_already_running";
+  }
 }
 
 class DaemonStartupDeferredError extends Error {
-  reason;
-  name = "DaemonStartupDeferredError";
-  code = "daemon_startup_deferred";
   constructor(reason) {
     super(`LSP daemon startup deferred: ${reason}`);
     this.reason = reason;
+    this.name = "DaemonStartupDeferredError";
+    this.code = "daemon_startup_deferred";
   }
 }
 async function acquireStartupLease(paths, pingOwner) {
@@ -6286,7 +6347,7 @@ async function acquireStartupLease(paths, pingOwner) {
 function ensureDaemonDirectories(paths) {
   ensurePrivateDirectory(paths.dir);
   if (process.platform !== "win32")
-    ensurePrivateDirectory(dirname11(paths.socket));
+    ensurePrivateDirectory(dirname12(paths.socket));
 }
 function readDaemonOwner(paths) {
   try {
@@ -6366,7 +6427,7 @@ async function validateExistingOwner(paths, pingOwner) {
   throw new DaemonStartupDeferredError("reachable_owner_mismatch");
 }
 function cleanupDeadOwner(paths, owner) {
-  if (process.platform !== "win32" && existsSync13(owner.endpoint.path)) {
+  if (process.platform !== "win32" && existsSync14(owner.endpoint.path)) {
     const stat = lstatSync7(owner.endpoint.path);
     if (stat.isSocket())
       unlinkSync3(owner.endpoint.path);
@@ -6417,7 +6478,7 @@ function parseEndpoint(value) {
 // src/version-reap.ts
 import { execFile } from "node:child_process";
 import { readdir, readFile, rm } from "node:fs/promises";
-import { basename as basename4, dirname as dirname12, join as join8 } from "node:path";
+import { basename as basename5, dirname as dirname13, join as join9 } from "node:path";
 var TERM_GRACE_MS = 5000;
 var KILL_GRACE_MS = 1000;
 var VERSION_ENTRY_PATTERN = /^v([A-Za-z0-9][A-Za-z0-9._+-]{0,127})$/;
@@ -6438,7 +6499,7 @@ async function attestDaemonCliProcess(pid, platform, deps = {}) {
   return isNodeCliDaemonCommand(command.trim());
 }
 async function reapStaleDaemonVersions(ownPaths, deps = {}) {
-  const baseDir = dirname12(ownPaths.dir);
+  const baseDir = dirname13(ownPaths.dir);
   const platform = deps.platform ?? process.platform;
   const isAlive = deps.isAlive ?? isProcessAlive2;
   const attest = deps.attest ?? ((pid) => attestDaemonCliProcess(pid, platform));
@@ -6457,7 +6518,7 @@ async function reapStaleDaemonVersions(ownPaths, deps = {}) {
     const version = parseVersionEntry(entry.name);
     if (version === null || !entry.isDirectory())
       continue;
-    const versionDir = join8(baseDir, entry.name);
+    const versionDir = join9(baseDir, entry.name);
     const siblingPaths = daemonPaths({ [OMO_LSP_DAEMON_DIR]: baseDir }, { cliPath: ownPaths.cliPath, version });
     results.push(await reapOneVersion({
       version,
@@ -6481,7 +6542,7 @@ async function reapOneVersion(context) {
   const { version, versionDir } = context;
   const owner = context.readOwner(context.siblingPaths);
   if (!owner) {
-    const lockPid = readLockPid(join8(versionDir, "daemon.lock"));
+    const lockPid = readLockPid(join9(versionDir, "daemon.lock"));
     if (lockPid !== null && context.isAlive(lockPid)) {
       context.log(`reap: sparing v${version}: owner metadata missing but daemon.lock is held by live pid ${lockPid}`);
       return { version, status: "spared", reason: `owner metadata missing but lock held by live pid ${lockPid}` };
@@ -6547,7 +6608,7 @@ function splitCmdline(buffer) {
 function isNodeCliDaemonArgv(argv) {
   if (argv.length < 2 || !argv.includes("daemon"))
     return false;
-  const executable = basename4(argv[0] ?? "");
+  const executable = basename5(argv[0] ?? "");
   if (!/^node(?:\.exe)?$/i.test(executable))
     return false;
   return argv.some((value) => value === "cli.js" || value.endsWith("/cli.js") || value.endsWith("\\cli.js"));
@@ -6560,7 +6621,7 @@ function defaultReadProcFile(path2) {
 }
 function defaultExecuteForStdout(file, args) {
   return new Promise((resolve9) => {
-    execFile(file, [...args], { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: 1000 }, (error, stdout) => {
+    execFile(file, [...args], { encoding: "utf8", maxBuffer: 1024 * 1024, timeout: 1000, windowsHide: true }, (error, stdout) => {
       if (error !== null) {
         resolve9(null);
         return;