oh-my-opencode 4.19.4 → 5.0.0-beta.10

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

@@ -8,7 +8,7 @@ import { argv, execPath as execPath2, stderr } from "node:process";
 import { stdin as processStdin } from "node:process";
 
 // src/codex-hook.ts
-import { readFileSync as readFileSync9, realpathSync as realpathSync6 } from "node:fs";
+import { readFileSync as readFileSync9, realpathSync as realpathSync7 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join11, resolve as resolve11 } from "node:path";
 
@@ -18,10 +18,10 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync, realpathSync, statSync } from "node:fs";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { spawn } from "node:child_process";
-import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync as openSync2, writeSync as writeSync2 } from "node:fs";
 import { Socket } from "node:net";
-import { dirname as dirname3 } from "node:path";
-import { execPath } from "node:process";
+import { dirname as dirname3, isAbsolute as isAbsolute3 } from "node:path";
+import { argv0, execPath } from "node:process";
 import {
   chmodSync,
   closeSync,
@@ -42,38 +42,38 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { statSync as statSync2 } from "node:fs";
 import { isAbsolute as isAbsolute2 } from "node:path";
-import { existsSync as existsSync9, statSync as statSync4 } from "node:fs";
-import { dirname as dirname8, join as join4, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync10, realpathSync as realpathSync4, statSync as statSync4 } from "node:fs";
+import { basename as basename3, dirname as dirname8, join as join4, resolve as resolve7 } from "node:path";
 import { basename as basename2, extname } from "node:path";
 import { resolve as resolve6 } from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 import { pathToFileURL } from "node:url";
 import { spawn as spawn2, spawnSync } from "node:child_process";
-import { existsSync as existsSync2, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync3, statSync as statSync3 } from "node:fs";
 import { delimiter as delimiter2, join as join2 } from "node:path";
 import { readFileSync as readFileSync2, realpathSync as realpathSync2 } from "node:fs";
 import { relative as relative2, resolve as resolve2 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { existsSync as existsSync4, lstatSync as lstatSync3, renameSync, rmSync, writeFileSync } from "node:fs";
-import { existsSync as existsSync3, lstatSync as lstatSync2, readFileSync as readFileSync3, readdirSync, realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync5, lstatSync as lstatSync3, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, lstatSync as lstatSync2, readFileSync as readFileSync3, readdirSync, realpathSync as realpathSync3 } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute4, relative as relative3, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { createHash as createHash2 } from "node:crypto";
 import { dirname as dirname5, relative as relative4, resolve as resolve4 } from "node:path";
-import { existsSync as existsSync5, lstatSync as lstatSync4, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync6, lstatSync as lstatSync4, readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname6, resolve as resolve5 } from "node:path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { delimiter as delimiter3, join as join3 } from "node:path";
-import { existsSync as existsSync10, lstatSync as lstatSync5, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync11, lstatSync as lstatSync5, readdirSync as readdirSync3 } from "node:fs";
 import { join as join5, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { lstatSync as lstatSync6, readdirSync as readdirSync4 } from "node:fs";
 import { join as join6 } from "node:path";
 import { statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute4 } from "node:path";
+import { isAbsolute as isAbsolute5 } from "node:path";
 
 class LspRequestContextParseError extends Error {
   code;
@@ -563,15 +563,29 @@ function spawnDaemonProcess(paths) {
   mkdirSync2(dirname3(paths.log), { recursive: true });
   const logFd = openSync2(paths.log, "a");
   try {
-    const child = spawn(execPath, [paths.cliPath, "daemon"], {
+    const child = spawn(resolveDaemonNodeExecutable(), [paths.cliPath, "daemon"], {
       detached: true,
       stdio: ["ignore", logFd, logFd]
     });
+    child.once("spawn", () => closeSync2(logFd));
+    child.once("error", (error) => {
+      writeSync2(logFd, `[lsp-daemon] failed to spawn daemon: ${error.message}
+`);
+      closeSync2(logFd);
+    });
     child.unref();
-  } finally {
+  } catch (error) {
     closeSync2(logFd);
+    throw error;
   }
 }
+function resolveDaemonNodeExecutable(cachedExecPath = execPath, originalArgv0 = argv0, pathExists = existsSync2) {
+  if (pathExists(cachedExecPath))
+    return cachedExecPath;
+  if (isAbsolute3(originalArgv0) && pathExists(originalArgv0))
+    return originalArgv0;
+  return "node";
+}
 function defaultEnsureDaemonDeps() {
   return {
     probe: (paths, signal) => probeDaemon(paths, PROBE_TIMEOUT_MS, signal),
@@ -1085,7 +1099,7 @@ function reportKillError(context, error) {
 }
 function validateCwd(cwd) {
   try {
-    if (!existsSync2(cwd)) {
+    if (!existsSync3(cwd)) {
       return { valid: false, error: `Working directory does not exist: ${cwd}` };
     }
     const stats = statSync3(cwd);
@@ -1173,7 +1187,7 @@ function resolveWindowsCommand(command, env) {
   for (const baseDirectory of baseDirectories) {
     for (const extension of extensions) {
       const candidate = baseDirectory ? join2(baseDirectory, `${command}${extension}`) : `${command}${extension}`;
-      if (existsSync2(candidate))
+      if (existsSync3(candidate))
         return candidate;
     }
   }
@@ -1567,7 +1581,7 @@ class LspClientConnection extends LspClientTransport {
       initializationOptions: this.server.initialization
     }, { timeoutMs: this.initializeTimeoutMs });
     this.setDiagnosticPullSupported(supportsDiagnosticPull(result?.capabilities));
-    await this.sendNotification("initialized");
+    await this.sendNotification("initialized", {});
     await this.sendNotification("workspace/didChangeConfiguration", {
       settings: { json: { validate: { enable: true } } }
     });
@@ -2037,11 +2051,11 @@ class WorkspaceEditPathError extends Error {
 }
 function isPathInsideWorkspace(filePath, workspaceRoot) {
   const relativePath = relative3(workspaceRoot, filePath);
-  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute3(relativePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute4(relativePath);
 }
 function canonicalizeMissingPath(filePath) {
   let ancestor = filePath;
-  while (!existsSync3(ancestor)) {
+  while (!existsSync4(ancestor)) {
     const parent = dirname4(ancestor);
     if (parent === ancestor)
       throw new WorkspaceEditPathError(filePath, "no existing ancestor");
@@ -2059,7 +2073,7 @@ function canonicalWorkspaceRoot(workspaceRoot) {
       success: true,
       path: canonical,
       requestedPath: resolve3(workspaceRoot),
-      followedSymbolicLink: existsSync3(resolve3(workspaceRoot)) && lstatSync2(resolve3(workspaceRoot)).isSymbolicLink()
+      followedSymbolicLink: existsSync4(resolve3(workspaceRoot)) && lstatSync2(resolve3(workspaceRoot)).isSymbolicLink()
     };
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
@@ -2079,7 +2093,7 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
     return { success: false, error: `non-file URI ${uri}: ${detail}` };
   }
   try {
-    const canonical = existsSync3(requestedPath) ? realpathSync3(requestedPath) : canonicalizeMissingPath(requestedPath);
+    const canonical = existsSync4(requestedPath) ? realpathSync3(requestedPath) : canonicalizeMissingPath(requestedPath);
     if (!isPathInsideWorkspace(canonical, workspaceRoot)) {
       return { success: false, error: `${requestedPath}: outside workspace ${workspaceRoot}` };
     }
@@ -2087,7 +2101,7 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
       success: true,
       path: canonical,
       requestedPath,
-      followedSymbolicLink: existsSync3(requestedPath) && lstatSync2(requestedPath).isSymbolicLink()
+      followedSymbolicLink: existsSync4(requestedPath) && lstatSync2(requestedPath).isSymbolicLink()
     };
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
@@ -2095,7 +2109,7 @@ function uriToCanonicalWorkspacePath(uri, workspaceRoot) {
   }
 }
 function snapshotPath(path2, includeChildren) {
-  if (!existsSync3(path2))
+  if (!existsSync4(path2))
     return { kind: "missing" };
   const stats = lstatSync2(path2);
   if (stats.isFile())
@@ -2213,7 +2227,7 @@ function commitOperation(context, operation) {
   }
   if (operation.kind === "rename") {
     if (operation.replaceDestination) {
-      const targetKind = existsSync4(operation.newPath) && lstatSync3(operation.newPath).isDirectory() ? "directory" : "file";
+      const targetKind = existsSync5(operation.newPath) && lstatSync3(operation.newPath).isDirectory() ? "directory" : "file";
       io.remove(operation.newPath, targetKind === "directory");
       accumulator.mutations.push({ kind: "delete", path: operation.newPath, targetKind });
       addModifiedPath(accumulator.filesModified, reportedPath(plan, operation.newPath));
@@ -2841,7 +2855,7 @@ class WorkspaceSnapshotBuilder {
         break;
       candidate = dirname6(candidate);
     }
-    if (!includeChildren || !existsSync5(path2) || !lstatSync4(path2).isDirectory())
+    if (!includeChildren || !existsSync6(path2) || !lstatSync4(path2).isDirectory())
       return;
     for (const child of readdirSync2(path2))
       this.add(resolve5(path2, child), true);
@@ -3597,7 +3611,7 @@ function getInstallDecisionsPath() {
 }
 function loadInstallDecisions() {
   const path2 = getInstallDecisionsPath();
-  if (!existsSync6(path2))
+  if (!existsSync7(path2))
     return {};
   try {
     const parsed = JSON.parse(readFileSync4(path2, "utf8"));
@@ -3788,7 +3802,7 @@ function getUserConfigPath() {
   return lspRequestContext().userConfigPath;
 }
 function loadJsonFile(path2) {
-  if (!existsSync7(path2))
+  if (!existsSync8(path2))
     return null;
   try {
     const parsed = JSON.parse(readFileSync5(path2, "utf-8"));
@@ -3981,7 +3995,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";
@@ -4002,7 +4016,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(join3(p, cmd + suffix))) {
         return true;
       }
     }
@@ -4103,32 +4117,86 @@ function isDirectoryPath(filePath) {
   }
 }
 function findWorkspaceRoot(filePath) {
-  const abs = resolvePathInsideContext(filePath);
+  const cwd = contextCwd();
+  const abs = resolveReadablePathInsideContext(filePath);
   let dir = abs;
   if (!isDirectoryPath(dir)) {
     dir = dirname8(dir);
   }
-  let prevDir = "";
-  while (dir !== prevDir) {
-    for (const marker of WORKSPACE_MARKERS) {
-      if (existsSync9(join4(dir, marker))) {
-        return 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(join4(dir, marker))) {
+          return canonicalDir;
+        }
       }
     }
-    prevDir = dir;
+    if (dir === cwd)
+      break;
     dir = dirname8(dir);
   }
-  return dirname8(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;
+  const canonical = canonicalizeExistingOrNearestAncestor(abs);
+  if (isPathInside(cwd, canonical))
+    return canonical;
+  throw new LspInvalidPathError(`LSP file path must be inside request cwd: ${filePath}`);
+}
+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(path2, cwd) {
+  let current = path2;
+  const suffix = [];
+  while (true) {
+    if (existsSync10(current)) {
+      const canonical = realpathSync4(current);
+      if (isPathInside(cwd, canonical))
+        return suffix.length === 0 ? canonical : join4(canonical, ...suffix);
+    }
+    const parent = dirname8(current);
+    if (parent === current)
+      return;
+    suffix.unshift(basename3(current));
+    current = parent;
+  }
+}
+function existingDirectoryInsideContext(directory, cwd) {
+  if (!existsSync10(directory))
+    return;
+  const canonical = realpathSync4(directory);
+  if (!statSync4(canonical).isDirectory())
+    return;
+  return isPathInside(cwd, canonical) ? canonical : undefined;
+}
+function nearestExistingDirectoryInsideContext(directory, cwd) {
+  let current = directory;
+  while (isPathInside(cwd, current)) {
+    const canonical = existingDirectoryInsideContext(current, cwd);
+    if (canonical !== undefined)
+      return canonical;
+    if (current === cwd)
+      return;
+    current = dirname8(current);
+  }
+  return;
+}
 function formatServerLookupError(result) {
   if (result.status === "not_installed") {
     return formatNotInstalled(result);
@@ -4199,7 +4267,7 @@ function formatNotInstalled(result) {
   ].join(`
 `);
 }
-var READ_ONLY_RETRY_TOOLS = new Set([
+var READ_ONLY_TOOLS = new Set([
   "diagnostics",
   "definition",
   "references",
@@ -4208,7 +4276,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.");
   }
@@ -4223,9 +4291,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);
       }
@@ -4391,7 +4459,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 };
@@ -4655,7 +4723,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) {
@@ -4684,7 +4752,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 = {
@@ -4756,7 +4824,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)
@@ -4781,7 +4849,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;
@@ -4821,7 +4889,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) {
@@ -4842,7 +4910,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) {
@@ -4916,7 +4984,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");
@@ -5260,12 +5328,12 @@ function resolveDaemonRuntime2(env, defaults) {
     throw new InvalidRuntimeOverrideError2("paired_values_required", `${OMO_LSP_DAEMON_CLI2} and ${OMO_LSP_DAEMON_VERSION2} must be set together`);
   }
   if (!hasCliOverride || !hasVersionOverride) {
-    if (!isAbsolute4(defaults.cliPath)) {
+    if (!isAbsolute5(defaults.cliPath)) {
       throw new InvalidRuntimeOverrideError2("packaged_cli_must_be_absolute", "Packaged LSP daemon CLI path must be absolute");
     }
     return { cliPath: defaults.cliPath, version: validateDaemonVersion2(defaults.version) };
   }
-  if (!isAbsolute4(cliOverride)) {
+  if (!isAbsolute5(cliOverride)) {
     throw new InvalidRuntimeOverrideError2("cli_must_be_absolute", `${OMO_LSP_DAEMON_CLI2} must be an absolute path to an existing regular file`);
   }
   const stat = statSync5(cliOverride, { throwIfNoEntry: false });
@@ -5386,8 +5454,8 @@ function extensionKey(filePath) {
 }
 // ../../../../lsp-core/src/request-context.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-import { existsSync as existsSync11, realpathSync as realpathSync4, statSync as statSync6 } from "node:fs";
-import { basename as basename3, delimiter as delimiter4, dirname as dirname2, isAbsolute as isAbsolute5, join as join7, relative as relative5, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync12, realpathSync as realpathSync5, statSync as statSync6 } from "node:fs";
+import { basename as basename4, delimiter as delimiter4, dirname as dirname2, isAbsolute as isAbsolute6, join as join7, relative as relative5, resolve as resolve9 } from "node:path";
 
 class LspRequestContextParseError2 extends Error {
   code;
@@ -5430,17 +5498,17 @@ function parseLspRequestContext2(value) {
 }
 function canonicalCwd2(cwd) {
   const resolved = resolve9(cwd);
-  if (!existsSync11(resolved) || !statSync6(resolved).isDirectory()) {
+  if (!existsSync12(resolved) || !statSync6(resolved).isDirectory()) {
     throw new LspRequestContextParseError2("invalid_cwd", `LSP request cwd must be an existing directory: ${cwd}`);
   }
-  return realpathSync4(resolved);
+  return realpathSync5(resolved);
 }
 function canonicalizeExistingOrNearestAncestor2(path2) {
   let current = resolve9(path2);
   const suffix = [];
   while (true) {
     try {
-      const existing = realpathSync4(current);
+      const existing = realpathSync5(current);
       return suffix.length === 0 ? existing : join7(existing, ...suffix);
     } catch (error) {
       if (!isMissingPathError2(error))
@@ -5448,7 +5516,7 @@ function canonicalizeExistingOrNearestAncestor2(path2) {
       const parent = dirname2(current);
       if (parent === current)
         throw error;
-      suffix.unshift(basename3(current));
+      suffix.unshift(basename4(current));
       current = parent;
     }
   }
@@ -5479,14 +5547,14 @@ function stringArrayField2(value, field) {
   return fieldValue;
 }
 function requireAbsolutePath2(path2, field) {
-  if (!isAbsolute5(path2)) {
+  if (!isAbsolute6(path2)) {
     throw new LspRequestContextParseError2("relative_path", `LSP request context.${field} must be absolute: ${path2}`);
   }
 }
 function isPathInside2(parent, child) {
   const childPath = resolve9(child);
   const relativePath = relative5(parent, childPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute5(relativePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute6(relativePath);
 }
 function isMissingPathError2(error) {
   const code = errorCode2(error);
@@ -5509,7 +5577,7 @@ function errorCode2(error) {
 }
 
 // src/daemon-cli-path.ts
-import { existsSync as existsSync13, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync6 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { dirname as dirname9, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
@@ -5533,7 +5601,7 @@ function resolveLspDaemonCli() {
   if (packageCli !== null)
     return resolveConfiguredLspDaemonCli(packageCli);
   const bundledCli = fileURLToPath4(new URL("../../lsp-daemon/dist/cli.js", import.meta.url));
-  if (existsSync13(bundledCli))
+  if (existsSync14(bundledCli))
     return resolveConfiguredLspDaemonCli(bundledCli);
   return resolveConfiguredLspDaemonCli(bundledCli);
 }
@@ -5761,7 +5829,7 @@ function notConfiguredAvailability(details) {
   return typeof extension === "string" && extension.length > 0 ? { extension } : undefined;
 }
 function codexLspRequestContext(env = process.env, cwd = process.cwd()) {
-  const canonicalCwd3 = realpathSync6(resolve11(cwd));
+  const canonicalCwd3 = realpathSync7(resolve11(cwd));
   const codexHome = resolve11(env["CODEX_HOME"]?.trim() || join11(homedir3(), ".codex"));
   return parseLspRequestContext2({
     cwd: canonicalCwd3,

package/packages/omo-codex/plugin/components/lsp/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "(OmO 4.19.4) Checking LSP Diagnostics"
+						"statusMessage": "(OmO 5.0.0-beta.10) Checking LSP Diagnostics"
 					}
 				]
 			}
@@ -21,7 +21,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.19.4) Resetting LSP Diagnostics Cache"
+						"statusMessage": "(OmO 5.0.0-beta.10) Resetting LSP Diagnostics Cache"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/lsp/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lsp",
-	"version": "4.19.4",
+	"version": "5.0.0-beta.10",
 	"description": "Codex plugin that exposes Language Server Protocol tools and post-edit diagnostics.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/rules/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.19.4) Loading Project Rules"
+						"statusMessage": "(OmO 5.0.0-beta.10) Loading Project Rules"
 					}
 				]
 			}
@@ -19,7 +19,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook user-prompt-submit",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.19.4) Loading Project Rules"
+						"statusMessage": "(OmO 5.0.0-beta.10) Loading Project Rules"
 					}
 				]
 			}
@@ -32,7 +32,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.19.4) Matching Project Rules"
+						"statusMessage": "(OmO 5.0.0-beta.10) Matching Project Rules"
 					}
 				]
 			}
@@ -45,7 +45,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.19.4) Resetting Project Rule Cache"
+						"statusMessage": "(OmO 5.0.0-beta.10) Resetting Project Rule Cache"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/rules/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-rules",
-	"version": "4.19.4",
+	"version": "5.0.0-beta.10",
 	"description": "Codex plugin that injects project rule files into model context through lifecycle hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/rules/test/bundled-rules-priority.test.ts

@@ -1,19 +1,22 @@
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { RuleCandidate } from "@oh-my-opencode/rules-engine/engine";
+import {
+	createEngine,
+	defaultConfig,
+	type EngineDeps,
+	resolvePluginRulesRoot,
+	SOURCE_PRIORITY,
+} from "@oh-my-opencode/rules-engine/engine";
 import { afterEach, describe, expect, it } from "vitest";
-
 import { configFromEnvironment } from "../src/config.js";
-import { SOURCE_PRIORITY } from "@oh-my-opencode/rules-engine/engine";
-import { createEngine, defaultConfig, type EngineDeps } from "@oh-my-opencode/rules-engine/engine";
-import { resolvePluginRulesRoot } from "@oh-my-opencode/rules-engine/engine";
-import type { RuleCandidate } from "@oh-my-opencode/rules-engine/engine";
 
 const projectRoot = "/tmp/codex-rules-bundled-priority";
 const bundledPath = join(projectRoot, "bundled-rules", "hephaestus.md");
 const homePath = join(projectRoot, "home", ".opencode", "rules", "hephaestus.md");
-const bundledBody = "Bundled baseline discipline.";
-const homeBody = "Home baseline discipline override.";
+const bundledBody = "BUNDLED_BASELINE_SENTINEL";
+const homeBody = "HOME_OVERRIDE_SENTINEL";
 const tempDirectories: string[] = [];
 
 afterEach(() => {
@@ -35,14 +38,7 @@ function globalCandidate(source: "plugin-bundled" | "~/.opencode/rules", path: s
 }
 
 function ruleMarkdown(body: string): string {
-	return [
-		"---",
-		"description: OMO Hephaestus baseline discipline for Codex",
-		"alwaysApply: true",
-		"---",
-		"",
-		body,
-	].join("\n");
+	return ["---", "description: Fixture", "alwaysApply: true", "---", "", body].join("\n");
 }
 
 describe("plugin bundled rule priority", () => {
@@ -85,7 +81,6 @@ describe("plugin bundled rule priority", () => {
 		// then
 		expect(formatted).toContain(homePath);
 		expect(formatted).toContain(homeBody);
-		expect(formatted).not.toContain(`- [hephaestus.md]{${homePath}}`);
 		expect(formatted).not.toContain(bundledPath);
 		expect(formatted).not.toContain(bundledBody);
 	});