lazycodex-ai 5.0.0-beta.49 → 5.0.0-beta.50

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

@@ -8,9 +8,9 @@ import { argv, execPath as execPath2, stderr } from "node:process";
 import { stdin as processStdin } from "node:process";
 
 // src/codex-hook.ts
-import { readFileSync as readFileSync10, realpathSync as realpathSync8 } from "node:fs";
+import { readFileSync as readFileSync9, realpathSync as realpathSync7 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join12, resolve as resolve12 } from "node:path";
+import { join as join11, resolve as resolve11 } from "node:path";
 
 // ../../../../lsp-daemon/dist/client.js
 import { statSync as statSync5 } from "node:fs";
@@ -115,18 +115,18 @@ function parseLspRequestContext(value) {
   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);
+  for (const path of projectConfigPaths) {
+    requireAbsolutePath(path, "projectConfigPaths");
+    const projectPath = canonicalizeExistingOrNearestAncestor(path);
     if (!isPathInside(canonical, projectPath)) {
-      throw new LspRequestContextParseError("project_config_outside_cwd", `Project LSP config path must be inside cwd: ${path2}`);
+      throw new LspRequestContextParseError("project_config_outside_cwd", `Project LSP config path must be inside cwd: ${path}`);
     }
   }
   requireAbsolutePath(userConfigPath, "userConfigPath");
   requireAbsolutePath(installDecisionsPath, "installDecisionsPath");
   return {
     cwd: canonical,
-    projectConfigPaths: projectConfigPaths.map((path2) => canonicalizeExistingOrNearestAncestor(path2)),
+    projectConfigPaths: projectConfigPaths.map((path) => canonicalizeExistingOrNearestAncestor(path)),
     userConfigPath,
     installDecisionsPath,
     capabilities
@@ -139,8 +139,8 @@ function canonicalCwd(cwd) {
   }
   return realpathSync(resolved);
 }
-function canonicalizeExistingOrNearestAncestor(path2) {
-  let current = resolve(path2);
+function canonicalizeExistingOrNearestAncestor(path) {
+  let current = resolve(path);
   const suffix = [];
   while (true) {
     try {
@@ -182,9 +182,9 @@ function stringArrayField(value, field) {
   }
   return fieldValue;
 }
-function requireAbsolutePath(path2, field) {
-  if (!isAbsolute(path2)) {
-    throw new LspRequestContextParseError("relative_path", `LSP request context.${field} must be absolute: ${path2}`);
+function requireAbsolutePath(path, field) {
+  if (!isAbsolute(path)) {
+    throw new LspRequestContextParseError("relative_path", `LSP request context.${field} must be absolute: ${path}`);
   }
 }
 function isPathInside(parent, child) {
@@ -521,7 +521,7 @@ async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   return await pingDaemon(paths, token, timeoutMs, signal) !== null;
 }
 function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
-  return new Promise((resolve22) => {
+  return new Promise((resolve) => {
     const socket = new Socket;
     let settled = false;
     let timer;
@@ -533,7 +533,7 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
         clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
       socket.destroy();
-      resolve22(value);
+      resolve(value);
     };
     const onAbort = () => finish(null);
     const decoder = createLineDecoder((message) => {
@@ -596,7 +596,7 @@ function defaultEnsureDaemonDeps() {
   };
 }
 function sleepWithSignal(ms, signal) {
-  return new Promise((resolve22) => {
+  return new Promise((resolve) => {
     let settled = false;
     const finish = () => {
       if (settled)
@@ -604,7 +604,7 @@ function sleepWithSignal(ms, signal) {
       settled = true;
       clearTimeout(timer);
       signal?.removeEventListener("abort", finish);
-      resolve22();
+      resolve();
     };
     const timer = setTimeout(finish, ms);
     if (signal?.aborted) {
@@ -619,7 +619,7 @@ function awaitWithSignal(promise, signal) {
     return promise;
   if (signal.aborted)
     return Promise.reject(abortError(signal));
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const finish = (run) => {
       if (settled)
@@ -630,7 +630,7 @@ function awaitWithSignal(promise, signal) {
     };
     const onAbort = () => finish(() => reject(abortError(signal)));
     signal.addEventListener("abort", onAbort, { once: true });
-    promise.then((value) => finish(() => resolve22(value)), (error) => finish(() => reject(error)));
+    promise.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
   });
 }
 function throwIfAborted(signal) {
@@ -659,18 +659,18 @@ function parsePingResponse(message) {
     return null;
   if (!endpoint || typeof endpoint !== "object" || Array.isArray(endpoint))
     return null;
-  const path2 = Reflect.get(endpoint, "path");
+  const path = Reflect.get(endpoint, "path");
   const kind = Reflect.get(endpoint, "kind");
-  if (typeof path2 !== "string")
+  if (typeof path !== "string")
     return null;
   if (kind === "windows")
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2 } };
+    return { pid, nonce, startedAt, endpoint: { kind, path } };
   if (kind === "missing")
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2 } };
+    return { pid, nonce, startedAt, endpoint: { kind, path } };
   const dev = Reflect.get(endpoint, "dev");
   const ino = Reflect.get(endpoint, "ino");
   if (kind === "unix" && typeof dev === "number" && typeof ino === "number") {
-    return { pid, nonce, startedAt, endpoint: { kind, path: path2, dev, ino } };
+    return { pid, nonce, startedAt, endpoint: { kind, path, dev, ino } };
   }
   return null;
 }
@@ -856,7 +856,7 @@ class JsonRpcConnection {
     let settled = false;
     const writeCancel = () => this.writeMessage({ jsonrpc: "2.0", method: "$/cancelRequest", params: { id } });
     let rejectAfterCancelWrite;
-    const responsePromise = new Promise((resolve22, reject) => {
+    const responsePromise = new Promise((resolve, reject) => {
       const cleanup = () => {
         options.signal?.removeEventListener("abort", onAbort);
       };
@@ -886,7 +886,7 @@ class JsonRpcConnection {
         resolve(result) {
           settled = true;
           cleanup();
-          resolve22(result);
+          resolve(result);
         },
         reject(error) {
           settled = true;
@@ -1045,13 +1045,13 @@ class JsonRpcConnection {
     const payload = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
 \r
 ${body}`;
-    return new Promise((resolve22, reject) => {
+    return new Promise((resolve, reject) => {
       this.writer.write(payload, (error) => {
         if (error) {
           reject(error);
           return;
         }
-        resolve22();
+        resolve();
       });
     });
   }
@@ -1133,9 +1133,9 @@ function validateCwd(cwd) {
   }
 }
 function wrap(proc) {
-  const exitedPromise = new Promise((resolve22) => {
-    proc.once("close", (code) => resolve22(code ?? 0));
-    proc.once("error", () => resolve22(1));
+  const exitedPromise = new Promise((resolve) => {
+    proc.once("close", (code) => resolve(code ?? 0));
+    proc.once("error", () => resolve(1));
   });
   if (!proc.stdin || !proc.stdout || !proc.stderr) {
     throw new LspProcessSpawnError("Spawned process is missing one of stdin/stdout/stderr pipes");
@@ -1294,9 +1294,9 @@ class LspClientNotStartedError extends Error {
 }
 
 class LspClientTransport {
-  constructor(root, server2, timeouts = {}) {
+  constructor(root, server, timeouts = {}) {
     this.root = root;
-    this.server = server2;
+    this.server = server;
     this.proc = null;
     this.connection = null;
     this.stderrBuffer = [];
@@ -1478,8 +1478,8 @@ class LspClientTransport {
       try {
         proc.kill();
         let timeoutId;
-        const timeoutPromise = new Promise((resolve22) => {
-          timeoutId = setTimeout(resolve22, STOP_HARD_KILL_TIMEOUT_MS);
+        const timeoutPromise = new Promise((resolve) => {
+          timeoutId = setTimeout(resolve, STOP_HARD_KILL_TIMEOUT_MS);
         });
         await Promise.race([
           proc.exited.then(() => {
@@ -1495,7 +1495,7 @@ class LspClientTransport {
             proc.kill("SIGKILL");
             await Promise.race([
               proc.exited,
-              new Promise((resolve22) => setTimeout(resolve22, STOP_SIGKILL_GRACE_MS))
+              new Promise((resolve) => setTimeout(resolve, STOP_SIGKILL_GRACE_MS))
             ]);
           } catch (error) {
             reportBestEffortCleanupError("hard process kill", error instanceof Error ? error : String(error));
@@ -1833,16 +1833,16 @@ class WorkspaceDocumentState {
     this.versionlessPublishQuiescenceMs = options.versionlessPublishQuiescenceMs ?? DEFAULT_VERSIONLESS_PUBLISH_QUIESCENCE_MS;
   }
   async openFile(filePath) {
-    const path2 = canonicalPath(filePath);
-    const existingOpen = this.openPromises.get(path2);
+    const path = canonicalPath(filePath);
+    const existingOpen = this.openPromises.get(path);
     if (existingOpen) {
       await existingOpen;
-      return this.openFile(path2);
+      return this.openFile(path);
     }
-    const text = readFileSync2(path2, "utf-8");
-    const existing = this.openDocuments.get(path2);
+    const text = readFileSync2(path, "utf-8");
+    const existing = this.openDocuments.get(path);
     if (!existing)
-      return this.openDocumentSingleFlight(path2, text);
+      return this.openDocumentSingleFlight(path, text);
     if (existing.text === text)
       return;
     await this.changeDocument(existing, text);
@@ -1937,7 +1937,7 @@ class WorkspaceDocumentState {
     });
   }
   validateVersions(operations) {
-    const versions = new Map([...this.openDocuments].map(([path2, state]) => [path2, state.version]));
+    const versions = new Map([...this.openDocuments].map(([path, state]) => [path, state.version]));
     for (const operation of operations) {
       if (operation.kind === "text") {
         const current = versions.get(operation.path);
@@ -1953,17 +1953,17 @@ class WorkspaceDocumentState {
         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);
+        const moved = [...versions].filter(([path]) => isSameOrDescendant(path, operation.oldPath));
+        for (const [path] of moved)
+          versions.delete(path);
+        for (const [path] of moved)
+          versions.set(movedPath(path, operation.oldPath, operation.newPath), 1);
         continue;
       }
       if (operation.kind === "delete") {
-        for (const path2 of [...versions.keys()]) {
-          if (isSameOrDescendant(path2, operation.path))
-            versions.delete(path2);
+        for (const path of [...versions.keys()]) {
+          if (isSameOrDescendant(path, operation.path))
+            versions.delete(path);
         }
         continue;
       }
@@ -2007,8 +2007,8 @@ class WorkspaceDocumentState {
       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"));
+        const path = movedPath(state.path, mutation.oldPath, mutation.newPath);
+        await this.openDocumentSingleFlight(path, readFileSync2(path, "utf-8"));
       }
       if (moved.length === 0) {
         watched.push({ uri: pathToFileURL2(mutation.oldPath).href, type: 3 });
@@ -2022,31 +2022,31 @@ class WorkspaceDocumentState {
     if (removed.length === 0)
       watched.push({ uri: pathToFileURL2(mutation.path).href, type: 3 });
   }
-  async openDocumentSingleFlight(path2, text) {
-    const existing = this.openPromises.get(path2);
+  async openDocumentSingleFlight(path, text) {
+    const existing = this.openPromises.get(path);
     if (existing)
       return existing;
     const open = (async () => {
       const state = {
-        path: path2,
-        uri: pathToFileURL2(path2).href,
-        languageId: getLanguageId(effectiveExtension(path2)),
+        path,
+        uri: pathToFileURL2(path).href,
+        languageId: getLanguageId(effectiveExtension(path)),
         text,
         version: 1,
         generation: 1,
         publishGeneration: 0,
         waiters: new Set
       };
-      this.openDocuments.set(path2, state);
+      this.openDocuments.set(path, state);
       this.openByUri.set(normalizeDocumentUri(state.uri), state);
       this.notifyWaiters(state);
       await this.sendNotification("textDocument/didOpen", {
         textDocument: { uri: state.uri, languageId: state.languageId, version: state.version, text }
       });
     })().finally(() => {
-      this.openPromises.delete(path2);
+      this.openPromises.delete(path);
     });
-    this.openPromises.set(path2, open);
+    this.openPromises.set(path, open);
     return open;
   }
   async changeDocument(state, text) {
@@ -2082,9 +2082,9 @@ function workspaceApplyEditConcurrentFailureReason(phase) {
 }
 
 class WorkspaceEditPathError extends Error {
-  constructor(path2, detail) {
-    super(`${detail}: ${path2}`);
-    this.path = path2;
+  constructor(path, detail) {
+    super(`${detail}: ${path}`);
+    this.path = path;
     this.detail = detail;
     this.name = "WorkspaceEditPathError";
   }
@@ -2148,26 +2148,26 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
     return { success: false, error: `${requestedPath}: ${detail}` };
   }
 }
-function snapshotPath(path2, includeChildren) {
-  if (!existsSync4(path2))
+function snapshotPath(path, includeChildren) {
+  if (!existsSync4(path))
     return { kind: "missing" };
-  const stats = lstatSync2(path2);
+  const stats = lstatSync2(path);
   if (stats.isFile())
-    return { kind: "file", content: readFileSync3(path2, "utf-8") };
+    return { kind: "file", content: readFileSync3(path, "utf-8") };
   if (stats.isDirectory()) {
-    return includeChildren ? { kind: "directory", children: readdirSync(path2).sort() } : { kind: "directory" };
+    return includeChildren ? { kind: "directory", children: readdirSync(path).sort() } : { kind: "directory" };
   }
-  throw new WorkspaceEditPathError(path2, "unsupported filesystem entry");
+  throw new WorkspaceEditPathError(path, "unsupported filesystem entry");
 }
 var DEFAULT_IO = {
-  writeFile(path2, content) {
-    writeFileSync(path2, content, "utf-8");
+  writeFile(path, content) {
+    writeFileSync(path, content, "utf-8");
   },
   rename(oldPath, newPath) {
     renameSync(oldPath, newPath);
   },
-  remove(path2, recursive) {
-    rmSync(path2, { recursive, force: false });
+  remove(path, recursive) {
+    rmSync(path, { recursive, force: false });
   }
 };
 function snapshotsEqual(expected, actual) {
@@ -2180,8 +2180,8 @@ function snapshotsEqual(expected, actual) {
   }
   return true;
 }
-function liveSnapshot(path2, expected) {
-  return snapshotPath(path2, expected.kind === "directory" && expected.children !== undefined);
+function liveSnapshot(path, expected) {
+  return snapshotPath(path, expected.kind === "directory" && expected.children !== undefined);
 }
 function firstOperationIndex(plan) {
   return plan.operations[0]?.changeIndex ?? 0;
@@ -2202,28 +2202,28 @@ function failedCommit(plan, failure) {
   };
 }
 function verifySnapshots(plan) {
-  for (const [path2, expected] of plan.snapshots) {
+  for (const [path, expected] of plan.snapshots) {
     let actual;
     try {
-      actual = liveSnapshot(path2, expected);
+      actual = liveSnapshot(path, expected);
     } catch (error) {
-      const changeIndex = plan.firstChangeByPath.get(path2) ?? firstOperationIndex(plan);
+      const changeIndex = plan.firstChangeByPath.get(path) ?? firstOperationIndex(plan);
       const detail = error instanceof Error ? error.message : String(error);
-      return failedCommit(plan, { message: `cannot verify snapshot for ${path2}: ${detail}`, changeIndex });
+      return failedCommit(plan, { message: `cannot verify snapshot for ${path}: ${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 });
+      const changeIndex = plan.firstChangeByPath.get(path) ?? firstOperationIndex(plan);
+      return failedCommit(plan, { message: `workspace state changed before commit: ${path}`, changeIndex });
     }
   }
   return null;
 }
-function addModifiedPath(paths, path2) {
-  if (!paths.includes(path2))
-    paths.push(path2);
+function addModifiedPath(paths, path) {
+  if (!paths.includes(path))
+    paths.push(path);
 }
-function reportedPath(plan, path2) {
-  return plan.reportedPathByCanonical.get(path2) ?? path2;
+function reportedPath(plan, path) {
+  return plan.reportedPathByCanonical.get(path) ?? path;
 }
 function changedPathsForMutation(mutation) {
   return mutation.kind === "rename" ? [mutation.oldPath, mutation.newPath] : [mutation.path];
@@ -2231,8 +2231,8 @@ function changedPathsForMutation(mutation) {
 function mutationDelta(operations) {
   const changedPaths = new Set;
   for (const operation of operations) {
-    for (const path2 of changedPathsForMutation(operation))
-      changedPaths.add(path2);
+    for (const path of changedPathsForMutation(operation))
+      changedPaths.add(path);
   }
   return { operations, changedPaths: [...changedPaths].sort() };
 }
@@ -2458,14 +2458,14 @@ function parseSinglePathResource(input, kind) {
     return;
   }
   if (kind === "create") {
-    const options2 = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
+    const options = parseOptions(change["options"], ["overwrite", "ignoreIfExists"], changeIndex);
     target.operations.push({
       kind,
       changeIndex,
       path: resolvedPath.path,
       reportedPath: resolvedPath.requestedPath,
-      overwrite: options2["overwrite"] ?? false,
-      ignoreIfExists: options2["ignoreIfExists"] ?? false,
+      overwrite: options["overwrite"] ?? false,
+      ignoreIfExists: options["ignoreIfExists"] ?? false,
       followedSymbolicLink: resolvedPath.followedSymbolicLink
     });
     return;
@@ -2714,12 +2714,12 @@ function isSameOrDescendant2(candidate, parent) {
   const relativePath = relative4(parent, candidate);
   return relativePath === "" || !relativePath.startsWith("..") && relativePath !== "..";
 }
-function removeVirtualSubtree(virtual, path2) {
+function removeVirtualSubtree(virtual, path) {
   for (const candidate of [...virtual.keys()]) {
-    if (isSameOrDescendant2(candidate, path2))
+    if (isSameOrDescendant2(candidate, path))
       virtual.delete(candidate);
   }
-  virtual.set(path2, { kind: "missing" });
+  virtual.set(path, { kind: "missing" });
 }
 function moveVirtualSubtree(virtual, oldPath, newPath) {
   const moved = [...virtual.entries()].filter(([candidate]) => isSameOrDescendant2(candidate, oldPath));
@@ -2730,16 +2730,16 @@ function moveVirtualSubtree(virtual, oldPath, newPath) {
     virtual.set(suffix === "" ? newPath : resolve4(newPath, suffix), entry);
   }
 }
-function virtualDirectoryHasChildren(virtual, path2) {
+function virtualDirectoryHasChildren(virtual, path) {
   for (const [candidate, entry] of virtual) {
-    if (candidate !== path2 && entry.kind !== "missing" && isSameOrDescendant2(candidate, path2))
+    if (candidate !== path && entry.kind !== "missing" && isSameOrDescendant2(candidate, path))
       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 requireVirtualParent(virtual, path, changeIndex) {
+  if (virtual.get(dirname5(path))?.kind !== "directory") {
+    throw new WorkspaceEditValidationError(changeIndex, `parent directory does not exist for ${path}`);
   }
 }
 function simulateOperations(parsed, snapshots) {
@@ -2881,21 +2881,21 @@ class WorkspaceSnapshotBuilder {
     }
     return this.snapshots;
   }
-  add(path2, includeChildren) {
-    let candidate = path2;
+  add(path, includeChildren) {
+    let candidate = path;
     while (true) {
       const existing = this.snapshots.get(candidate);
       if (existing === undefined || includeChildren && existing.kind === "directory" && existing.children === undefined) {
-        this.snapshots.set(candidate, snapshotPath(candidate, includeChildren && candidate === path2));
+        this.snapshots.set(candidate, snapshotPath(candidate, includeChildren && candidate === path));
       }
       if (candidate === this.workspaceRoot)
         break;
       candidate = dirname6(candidate);
     }
-    if (!includeChildren || !existsSync6(path2) || !lstatSync4(path2).isDirectory())
+    if (!includeChildren || !existsSync6(path) || !lstatSync4(path).isDirectory())
       return;
-    for (const child of readdirSync2(path2))
-      this.add(resolve5(path2, child), true);
+    for (const child of readdirSync2(path))
+      this.add(resolve5(path, child), true);
   }
 }
 function snapshotOperations(operations, workspaceRoot) {
@@ -2922,11 +2922,11 @@ class PlanPathIndex {
       }
     }
   }
-  add(path2, reportedPath2, changeIndex) {
-    if (!this.firstChangeByPath.has(path2))
-      this.firstChangeByPath.set(path2, changeIndex);
-    if (!this.reportedPathByCanonical.has(path2))
-      this.reportedPathByCanonical.set(path2, reportedPath2);
+  add(path, reportedPath, changeIndex) {
+    if (!this.firstChangeByPath.has(path))
+      this.firstChangeByPath.set(path, changeIndex);
+    if (!this.reportedPathByCanonical.has(path))
+      this.reportedPathByCanonical.set(path, reportedPath);
   }
 }
 function fingerprintWorkspaceEdit(edit, workspaceRoot) {
@@ -3036,15 +3036,15 @@ class WorkspaceMutationController {
       };
     }
     lease.phase = "applying";
-    lease.applyCompletion = new Promise((resolve62) => {
-      lease.resolveApply = resolve62;
+    lease.applyCompletion = new Promise((resolve) => {
+      lease.resolveApply = resolve;
     });
     const edit = isRecord4(params) ? params["edit"] : undefined;
-    const record2 = edit === undefined ? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) } : await this.applyEdit(edit, lease);
-    lease.serverApply = record2;
+    const record = edit === undefined ? { fingerprint: null, result: failure("workspace/applyEdit params.edit is required", 0) } : await this.applyEdit(edit, lease);
+    lease.serverApply = record;
     lease.phase = "settled";
     lease.resolveApply?.();
-    return responseFor(record2.result);
+    return responseFor(record.result);
   }
   async reconcileRename(leaseToken, edit) {
     const lease = this.requireActiveLease(leaseToken);
@@ -3060,16 +3060,16 @@ class WorkspaceMutationController {
     const applied = await this.applyEdit(edit, lease);
     return { edit, apply: applied.result };
   }
-  reconcileServerApply(record2, edit) {
+  reconcileServerApply(record, edit) {
     if (!edit)
-      return { edit, apply: record2.result };
+      return { edit, apply: record.result };
     const fingerprint = fingerprintWorkspaceEdit(edit, this.workspaceRoot);
-    if (fingerprint.success && record2.fingerprint !== null && fingerprint.fingerprint === record2.fingerprint) {
-      return { edit, apply: record2.result };
+    if (fingerprint.success && record.fingerprint !== null && fingerprint.fingerprint === record.fingerprint) {
+      return { edit, apply: record.result };
     }
     return {
       edit,
-      apply: failure("rename result conflicts with server-applied workspace edit", 0, record2.result)
+      apply: failure("rename result conflicts with server-applied workspace edit", 0, record.result)
     };
   }
   async applyEdit(edit, lease) {
@@ -3108,8 +3108,8 @@ var DIAGNOSTICS_FRESHNESS_TIMEOUT_MS = 3000;
 var VERSIONLESS_PUBLISH_QUIESCENCE_MS = 250;
 
 class LspClient extends LspClientConnection {
-  constructor(root, server2, options = {}) {
-    super(root, server2, options);
+  constructor(root, server, options = {}) {
+    super(root, server, options);
     this.diagnosticPullErrors = [];
     this.diagnosticsFreshnessTimeoutMs = options.diagnosticsFreshnessTimeoutMs ?? DIAGNOSTICS_FRESHNESS_TIMEOUT_MS;
     this.documents = new WorkspaceDocumentState((method, params) => this.sendNotification(method, params), (uri) => this.diagnosticsStore.delete(uri), {
@@ -3230,13 +3230,13 @@ class LspClient extends LspClientConnection {
       if (!pushFallbackOnly) {
         const cached = this.documents.getPullCache(snapshot);
         try {
-          const remainingMs2 = deadlineAt - this.timerProvider.now();
-          if (remainingMs2 <= 0)
+          const remainingMs = deadlineAt - this.timerProvider.now();
+          if (remainingMs <= 0)
             return this.freshnessTimeout(absPath);
           const result = await this.sendRequest("textDocument/diagnostic", {
             textDocument: { uri },
             ...cached?.resultId === undefined ? {} : { previousResultId: cached.resultId }
-          }, { timeoutMs: remainingMs2, ...signal === undefined ? {} : { signal } });
+          }, { timeoutMs: remainingMs, ...signal === undefined ? {} : { signal } });
           if (!this.documents.isCurrentSnapshot(snapshot))
             continue;
           const report = this.parseDiagnosticPullReport(result);
@@ -3317,7 +3317,7 @@ function waitForDiagnosticsActivity(wait, signal) {
     return wait;
   if (signal.aborted)
     return Promise.reject(abortError3(signal));
-  return new Promise((resolve72, reject) => {
+  return new Promise((resolve, reject) => {
     const onAbort = () => {
       signal.removeEventListener("abort", onAbort);
       reject(abortError3(signal));
@@ -3325,7 +3325,7 @@ function waitForDiagnosticsActivity(wait, signal) {
     signal.addEventListener("abort", onAbort, { once: true });
     wait.then(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve72();
+      resolve();
     }, (error) => {
       signal.removeEventListener("abort", onAbort);
       reject(error);
@@ -3389,7 +3389,7 @@ async function stopClientBestEffort(client) {
 function awaitWithSignal2(promise, signal) {
   if (!signal)
     return promise;
-  return new Promise((resolve72, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const onAbort = () => {
       if (settled)
@@ -3407,7 +3407,7 @@ function awaitWithSignal2(promise, signal) {
         return;
       settled = true;
       signal.removeEventListener("abort", onAbort);
-      resolve72(value);
+      resolve(value);
     }, (err) => {
       if (settled)
         return;
@@ -3430,7 +3430,7 @@ class LspManager {
     this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS;
     this.maxResidentClients = options.maxResidentClients ?? MAX_RESIDENT_CLIENTS;
     this.reaperIntervalMs = options.reaperIntervalMs ?? REAPER_INTERVAL_MS;
-    this.clientFactory = options.clientFactory ?? ((root, server2) => new LspClient(root, server2));
+    this.clientFactory = options.clientFactory ?? ((root, server) => new LspClient(root, server));
     this.now = options.now ?? (() => Date.now());
     this.startReaper();
     this.signalDisposer = installProcessSignalCleanup(() => this.stopAll());
@@ -3523,12 +3523,12 @@ class LspManager {
       await this.tombstoneStop(key, managed.client);
     }
   }
-  async getClient(root, server2, signal) {
+  async getClient(root, server, signal) {
     if (this.disposed) {
       throw new Error("LspManager has been disposed");
     }
     signal?.throwIfAborted();
-    const key = this.getKey(root, server2.id);
+    const key = this.getKey(root, server.id);
     for (;; ) {
       const pendingStop = this.pendingStops.get(key);
       if (pendingStop === undefined)
@@ -3570,7 +3570,7 @@ class LspManager {
           this.clients.delete(key);
         }
         await this.tombstoneStop(key, managed.client);
-        return this.getClient(root, server2, signal);
+        return this.getClient(root, server, signal);
       }
       this.markHealthyGeneration(key);
       managed.refCount++;
@@ -3578,8 +3578,8 @@ class LspManager {
       return managed.client;
     }
     this.evictForAdmission();
-    this.ensureRespawnAllowed(key, root, server2.id);
-    const client = this.clientFactory(root, server2);
+    this.ensureRespawnAllowed(key, root, server.id);
+    const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
       await client.start();
@@ -3619,7 +3619,7 @@ class LspManager {
         this.clients.delete(key);
       }
       await this.tombstoneStop(key, client);
-      return this.getClient(root, server2, signal);
+      return this.getClient(root, server, signal);
     }
     this.markHealthyGeneration(key);
     newManaged.refCount++;
@@ -3644,19 +3644,19 @@ class LspManager {
     this.clients.delete(key);
     this.tombstoneStop(key, managed.client);
   }
-  warmupClient(root, server2) {
+  warmupClient(root, server) {
     if (this.disposed)
       return;
-    const key = this.getKey(root, server2.id);
+    const key = this.getKey(root, server.id);
     if (this.clients.has(key) || this.pendingStops.has(key))
       return;
     this.evictForAdmission();
     try {
-      this.ensureRespawnAllowed(key, root, server2.id);
+      this.ensureRespawnAllowed(key, root, server.id);
     } catch {
       return;
     }
-    const client = this.clientFactory(root, server2);
+    const client = this.clientFactory(root, server);
     const initStartedAt = this.now();
     const initPromise = (async () => {
       await client.start();
@@ -3946,11 +3946,11 @@ function getInstallDecisionsPath() {
   return lspRequestContext().installDecisionsPath;
 }
 function loadInstallDecisions() {
-  const path2 = getInstallDecisionsPath();
-  if (!existsSync8(path2))
+  const path = getInstallDecisionsPath();
+  if (!existsSync8(path))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync4(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     return isInstallDecisions(parsed) ? parsed : {};
   } catch {
     return {};
@@ -3968,12 +3968,12 @@ function isInstallDecision(value) {
   return value === "declined" || value === "allowed";
 }
 function writeInstallDecisions(decisions) {
-  const path2 = getInstallDecisionsPath();
-  mkdirSync3(dirname8(path2), { recursive: true });
-  const tmpPath = `${path2}.tmp`;
+  const path = getInstallDecisionsPath();
+  mkdirSync3(dirname8(path), { recursive: true });
+  const tmpPath = `${path}.tmp`;
   writeFileSync2(tmpPath, `${JSON.stringify(decisions, null, 2)}
 `, "utf8");
-  renameSync2(tmpPath, path2);
+  renameSync2(tmpPath, path);
 }
 function isInstallDecisions(value) {
   return isRecord5(value) && Object.values(value).every(isInstallDecisionRecord);
@@ -3992,11 +3992,11 @@ function getProjectConfigPaths() {
 function getUserConfigPath() {
   return lspRequestContext().userConfigPath;
 }
-function loadJsonFile(path2) {
-  if (!existsSync9(path2))
+function loadJsonFile(path) {
+  if (!existsSync9(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync5(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
     return isConfigJson(parsed) ? parsed : null;
   } catch {
     return null;
@@ -4013,8 +4013,8 @@ function loadAllConfigs() {
   return configs;
 }
 function loadFirstJsonFile(paths) {
-  for (const path2 of paths) {
-    const config = loadJsonFile(path2);
+  for (const path of paths) {
+    const config = loadJsonFile(path);
     if (config)
       return config;
   }
@@ -4040,10 +4040,10 @@ function getMergedServers() {
       }
       if (seen.has(id))
         continue;
-      const server2 = createServerFromEntry(id, entry, source);
-      if (!server2)
+      const server = createServerFromEntry(id, entry, source);
+      if (!server)
         continue;
-      servers.push(server2);
+      servers.push(server);
       seen.add(id);
     }
   }
@@ -4075,7 +4075,7 @@ function createServerFromEntry(id, entry, source) {
   if (source === "project") {
     if (!builtin)
       return null;
-    const server3 = createServer({
+    const server = createServer({
       id,
       command: builtin.command,
       extensions: entry.extensions ?? builtin.extensions,
@@ -4083,35 +4083,35 @@ function createServerFromEntry(id, entry, source) {
       source
     });
     if (entry.initialization !== undefined) {
-      server3.initialization = entry.initialization;
+      server.initialization = entry.initialization;
     }
-    return server3;
+    return server;
   }
   if (entry.command && entry.extensions) {
-    const server3 = createServer({
+    const server = createServer({
       id,
       command: entry.command,
       extensions: entry.extensions,
       priority: entry.priority ?? 0,
       source
     });
-    applyOptionalServerFields(server3, entry);
-    return server3;
+    applyOptionalServerFields(server, entry);
+    return server;
   }
   if (!builtin)
     return null;
-  const server2 = createServer({
+  const server = createServer({
     id,
     command: entry.command ?? builtin.command,
     extensions: entry.extensions ?? builtin.extensions,
     priority: entry.priority ?? 0,
     source
   });
-  applyOptionalServerFields(server2, entry);
-  return server2;
+  applyOptionalServerFields(server, entry);
+  return server;
 }
 function createServer(input) {
-  const server2 = {
+  const server = {
     id: input.id,
     command: input.command,
     extensions: input.extensions,
@@ -4119,19 +4119,19 @@ function createServer(input) {
     source: input.source
   };
   if (input.env !== undefined) {
-    server2.env = input.env;
+    server.env = input.env;
   }
   if (input.initialization !== undefined) {
-    server2.initialization = input.initialization;
+    server.initialization = input.initialization;
   }
-  return server2;
+  return server;
 }
-function applyOptionalServerFields(server2, entry) {
+function applyOptionalServerFields(server, entry) {
   if (entry.env !== undefined) {
-    server2.env = entry.env;
+    server.env = entry.env;
   }
   if (entry.initialization !== undefined) {
-    server2.initialization = entry.initialization;
+    server.initialization = entry.initialization;
   }
 }
 function isConfigJson(value) {
@@ -4216,9 +4216,9 @@ var LOCAL_BIN_RULES = [
 ];
 var resolutionCache = new Map;
 var probeCount = 0;
-function probe(path2) {
+function probe(path) {
   probeCount += 1;
-  return existsSync10(path2);
+  return existsSync10(path);
 }
 function executableSuffixes(platform, pathExt) {
   if (platform !== "win32")
@@ -4316,24 +4316,24 @@ function withResolvedCommand(command, binaryPath) {
 function findServerForExtension(ext) {
   const servers = getMergedServers();
   const workingDirectory = contextCwd();
-  for (const server2 of servers) {
-    if (!server2.extensions.includes(ext))
+  for (const server of servers) {
+    if (!server.extensions.includes(ext))
       continue;
-    const binaryPath = resolveServerBinary(server2.command, workingDirectory);
+    const binaryPath = resolveServerBinary(server.command, workingDirectory);
     if (binaryPath !== null) {
       const resolvedServer = {
-        id: server2.id,
-        command: withResolvedCommand(server2.command, binaryPath),
-        extensions: server2.extensions,
-        priority: server2.priority
+        id: server.id,
+        command: withResolvedCommand(server.command, binaryPath),
+        extensions: server.extensions,
+        priority: server.priority
       };
-      if (server2.env !== undefined) {
+      if (server.env !== undefined) {
         return {
           status: "found",
           server: {
             ...resolvedServer,
-            env: server2.env,
-            ...server2.initialization === undefined ? {} : { initialization: server2.initialization }
+            env: server.env,
+            ...server.initialization === undefined ? {} : { initialization: server.initialization }
           }
         };
       }
@@ -4341,20 +4341,20 @@ function findServerForExtension(ext) {
         status: "found",
         server: {
           ...resolvedServer,
-          ...server2.initialization === undefined ? {} : { initialization: server2.initialization }
+          ...server.initialization === undefined ? {} : { initialization: server.initialization }
         }
       };
     }
   }
-  for (const server2 of servers) {
-    if (server2.extensions.includes(ext)) {
-      const installHint = LSP_INSTALL_HINTS[server2.id] ?? `Install '${server2.command[0]}' and ensure it's in your PATH`;
+  for (const server of servers) {
+    if (server.extensions.includes(ext)) {
+      const installHint = LSP_INSTALL_HINTS[server.id] ?? `Install '${server.command[0]}' and ensure it's in your PATH`;
       return {
         status: "not_installed",
         server: {
-          id: server2.id,
-          command: server2.command,
-          extensions: server2.extensions
+          id: server.id,
+          command: server.command,
+          extensions: server.extensions
         },
         installHint
       };
@@ -4373,18 +4373,18 @@ function getAllServers() {
   const workingDirectory = contextCwd();
   const result = [];
   const seen = new Set;
-  for (const server2 of servers) {
-    if (seen.has(server2.id))
+  for (const server of servers) {
+    if (seen.has(server.id))
       continue;
     result.push({
-      id: server2.id,
-      installed: isServerInstalled(server2.command, workingDirectory),
-      extensions: server2.extensions,
+      id: server.id,
+      installed: isServerInstalled(server.command, workingDirectory),
+      extensions: server.extensions,
       disabled: false,
-      source: server2.source,
-      priority: server2.priority
+      source: server.source,
+      priority: server.priority
     });
-    seen.add(server2.id);
+    seen.add(server.id);
   }
   for (const id of disabled) {
     if (seen.has(id))
@@ -4457,8 +4457,8 @@ function resolvePathInsideContext(filePath) {
   }
   return canonical;
 }
-function rebaseThroughCanonicalAncestor(path2, cwd) {
-  let current = path2;
+function rebaseThroughCanonicalAncestor(path, cwd) {
+  let current = path;
   const suffix = [];
   while (true) {
     if (existsSync11(current)) {
@@ -4530,20 +4530,20 @@ function formatInstallOptions(serverId, installHint) {
   ];
 }
 function formatNotInstalled(result) {
-  const { server: server2, installHint } = result;
-  const extensions = server2.extensions.join(", ");
-  const decision = loadInstallDecision(server2.id)?.decision;
+  const { server, installHint } = result;
+  const extensions = server.extensions.join(", ");
+  const decision = loadInstallDecision(server.id)?.decision;
   const context = lspRequestContext();
   if (decision === "declined") {
-    return `LSP server '${server2.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
+    return `LSP server '${server.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
   }
   const header = [
-    `LSP server '${server2.id}' for ${extensions} is NOT INSTALLED.`,
+    `LSP server '${server.id}' for ${extensions} is NOT INSTALLED.`,
     "",
-    `Command not found: ${server2.command[0]}`,
+    `Command not found: ${server.command[0]}`,
     ""
   ];
-  const installOptions = formatInstallOptions(server2.id, installHint);
+  const installOptions = formatInstallOptions(server.id, installHint);
   if (decision === "allowed") {
     return [
       ...header,
@@ -4569,7 +4569,7 @@ function formatNotInstalled(result) {
     "ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
     "- If the user agrees: run the install command above, then retry this tool.",
     "- If the user declines, OR has NOT explicitly asked for LSP installation:",
-    `    call lsp_install_decision { server_id: "${server2.id}", decision: "declined" },`,
+    `    call lsp_install_decision { server_id: "${server.id}", decision: "declined" },`,
     `    which writes to ${context.installDecisionsPath},`,
     "    then ignore this message and proceed WITHOUT LSP."
   ].join(`
@@ -4593,26 +4593,26 @@ async function withLspClient(filePath, fn, toolName, options = {}) {
   if (result.status !== "found") {
     throw new LspServerLookupError(formatServerLookupError(result), result);
   }
-  const server2 = result.server;
+  const server = result.server;
   const root = findWorkspaceRoot(absPath);
   const manager = options.manager ?? getLspManager();
   const acquireAndCall = async (allowRetry) => {
-    const client = await manager.getClient(root, server2, options.signal);
+    const client = await manager.getClient(root, server, options.signal);
     try {
       return await fn(client, root, absPath);
     } catch (err) {
       if (allowRetry && READ_ONLY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
-        manager.invalidateClient(root, server2.id, client);
+        manager.invalidateClient(root, server.id, client);
         return acquireAndCall(false);
       }
       if (err instanceof LspRequestTimeoutError) {
-        if (manager.isServerInitializing(root, server2.id)) {
+        if (manager.isServerInitializing(root, server.id)) {
           throw new LspServerInitializingError(err);
         }
       }
       throw err;
     } finally {
-      manager.releaseClient(root, server2.id);
+      manager.releaseClient(root, server.id);
     }
   };
   return acquireAndCall(true);
@@ -4628,10 +4628,10 @@ function uriToPath(uri) {
 }
 function formatLocation(loc) {
   if ("targetUri" in loc) {
-    const uri2 = uriToPath(loc.targetUri);
-    const line2 = loc.targetRange.start.line + 1;
-    const char2 = loc.targetRange.start.character;
-    return `${uri2}:${line2}:${char2}`;
+    const uri = uriToPath(loc.targetUri);
+    const line = loc.targetRange.start.line + 1;
+    const char = loc.targetRange.start.character;
+    return `${uri}:${line}:${char}`;
   }
   const uri = uriToPath(loc.uri);
   const line = loc.range.start.line + 1;
@@ -4774,7 +4774,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   if (serverResult.status !== "found") {
     throw new LspServerLookupError(formatServerLookupError(serverResult));
   }
-  const server2 = serverResult.server;
+  const server = serverResult.server;
   const allFiles = (options.listFiles ?? collectFilesWithExtension)(absDir, extension, maxFiles + 1);
   const wasCapped = allFiles.length > maxFiles;
   const filesToProcess = allFiles.slice(0, maxFiles);
@@ -4794,7 +4794,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   const fileErrors = [];
   const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
   options.signal?.throwIfAborted();
-  const client = await manager.getClient(root, server2, options.signal);
+  const client = await manager.getClient(root, server, options.signal);
   try {
     let nextIndex = 0;
     const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
@@ -4822,7 +4822,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
     });
     await Promise.all(workers);
   } finally {
-    manager.releaseClient(root, server2.id);
+    manager.releaseClient(root, server.id);
   }
   const displayDiagnostics = allDiagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS);
   const wasDiagCapped = allDiagnostics.length > DEFAULT_MAX_DIAGNOSTICS;
@@ -5017,8 +5017,8 @@ function severityFilter(params) {
 function clientOptions(signal) {
   return signal === undefined ? {} : { signal };
 }
-function text(text2, details, isError = false) {
-  return { content: [{ type: "text", text: text2 }], details, isError };
+function text(text, details, isError = false) {
+  return { content: [{ type: "text", text }], details, isError };
 }
 function asDiagnosticArray(result) {
   if (!result)
@@ -5036,7 +5036,7 @@ async function executeLspDiagnostics(params, signal) {
       const extension = inferExtensionFromDirectory(absPath);
       if (!extension) {
         const message = `No supported source files found in directory: ${absPath}`;
-        const details3 = {
+        const details = {
           filePath,
           severity,
           mode: "directory",
@@ -5046,24 +5046,24 @@ async function executeLspDiagnostics(params, signal) {
           error: message,
           errorKind: "no_files"
         };
-        return text(message, details3);
+        return text(message, details);
       }
-      const output2 = await aggregateDiagnosticsForDirectory(absPath, extension, severity, undefined, signal === undefined ? {} : { signal });
-      const details2 = {
+      const output = await aggregateDiagnosticsForDirectory(absPath, extension, severity, undefined, signal === undefined ? {} : { signal });
+      const details = {
         filePath,
         severity,
         mode: "directory",
         diagnostics: [],
-        totalDiagnostics: output2.totalDiagnostics,
+        totalDiagnostics: output.totalDiagnostics,
         truncated: false,
-        fileFailures: [...output2.fileFailures]
+        fileFailures: [...output.fileFailures]
       };
-      return text(output2.output, details2);
+      return text(output.output, details);
     }
     const result = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.diagnostics(resolvedFilePath, signal), "diagnostics", clientOptions(signal));
     if (result.transientError) {
       const message = result.transientError.message;
-      const details2 = {
+      const details = {
         filePath,
         severity,
         mode: "file",
@@ -5073,7 +5073,7 @@ async function executeLspDiagnostics(params, signal) {
         error: message,
         errorKind: result.transientError.kind
       };
-      return text(message, details2, true);
+      return text(message, details, true);
     }
     const diagnostics = filterDiagnosticsBySeverity(asDiagnosticArray(result), severity);
     const total = diagnostics.length;
@@ -5198,7 +5198,7 @@ async function executeLspInstallDecision(params) {
   if (!isInstallDecision(decision)) {
     return text(`Invalid decision '${String(decision)}'. Expected "declined" or "allowed".`, { serverId, errorKind: "invalid_decision" }, true);
   }
-  const serverIds = [...new Set(getMergedServers().map((server2) => server2.id))];
+  const serverIds = [...new Set(getMergedServers().map((server) => server.id))];
   if (!serverIds.includes(serverId)) {
     const preview = serverIds.slice(0, 20).join(", ");
     return text(`Unknown LSP server '${serverId}'. Known servers: ${preview}${serverIds.length > 20 ? "..." : ""}`, { serverId, errorKind: "unknown_server" }, true);
@@ -5330,10 +5330,10 @@ function objectSchema(properties, required = []) {
 async function executeLspStatus() {
   const servers = getAllServers();
   const snapshots = getLspManager().getSnapshot();
-  const installed = servers.filter((server2) => server2.installed && !server2.disabled);
-  const configuredLines = servers.map((server2) => {
-    const state = server2.disabled ? "disabled" : server2.installed ? "installed" : "missing";
-    return `- ${server2.id}: ${state}; source=${server2.source}; extensions=${server2.extensions.join(", ")}`;
+  const installed = servers.filter((server) => server.installed && !server.disabled);
+  const configuredLines = servers.map((server) => {
+    const state = server.disabled ? "disabled" : server.installed ? "installed" : "missing";
+    return `- ${server.id}: ${state}; source=${server.source}; extensions=${server.extensions.join(", ")}`;
   });
   const activeLines = snapshots.map((snapshot) => {
     const state = snapshot.alive ? snapshot.isInitializing ? "initializing" : "alive" : "dead";
@@ -5374,8 +5374,8 @@ async function executeLspSymbols(params, signal) {
           errorKind: "missing_query"
         });
       }
-      const symbols2 = await withLspClient(filePath, async (client) => client.workspaceSymbols(query, signal), "workspaceSymbols", clientOptions(signal));
-      return formatSymbolsResult(filePath, scope, symbols2, limit, query);
+      const symbols = await withLspClient(filePath, async (client) => client.workspaceSymbols(query, signal), "workspaceSymbols", clientOptions(signal));
+      return formatSymbolsResult(filePath, scope, symbols, limit, query);
     }
     const symbols = await withLspClient(filePath, async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal), "documentSymbols", clientOptions(signal));
     return formatSymbolsResult(filePath, scope, symbols, limit);
@@ -5587,7 +5587,7 @@ function withContext(args, context) {
 function ensureDaemonAvailable(paths, ensure, signal) {
   if (!signal)
     return ensure(paths);
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     const finish = (run) => {
       if (settled)
@@ -5602,11 +5602,11 @@ function ensureDaemonAvailable(paths, ensure, signal) {
       return;
     }
     signal.addEventListener("abort", onAbort, { once: true });
-    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve10()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
+    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
   });
 }
 function sendToolCall(paths, token, name, args, options) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve, reject) => {
     const socket = connect(paths.socket);
     const requestId = allocateProxyRequestId();
     let settled = false;
@@ -5659,7 +5659,7 @@ function sendToolCall(paths, token, name, args, options) {
       }
       const result = toToolResult(message, requestId);
       if (result)
-        finish(() => resolve10(result));
+        finish(() => resolve(result));
       else
         finish(() => reject(new DaemonRequestError("invalid daemon response", requestWritten)));
     });
@@ -5834,8 +5834,8 @@ function normalizeDiagnosticsOutcome(outcome) {
     return normalizeDiagnosticsText(outcome);
   return outcome;
 }
-function normalizeDiagnosticsText(text2) {
-  return text2.trim();
+function normalizeDiagnosticsText(text) {
+  return text.trim();
 }
 function formatDiagnosticsError(error) {
   const message = normalizeDiagnosticsText(error.message);
@@ -5880,18 +5880,18 @@ function parseLspRequestContext2(value) {
   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);
+  for (const path of projectConfigPaths) {
+    requireAbsolutePath2(path, "projectConfigPaths");
+    const projectPath = canonicalizeExistingOrNearestAncestor2(path);
     if (!isPathInside2(canonical, projectPath)) {
-      throw new LspRequestContextParseError2("project_config_outside_cwd", `Project LSP config path must be inside cwd: ${path2}`);
+      throw new LspRequestContextParseError2("project_config_outside_cwd", `Project LSP config path must be inside cwd: ${path}`);
     }
   }
   requireAbsolutePath2(userConfigPath, "userConfigPath");
   requireAbsolutePath2(installDecisionsPath, "installDecisionsPath");
   return {
     cwd: canonical,
-    projectConfigPaths: projectConfigPaths.map((path2) => canonicalizeExistingOrNearestAncestor2(path2)),
+    projectConfigPaths: projectConfigPaths.map((path) => canonicalizeExistingOrNearestAncestor2(path)),
     userConfigPath,
     installDecisionsPath,
     capabilities
@@ -5904,8 +5904,8 @@ function canonicalCwd2(cwd) {
   }
   return realpathSync6(resolved);
 }
-function canonicalizeExistingOrNearestAncestor2(path2) {
-  let current = resolve10(path2);
+function canonicalizeExistingOrNearestAncestor2(path) {
+  let current = resolve10(path);
   const suffix = [];
   while (true) {
     try {
@@ -5947,9 +5947,9 @@ function stringArrayField2(value, field) {
   }
   return fieldValue;
 }
-function requireAbsolutePath2(path2, field) {
-  if (!isAbsolute7(path2)) {
-    throw new LspRequestContextParseError2("relative_path", `LSP request context.${field} must be absolute: ${path2}`);
+function requireAbsolutePath2(path, field) {
+  if (!isAbsolute7(path)) {
+    throw new LspRequestContextParseError2("relative_path", `LSP request context.${field} must be absolute: ${path}`);
   }
 }
 function isPathInside2(parent, child) {
@@ -5978,9 +5978,9 @@ function errorCode2(error) {
 }
 
 // src/daemon-cli-path.ts
-import { existsSync as existsSync15, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync7 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname11, join as join10 } from "node:path";
+import { dirname as dirname11, 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/cli";
@@ -6002,7 +6002,7 @@ function resolveLspDaemonCli() {
   if (packageCli !== null)
     return resolveConfiguredLspDaemonCli(packageCli);
   const bundledCli = fileURLToPath4(new URL("../../lsp-daemon/dist/cli.js", import.meta.url));
-  if (existsSync15(bundledCli))
+  if (existsSync14(bundledCli))
     return resolveConfiguredLspDaemonCli(bundledCli);
   return resolveConfiguredLspDaemonCli(bundledCli);
 }
@@ -6027,8 +6027,8 @@ function resolveConfiguredLspDaemonCli(cliPath) {
 }
 function readDaemonPackageVersion(cliPath) {
   try {
-    const parsed = JSON.parse(readFileSync7(join10(dirname11(cliPath), "package.json"), "utf8"));
-    if (isRecord9(parsed) && typeof parsed["version"] === "string" && parsed["version"].length > 0) {
+    const parsed = JSON.parse(readFileSync7(join9(dirname11(cliPath), "package.json"), "utf8"));
+    if (isRecord8(parsed) && typeof parsed["version"] === "string" && parsed["version"].length > 0) {
       return parsed["version"];
     }
   } catch (error) {
@@ -6037,14 +6037,14 @@ function readDaemonPackageVersion(cliPath) {
   }
   return null;
 }
-function isRecord9(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/lsp-session-state.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname as dirname13, join as join11 } from "node:path";
+import { dirname as dirname12, join as join10 } from "node:path";
 function sessionIdFrom(input) {
   return typeof input.session_id === "string" && input.session_id.length > 0 ? input.session_id : undefined;
 }
@@ -6070,24 +6070,24 @@ function isLspDaemonUnreachableDiagnostics(diagnostics) {
   return diagnostics.includes("LSP daemon unreachable");
 }
 function sessionStatePath(sessionId) {
-  const root = process.env["PLUGIN_DATA"] ?? join11(homedir(), ".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(path2) {
+function readSessionState(path) {
   try {
-    const parsed = JSON.parse(readFileSync9(path2, "utf8"));
-    if (isRecord10(parsed) && isLspSessionState(parsed))
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
+    if (isRecord9(parsed) && isLspSessionState(parsed))
       return normalizeSessionState(parsed);
     return emptyState();
   } catch (error) {
-    if (error instanceof SyntaxError || isRecord10(error) && error["code"] === "ENOENT")
+    if (error instanceof SyntaxError || isRecord9(error) && error["code"] === "ENOENT")
       return emptyState();
     throw error;
   }
 }
-function writeSessionState(path2, state) {
-  mkdirSync4(dirname13(path2), { recursive: true });
-  writeFileSync4(path2, `${JSON.stringify(state)}
+function writeSessionState(path, state) {
+  mkdirSync4(dirname12(path), { recursive: true });
+  writeFileSync4(path, `${JSON.stringify(state)}
 `);
 }
 function emptyState() {
@@ -6106,7 +6106,7 @@ function normalizeSessionState(value) {
     notConfiguredExtensions: Array.isArray(notConfiguredExtensions) ? notConfiguredExtensions.filter((item) => typeof item === "string").sort() : []
   };
 }
-function isRecord10(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -6117,7 +6117,7 @@ function extractMutatedFilePaths(input) {
     return [];
   if (isFailedToolResponse(input.tool_response))
     return [];
-  const toolInput = isRecord11(input.tool_input) ? input.tool_input : {};
+  const toolInput = isRecord10(input.tool_input) ? input.tool_input : {};
   const paths = new Set;
   addStringValue(paths, toolInput["path"]);
   addStringValue(paths, toolInput["filePath"]);
@@ -6136,7 +6136,7 @@ function isMutationTool(value) {
   return MUTATION_TOOL_NAMES.has(value.toLowerCase());
 }
 function isFailedToolResponse(value) {
-  if (!isRecord11(value))
+  if (!isRecord10(value))
     return false;
   return value["isError"] === true || value["is_error"] === true || value["error"] === true || value["status"] === "error";
 }
@@ -6162,9 +6162,9 @@ function addPatchInput(paths, value) {
     return;
   for (const line of value.split(`
 `)) {
-    const path2 = extractPatchHeaderPath(line);
-    if (path2 !== undefined)
-      paths.add(path2);
+    const path = extractPatchHeaderPath(line);
+    if (path !== undefined)
+      paths.add(path);
   }
 }
 function extractPatchHeaderPath(line) {
@@ -6179,7 +6179,7 @@ function addPatchFiles(paths, value) {
   if (!Array.isArray(value))
     return;
   for (const item of value) {
-    if (!isRecord11(item))
+    if (!isRecord10(item))
       continue;
     addStringValue(paths, item["path"]);
     addStringValue(paths, item["filePath"]);
@@ -6188,7 +6188,7 @@ function addPatchFiles(paths, value) {
     addStringValue(paths, item["move_path"]);
   }
 }
-function isRecord11(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -6219,10 +6219,10 @@ function postEditOutcomeFromDaemonResult(result) {
 `);
 }
 function notConfiguredAvailability(details) {
-  if (!isRecord12(details))
+  if (!isRecord11(details))
     return;
   const availability = details["availability"];
-  if (!isRecord12(availability))
+  if (!isRecord11(availability))
     return;
   if (availability["kind"] !== "not_configured")
     return;
@@ -6230,13 +6230,13 @@ function notConfiguredAvailability(details) {
   return typeof extension === "string" && extension.length > 0 ? { extension } : undefined;
 }
 function codexLspRequestContext(env = process.env, cwd = process.cwd()) {
-  const canonicalCwd3 = realpathSync8(resolve12(cwd));
-  const codexHome = resolve12(env["CODEX_HOME"]?.trim() || join12(homedir3(), ".codex"));
+  const canonicalCwd = realpathSync7(resolve11(cwd));
+  const codexHome = resolve11(env["CODEX_HOME"]?.trim() || join11(homedir3(), ".codex"));
   return parseLspRequestContext2({
-    cwd: canonicalCwd3,
-    projectConfigPaths: [join12(canonicalCwd3, ".codex", "lsp-client.json")],
-    userConfigPath: join12(codexHome, "lsp-client.json"),
-    installDecisionsPath: join12(codexHome, "lsp-install-decisions.json"),
+    cwd: canonicalCwd,
+    projectConfigPaths: [join11(canonicalCwd, ".codex", "lsp-client.json")],
+    userConfigPath: join11(codexHome, "lsp-client.json"),
+    installDecisionsPath: join11(codexHome, "lsp-install-decisions.json"),
     capabilities: { installDecisionTool: true }
   });
 }
@@ -6330,29 +6330,29 @@ function isContextPressureTranscript(transcriptPath) {
   if (typeof transcriptPath !== "string")
     return false;
   try {
-    return hasContextPressureMarker(readFileSync10(transcriptPath, "utf8"));
+    return hasContextPressureMarker(readFileSync9(transcriptPath, "utf8"));
   } catch (error) {
     if (error instanceof Error)
       return false;
     throw error;
   }
 }
-function hasContextPressureMarker(text2) {
-  const normalizedText = text2.toLowerCase();
+function hasContextPressureMarker(text) {
+  const normalizedText = text.toLowerCase();
   return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
 }
-function limitHookText(text2, maxChars) {
-  if (text2.length <= maxChars)
-    return text2;
+function limitHookText(text, maxChars) {
+  if (text.length <= maxChars)
+    return text;
   const marker = `
 
 [Truncated hook output to ${maxChars} chars to avoid Codex context overflow.]`;
   if (marker.length >= maxChars)
     return marker.slice(0, maxChars);
-  const head = text2.slice(0, maxChars - marker.length).replace(/[ \t\r\n]+$/, "");
+  const head = text.slice(0, maxChars - marker.length).replace(/[ \t\r\n]+$/, "");
   return `${head}${marker}`;
 }
-function isRecord12(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -6369,7 +6369,7 @@ async function runHookCli(runHook, stdin) {
     if (!raw.trim())
       return;
     const parsed = JSON.parse(raw);
-    const input = isRecord12(parsed) ? parsed : {};
+    const input = isRecord11(parsed) ? parsed : {};
     const output = await runHook(input);
     if (output)
       process.stdout.write(output);
@@ -6413,14 +6413,14 @@ main().catch((error) => {
 async function runPackageLspMcpCli() {
   const cliPath = resolveLspDaemonCliPath();
   const child = spawn3(execPath2, [cliPath, "mcp"], { stdio: "inherit", windowsHide: true });
-  await new Promise((resolve11, reject) => {
+  await new Promise((resolve, 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;
-      resolve11();
+      resolve();
     });
   });
 }