oh-my-opencode 4.11.1 → 4.12.1

package/dist/cli-node/index.js

@@ -2146,7 +2146,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "oh-my-opencode",
-    version: "4.11.1",
+    version: "4.12.1",
     description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
     main: "./dist/index.js",
     types: "dist/index.d.ts",
@@ -2316,18 +2316,18 @@ var init_package = __esm(() => {
       typescript: "^6.0.3"
     },
     optionalDependencies: {
-      "oh-my-opencode-darwin-arm64": "4.11.1",
-      "oh-my-opencode-darwin-x64": "4.11.1",
-      "oh-my-opencode-darwin-x64-baseline": "4.11.1",
-      "oh-my-opencode-linux-arm64": "4.11.1",
-      "oh-my-opencode-linux-arm64-musl": "4.11.1",
-      "oh-my-opencode-linux-x64": "4.11.1",
-      "oh-my-opencode-linux-x64-baseline": "4.11.1",
-      "oh-my-opencode-linux-x64-musl": "4.11.1",
-      "oh-my-opencode-linux-x64-musl-baseline": "4.11.1",
-      "oh-my-opencode-windows-arm64": "4.11.1",
-      "oh-my-opencode-windows-x64": "4.11.1",
-      "oh-my-opencode-windows-x64-baseline": "4.11.1"
+      "oh-my-opencode-darwin-arm64": "4.12.1",
+      "oh-my-opencode-darwin-x64": "4.12.1",
+      "oh-my-opencode-darwin-x64-baseline": "4.12.1",
+      "oh-my-opencode-linux-arm64": "4.12.1",
+      "oh-my-opencode-linux-arm64-musl": "4.12.1",
+      "oh-my-opencode-linux-x64": "4.12.1",
+      "oh-my-opencode-linux-x64-baseline": "4.12.1",
+      "oh-my-opencode-linux-x64-musl": "4.12.1",
+      "oh-my-opencode-linux-x64-musl-baseline": "4.12.1",
+      "oh-my-opencode-windows-arm64": "4.12.1",
+      "oh-my-opencode-windows-x64": "4.12.1",
+      "oh-my-opencode-windows-x64-baseline": "4.12.1"
     },
     overrides: {
       hono: "^4.12.18",
@@ -7371,6 +7371,14 @@ var init_classify_path_environment = () => {};
 
 // packages/utils/src/codegraph/env.ts
 var init_env = () => {};
+
+// packages/utils/src/codegraph/workspace.ts
+var init_workspace = () => {};
+
+// packages/utils/src/codegraph/guidance.ts
+var init_guidance = __esm(() => {
+  init_workspace();
+});
 // packages/utils/src/codegraph/manifest.ts
 var init_manifest = () => {};
 
@@ -7391,12 +7399,10 @@ var init_resolve2 = __esm(() => {
   requireFromHere = createRequire2(import.meta.url);
 });
 
-// packages/utils/src/codegraph/workspace.ts
-var init_workspace = () => {};
-
 // packages/utils/src/codegraph/index.ts
 var init_codegraph = __esm(() => {
   init_env();
+  init_guidance();
   init_provision();
   init_resolve2();
   init_workspace();
@@ -56796,7 +56802,7 @@ async function probe(registration) {
     registration.available = false;
     return false;
   }
-  const probeUrl = new URL("/session", registration.serverUrl);
+  const probeUrl = new URL("/global/health", registration.serverUrl);
   const authHeader = getServerBasicAuthHeader();
   const headers = authHeader ? { Authorization: authHeader } : {};
   try {
@@ -56830,12 +56836,17 @@ async function probe(registration) {
     return false;
   }
 }
-function hasFreshProbe(registration) {
-  return registration.available !== undefined && Date.now() - registration.probeTimestamp < PROBE_TTL_MS;
+function getFreshProbeAvailability(registration) {
+  const available = registration.available;
+  if (available === undefined || Date.now() - registration.probeTimestamp >= PROBE_TTL_MS) {
+    return;
+  }
+  return available;
 }
 async function resolveAvailability(registration) {
-  if (hasFreshProbe(registration)) {
-    return registration.available;
+  const freshAvailability = getFreshProbeAvailability(registration);
+  if (freshAvailability !== undefined) {
+    return freshAvailability;
   }
   if (!registration.inFlightProbe) {
     registration.inFlightProbe = probe(registration).finally(() => {
@@ -56870,10 +56881,11 @@ function tryResolveDispatchClientSync2(client3, sessionID) {
   if (!registration.serverUrl) {
     return { client: client3, route: "in-process", reason: "unavailable" };
   }
-  if (!hasFreshProbe(registration)) {
+  const freshAvailability = getFreshProbeAvailability(registration);
+  if (freshAvailability === undefined) {
     return;
   }
-  if (!registration.available) {
+  if (!freshAvailability) {
     return { client: client3, route: "in-process", reason: "unavailable" };
   }
   const resolvedLiveClient = getOrBuildLiveClient(registration);
@@ -56888,6 +56900,9 @@ async function resolveDispatchClient2(client3, sessionID) {
     return syncResult;
   }
   const registration = registrations.get(client3);
+  if (!registration) {
+    return { client: client3, route: "in-process", reason: "identity" };
+  }
   const isAvailable = await resolveAvailability(registration);
   if (!isAvailable) {
     return { client: client3, route: "in-process", reason: "unavailable" };
@@ -58938,20 +58953,20 @@ var init_config_manager = __esm(() => {
 
 // packages/telemetry-core/src/activity-state.ts
 import { existsSync as existsSync27, mkdirSync as mkdirSync8, readFileSync as readFileSync13 } from "node:fs";
-import { basename as basename9, join as join47 } from "node:path";
+import { basename as basename9, join as join48 } from "node:path";
 function resolveTelemetryStateDir(product, options = {}) {
   const dataDir = resolveXdgDataDir(product.cacheDirName, {
     env: options.env,
     osProvider: options.osProvider
   });
-  const xdgStateDir = options.env?.XDG_DATA_HOME === undefined ? undefined : join47(options.env.XDG_DATA_HOME, product.cacheDirName);
+  const xdgStateDir = options.env?.XDG_DATA_HOME === undefined ? undefined : join48(options.env.XDG_DATA_HOME, product.cacheDirName);
   if (dataDir === xdgStateDir || xdgStateDir === undefined && basename9(dataDir) === product.cacheDirName) {
     return dataDir;
   }
-  return join47(dataDir, product.cacheDirName);
+  return join48(dataDir, product.cacheDirName);
 }
 function getTelemetryActivityStateFilePath(stateDir) {
-  return join47(stateDir, POSTHOG_ACTIVITY_STATE_FILE);
+  return join48(stateDir, POSTHOG_ACTIVITY_STATE_FILE);
 }
 function getDailyActiveCaptureState(input) {
   const state = readPostHogActivityState(input.stateDir, input.diagnostics);
@@ -59022,9 +59037,9 @@ var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com", DEFAULT_POSTHOG_API_KEY =
 
 // packages/telemetry-core/src/diagnostics.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync28, mkdirSync as mkdirSync9, readFileSync as readFileSync14 } from "node:fs";
-import { join as join48 } from "node:path";
+import { join as join49 } from "node:path";
 function getTelemetryDiagnosticsFilePath(diagnosticsDir) {
-  return join48(diagnosticsDir, DIAGNOSTICS_FILE_NAME);
+  return join49(diagnosticsDir, DIAGNOSTICS_FILE_NAME);
 }
 function writeTelemetryDiagnostic(input, options) {
   const now = options.now ?? new Date;
@@ -59190,7 +59205,7 @@ function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetr
 var init_machine_id = () => {};
 
 // node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname15, posix as posix2, sep as sep6 } from "path";
+import { dirname as dirname15, posix as posix2, sep as sep7 } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -59199,7 +59214,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname15(process.argv[1]) : process.cwd(), isWindows = sep6 === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname15(process.argv[1]) : process.cwd(), isWindows = sep7 === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -62220,9 +62235,9 @@ var init_context_lines_node = __esm(() => {
 });
 
 // node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
-import { isAbsolute as isAbsolute7, relative as relative5, sep as sep7 } from "path";
+import { isAbsolute as isAbsolute7, relative as relative5, sep as sep8 } from "path";
 function createRelativePathModifier(basePath = process.cwd()) {
-  const isWindows = sep7 === "\\";
+  const isWindows = sep8 === "\\";
   const toUnix = (p) => isWindows ? p.replace(/\\/g, "/") : p;
   const normalizedBase = toUnix(basePath);
   return async (frames) => {
@@ -64749,7 +64764,7 @@ var package_default2;
 var init_package2 = __esm(() => {
   package_default2 = {
     name: "@oh-my-opencode/omo-codex",
-    version: "4.11.1",
+    version: "4.12.1",
     type: "module",
     private: true,
     description: "Codex harness adapter for oh-my-openagent. Vendored Codex plugin namespace (omo) + TypeScript installer + telemetry.",
@@ -65719,7 +65734,7 @@ var init_update_toasts = __esm(() => {
 
 // packages/omo-opencode/src/hooks/auto-update-checker/hook/background-update-check.ts
 import { existsSync as existsSync47 } from "node:fs";
-import { dirname as dirname23, join as join64 } from "node:path";
+import { dirname as dirname23, join as join65 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function defaultGetModuleHostingWorkspace() {
   try {
@@ -65873,7 +65888,7 @@ var init_background_update_check = __esm(() => {
   init_update_toasts();
   defaultDeps4 = {
     existsSync: existsSync47,
-    join: join64,
+    join: join65,
     runBunInstallWithDetails,
     log: log2,
     getOpenCodeCacheDir,
@@ -66475,7 +66490,7 @@ function getUnsupportedOpenCodeVersionMessage(openCodeVersion) {
 }
 
 // packages/omo-codex/src/install/install-codex.ts
-import { join as join49, resolve as resolve14 } from "node:path";
+import { join as join50, resolve as resolve14 } from "node:path";
 import { existsSync as existsSync29 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 
@@ -66839,8 +66854,8 @@ async function existingNonSymlink(path7) {
   }
 }
 // packages/omo-codex/src/install/codex-cache-install.ts
-import { cp as cp2, mkdir as mkdir3, readFile as readFile6, rename, rm as rm3 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname11, join as join30, sep as sep4 } from "node:path";
+import { cp as cp2, mkdir as mkdir3, readFile as readFile7, rename, rm as rm3 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname11, join as join31, sep as sep5 } from "node:path";
 
 // packages/omo-codex/src/install/codex-cache-bundled-mcps.ts
 import { cp, mkdir as mkdir2, readFile as readFile3, stat as stat2 } from "node:fs/promises";
@@ -67178,13 +67193,83 @@ async function rewriteCachedManifestRoot(pluginRoot, fromRoot, toRoot) {
 `);
 }
 
+// packages/omo-codex/src/install/codex-hook-targets.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join30, sep as sep4 } from "node:path";
+var PLUGIN_ROOT_TARGET_PATTERN = /\$\{PLUGIN_ROOT\}[\\/]+([^"']+)/g;
+async function findMissingHookCommandTargets(pluginRoot) {
+  const commands = [];
+  for (const manifestPath of await hookManifestPaths(pluginRoot)) {
+    if (!await fileExistsStrict(manifestPath))
+      continue;
+    const parsed = JSON.parse(await readFile6(manifestPath, "utf8"));
+    collectCommands(parsed, commands);
+  }
+  const missing = [];
+  const seen = new Set;
+  for (const command of commands) {
+    for (const match of command.matchAll(PLUGIN_ROOT_TARGET_PATTERN)) {
+      const targetSuffix = match[1];
+      if (targetSuffix === undefined)
+        continue;
+      const target = join30(pluginRoot, ...targetSuffix.split(/[\\/]+/));
+      if (seen.has(target))
+        continue;
+      seen.add(target);
+      if (!await fileExistsStrict(target))
+        missing.push(target);
+    }
+  }
+  return missing;
+}
+async function hookManifestPaths(pluginRoot) {
+  const pluginManifestPath = join30(pluginRoot, ".codex-plugin", "plugin.json");
+  if (!await fileExistsStrict(pluginManifestPath))
+    return [join30(pluginRoot, "hooks", "hooks.json")];
+  const parsed = JSON.parse(await readFile6(pluginManifestPath, "utf8"));
+  if (!isPlainRecord3(parsed))
+    return [];
+  if (typeof parsed.hooks === "string" && parsed.hooks.trim() !== "") {
+    return [join30(pluginRoot, stripDotSlash(parsed.hooks))];
+  }
+  if (Array.isArray(parsed.hooks)) {
+    return parsed.hooks.filter((hookPath) => typeof hookPath === "string" && hookPath.trim() !== "").map((hookPath) => join30(pluginRoot, stripDotSlash(hookPath)));
+  }
+  return [];
+}
+function stripDotSlash(path7) {
+  return path7.startsWith("./") ? path7.slice(2) : path7;
+}
+async function assertHookCommandTargets(pluginRoot) {
+  const missing = await findMissingHookCommandTargets(pluginRoot);
+  if (missing.length === 0)
+    return;
+  const relativeMissing = missing.map((path7) => path7.split(`${pluginRoot}${sep4}`).join("").split(sep4).join("/"));
+  throw new Error(`Plugin payload is missing ${missing.length} hook command target(s) referenced by hooks.json: ${relativeMissing.join(", ")}. ` + "The previous plugin cache was left untouched; this payload was not activated.");
+}
+function collectCommands(value, commands) {
+  if (Array.isArray(value)) {
+    for (const entry of value)
+      collectCommands(entry, commands);
+    return;
+  }
+  if (!isPlainRecord3(value))
+    return;
+  if (value["type"] === "command" && typeof value["command"] === "string")
+    commands.push(value["command"]);
+  if (value["type"] === "command" && typeof value["commandWindows"] === "string")
+    commands.push(value["commandWindows"]);
+  for (const entry of Object.values(value))
+    collectCommands(entry, commands);
+}
+
 // packages/omo-codex/src/install/codex-cache-install.ts
 async function installCachedPlugin(input) {
   if (input.buildSource !== false) {
     await maybeRunNpmInstall(input.sourcePath, input.runCommand);
     await maybeRunNpmBuild(input.sourcePath, input.runCommand);
   }
-  const targetPath = join30(input.codexHome, "plugins", "cache", input.marketplaceName, input.name, input.version);
+  const targetPath = join31(input.codexHome, "plugins", "cache", input.marketplaceName, input.name, input.version);
   const tempPath = createTempSiblingPath(targetPath);
   await rm3(tempPath, { recursive: true, force: true });
   try {
@@ -67192,8 +67277,11 @@ async function installCachedPlugin(input) {
     await rewriteCachedPackageLocalFileDependencies(tempPath, input.sourcePath);
     await copyBundledMcpRuntimeDists({ pluginRoot: tempPath, sourceRoot: input.sourcePath });
     await maybeRunNpmInstall(tempPath, input.runCommand, ["ci", "--omit=dev"]);
+    if (input.buildSource === false)
+      await maybeRunNpmSyncSkills(tempPath, input.runCommand);
     await rewriteCachedMcpManifest(tempPath, input.sourcePath);
     await rewriteCachedManifestRoot(tempPath, tempPath, targetPath);
+    await assertHookCommandTargets(tempPath);
     await promoteDirectory(tempPath, targetPath, input.renameDirectory ?? rename);
   } catch (error) {
     await rm3(tempPath, { recursive: true, force: true });
@@ -67202,14 +67290,14 @@ async function installCachedPlugin(input) {
   return { name: input.name, version: input.version, path: targetPath };
 }
 async function maybeRunNpmInstall(cwd, runCommand, args = ["install"]) {
-  if (!await fileExistsStrict(join30(cwd, "package.json")))
+  if (!await fileExistsStrict(join31(cwd, "package.json")))
     return;
   await runCommand("npm", args, { cwd });
 }
 async function maybeRunNpmBuild(cwd, runCommand) {
-  if (!await fileExistsStrict(join30(cwd, "package.json")))
+  if (!await fileExistsStrict(join31(cwd, "package.json")))
     return;
-  const packageJson = JSON.parse(await readFile6(join30(cwd, "package.json"), "utf8"));
+  const packageJson = JSON.parse(await readFile7(join31(cwd, "package.json"), "utf8"));
   if (!isPlainRecord3(packageJson))
     return;
   const scripts = packageJson.scripts;
@@ -67217,11 +67305,22 @@ async function maybeRunNpmBuild(cwd, runCommand) {
     return;
   await runCommand("npm", ["run", "build"], { cwd });
 }
+async function maybeRunNpmSyncSkills(cwd, runCommand) {
+  if (!await fileExistsStrict(join31(cwd, "package.json")))
+    return;
+  const packageJson = JSON.parse(await readFile7(join31(cwd, "package.json"), "utf8"));
+  if (!isPlainRecord3(packageJson))
+    return;
+  const scripts = packageJson.scripts;
+  if (!isPlainRecord3(scripts) || typeof scripts["sync:skills"] !== "string")
+    return;
+  await runCommand("npm", ["run", "sync:skills"], { cwd });
+}
 function createTempSiblingPath(targetPath) {
-  return join30(dirname11(targetPath), `.tmp-${basename6(targetPath)}-${process.pid}-${Date.now()}`);
+  return join31(dirname11(targetPath), `.tmp-${basename6(targetPath)}-${process.pid}-${Date.now()}`);
 }
 function createBackupSiblingPath(targetPath) {
-  return join30(dirname11(targetPath), `.backup-${basename6(targetPath)}-${process.pid}-${Date.now()}`);
+  return join31(dirname11(targetPath), `.backup-${basename6(targetPath)}-${process.pid}-${Date.now()}`);
 }
 async function copyDirectory(sourcePath, targetPath) {
   await mkdir3(dirname11(targetPath), { recursive: true });
@@ -67252,17 +67351,17 @@ async function restoreBackupDirectory(backupPath, targetPath, renameDirectory) {
   await renameDirectory(backupPath, targetPath);
 }
 function shouldCopyPluginPath(path7, root) {
-  const relative5 = path7 === root ? "" : path7.slice(root.length + sep4.length);
+  const relative5 = path7 === root ? "" : path7.slice(root.length + sep5.length);
   if (relative5 === "")
     return true;
-  const parts = relative5.split(sep4);
+  const parts = relative5.split(sep5);
   return !parts.some((part) => part === ".git" || part === "node_modules");
 }
 // packages/omo-codex/src/install/codex-cache-prune.ts
 import { lstat as lstat4, readdir as readdir3, rm as rm4, stat as stat3 } from "node:fs/promises";
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 async function pruneMarketplaceCache(input) {
-  const cacheRoot = join31(input.codexHome, "plugins", "cache", input.marketplaceName);
+  const cacheRoot = join32(input.codexHome, "plugins", "cache", input.marketplaceName);
   if (!await fileExistsStrict(cacheRoot))
     return;
   const keep = new Set(input.keepPluginNames);
@@ -67270,15 +67369,15 @@ async function pruneMarketplaceCache(input) {
   for (const entry of entries) {
     if (!entry.isDirectory() || keep.has(entry.name))
       continue;
-    await rm4(join31(cacheRoot, entry.name), { recursive: true, force: true });
+    await rm4(join32(cacheRoot, entry.name), { recursive: true, force: true });
   }
 }
 async function pruneMarketplacePluginCaches(input) {
-  const cacheRoot = join31(input.codexHome, "plugins", "cache", input.marketplaceName);
+  const cacheRoot = join32(input.codexHome, "plugins", "cache", input.marketplaceName);
   if (!await fileExistsStrict(cacheRoot))
     return;
   for (const pluginName of input.pluginNames) {
-    await rm4(join31(cacheRoot, pluginName), { recursive: true, force: true });
+    await rm4(join32(cacheRoot, pluginName), { recursive: true, force: true });
   }
   const remainingEntries = await readCacheEntryNames(cacheRoot);
   if (remainingEntries.length === 0) {
@@ -67325,11 +67424,11 @@ async function isBrokenCacheSymlink(path7) {
 }
 // packages/omo-codex/src/install/codex-cached-marketplace-manifest.ts
 import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 async function writeCachedMarketplaceManifest(input) {
-  const marketplaceDir = join32(input.marketplaceRoot, ".agents", "plugins");
+  const marketplaceDir = join33(input.marketplaceRoot, ".agents", "plugins");
   await mkdir4(marketplaceDir, { recursive: true });
-  await writeFile4(join32(marketplaceDir, "marketplace.json"), `${JSON.stringify({
+  await writeFile4(join33(marketplaceDir, "marketplace.json"), `${JSON.stringify({
     name: input.marketplaceName,
     plugins: input.plugins.map((plugin) => ({
       name: plugin.name,
@@ -67341,8 +67440,8 @@ async function writeCachedMarketplaceManifest(input) {
 
 // packages/omo-codex/src/install/codex-package-layout.ts
 import { existsSync as existsSync26 } from "node:fs";
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join33 } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { join as join34 } from "node:path";
 var PACKAGED_CODEX_INSTALLER_NAMES = new Set([
   "@code-yeongyu/lazycodex",
   "@code-yeongyu/lazycodex-ai",
@@ -67352,19 +67451,19 @@ var PACKAGED_CODEX_INSTALLER_NAMES = new Set([
   "oh-my-openagent"
 ]);
 async function shouldBuildSourcePackages(repoRoot) {
-  if (existsSync26(join33(repoRoot, "packages", "omo-opencode", "src", "index.ts")))
+  if (existsSync26(join34(repoRoot, "packages", "omo-opencode", "src", "index.ts")))
     return true;
-  const packageJsonPath = join33(repoRoot, "package.json");
+  const packageJsonPath = join34(repoRoot, "package.json");
   if (!existsSync26(packageJsonPath))
     return true;
-  const packageJson = JSON.parse(await readFile7(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await readFile8(packageJsonPath, "utf8"));
   if (!isPlainRecord3(packageJson) || typeof packageJson.name !== "string")
     return true;
   return !PACKAGED_CODEX_INSTALLER_NAMES.has(packageJson.name);
 }
 
 // packages/omo-codex/src/install/codex-config-toml.ts
-import { mkdir as mkdir5, readFile as readFile9 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile10 } from "node:fs/promises";
 import { dirname as dirname13 } from "node:path";
 
 // packages/omo-codex/src/install/toml-section-editor.ts
@@ -67552,12 +67651,12 @@ function tomlKeySegment(value) {
 
 // packages/omo-codex/src/install/codex-config-atomic-write.ts
 import { lstat as lstat5, readlink as readlink3, realpath, rename as rename2, unlink, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename7, dirname as dirname12, isAbsolute as isAbsolute6, join as join34, resolve as resolve11 } from "node:path";
+import { basename as basename7, dirname as dirname12, isAbsolute as isAbsolute6, join as join35, resolve as resolve11 } from "node:path";
 var RENAME_RETRY_DELAYS_MS = [10, 25, 50];
 var RETRIABLE_RENAME_CODES = new Set(["EPERM", "EBUSY"]);
 async function writeFileAtomic(targetPath, data) {
   const writeTarget = await resolveSymlinkTarget(targetPath);
-  const temporaryPath = join34(dirname12(writeTarget), `.tmp-${basename7(writeTarget)}-${process.pid}-${Date.now()}`);
+  const temporaryPath = join35(dirname12(writeTarget), `.tmp-${basename7(writeTarget)}-${process.pid}-${Date.now()}`);
   await writeFile5(temporaryPath, data);
   try {
     await renameWithRetry(temporaryPath, writeTarget);
@@ -67827,8 +67926,8 @@ function isRootSetting(line, key) {
 }
 
 // packages/omo-codex/src/install/codex-model-catalog.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import { join as join35 } from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join36 } from "node:path";
 var FALLBACK_CODEX_MODEL_CATALOG = {
   current: {
     model: "gpt-5.5",
@@ -67847,9 +67946,9 @@ var FALLBACK_CODEX_MODEL_CATALOG = {
   ]
 };
 async function readCodexModelCatalog(codexPackageRoot) {
-  const catalogPath = join35(codexPackageRoot, "plugin", "model-catalog.json");
+  const catalogPath = join36(codexPackageRoot, "plugin", "model-catalog.json");
   try {
-    const parsed = JSON.parse(await readFile8(catalogPath, "utf8"));
+    const parsed = JSON.parse(await readFile9(catalogPath, "utf8"));
     return parseCodexModelCatalog(parsed) ?? FALLBACK_CODEX_MODEL_CATALOG;
   } catch (error) {
     if (error instanceof Error)
@@ -67930,7 +68029,7 @@ async function updateCodexConfig(input) {
   await mkdir5(dirname13(input.configPath), { recursive: true });
   let config = "";
   if (await exists(input.configPath))
-    config = await readFile9(input.configPath, "utf8");
+    config = await readFile10(input.configPath, "utf8");
   const pluginSet = new Set(input.pluginNames);
   for (const legacyMarketplaceName of legacyMarketplaceNames(input.marketplaceName)) {
     config = removeMarketplaceBlock(config, legacyMarketplaceName);
@@ -67966,7 +68065,7 @@ async function updateCodexConfig(input) {
 }
 async function exists(path7) {
   try {
-    await readFile9(path7, "utf8");
+    await readFile10(path7, "utf8");
     return true;
   } catch (error) {
     if (error instanceof Error)
@@ -67977,8 +68076,8 @@ async function exists(path7) {
 
 // packages/omo-codex/src/install/codex-hook-trust.ts
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile10 } from "node:fs/promises";
-import { join as join36 } from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import { join as join37 } from "node:path";
 var EVENT_LABELS = new Map([
   ["PreToolUse", "pre_tool_use"],
   ["PermissionRequest", "permission_request"],
@@ -67992,21 +68091,37 @@ var EVENT_LABELS = new Map([
   ["Stop", "stop"]
 ]);
 async function trustedHookStatesForPlugin(input) {
-  const manifestPath = join36(input.pluginRoot, ".codex-plugin", "plugin.json");
+  const manifestPath = join37(input.pluginRoot, ".codex-plugin", "plugin.json");
   if (!await exists2(manifestPath))
     return [];
-  const manifest = JSON.parse(await readFile10(manifestPath, "utf8"));
-  if (!isPlainRecord3(manifest) || typeof manifest.hooks !== "string")
-    return [];
-  const hooksPath = join36(input.pluginRoot, manifest.hooks);
-  if (!await exists2(hooksPath))
+  const manifest = JSON.parse(await readFile11(manifestPath, "utf8"));
+  if (!isPlainRecord3(manifest))
     return [];
-  const parsed = JSON.parse(await readFile10(hooksPath, "utf8"));
-  if (!isPlainRecord3(parsed) || !isPlainRecord3(parsed.hooks))
+  const states = [];
+  for (const hookPath of hookManifestPaths2(manifest.hooks)) {
+    const hooksPath = join37(input.pluginRoot, hookPath);
+    if (!await exists2(hooksPath))
+      continue;
+    const parsed = JSON.parse(await readFile11(hooksPath, "utf8"));
+    if (!isPlainRecord3(parsed) || !isPlainRecord3(parsed.hooks))
+      continue;
+    states.push(...trustedHookStatesForHooksFile({
+      keySource: `${input.pluginName}@${input.marketplaceName}:${hookPath}`,
+      hooks: parsed.hooks
+    }));
+  }
+  return states;
+}
+function hookManifestPaths2(value) {
+  if (typeof value === "string" && value.trim() !== "")
+    return [stripDotSlash2(value)];
+  if (!Array.isArray(value))
     return [];
-  const keySource = `${input.pluginName}@${input.marketplaceName}:${stripDotSlash(manifest.hooks)}`;
+  return value.filter((item) => typeof item === "string" && item.trim() !== "").map(stripDotSlash2);
+}
+function trustedHookStatesForHooksFile(input) {
   const states = [];
-  for (const [eventName, groups] of Object.entries(parsed.hooks)) {
+  for (const [eventName, groups] of Object.entries(input.hooks)) {
     if (!Array.isArray(groups))
       continue;
     const eventLabel = EVENT_LABELS.get(eventName);
@@ -68022,7 +68137,7 @@ async function trustedHookStatesForPlugin(input) {
           continue;
         if (typeof handler.command !== "string" || handler.command.trim() === "")
           continue;
-        const key = `${keySource}:${eventLabel}:${groupIndex}:${handlerIndex}`;
+        const key = `${input.keySource}:${eventLabel}:${groupIndex}:${handlerIndex}`;
         states.push({ key, trustedHash: commandHookHash(eventLabel, group.matcher, handler) });
       }
     }
@@ -68056,12 +68171,12 @@ function canonicalJson(value) {
   }
   return result;
 }
-function stripDotSlash(value) {
+function stripDotSlash2(value) {
   return value.startsWith("./") ? value.slice(2) : value;
 }
 async function exists2(path7) {
   try {
-    await readFile10(path7, "utf8");
+    await readFile11(path7, "utf8");
     return true;
   } catch (error) {
     if (error instanceof Error)
@@ -68113,12 +68228,12 @@ function toCodexResolution(resolution) {
 }
 
 // packages/omo-codex/src/install/link-cached-plugin-agents.ts
-import { copyFile, lstat as lstat7, mkdir as mkdir6, readFile as readFile12, readdir as readdir4, rm as rm6, writeFile as writeFile6 } from "node:fs/promises";
-import { basename as basename8, join as join38 } from "node:path";
+import { copyFile, lstat as lstat7, mkdir as mkdir6, readFile as readFile13, readdir as readdir4, rm as rm6, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename8, join as join39 } from "node:path";
 
 // packages/omo-codex/src/install/retired-managed-agent-purge.ts
-import { lstat as lstat6, readFile as readFile11, rm as rm5 } from "node:fs/promises";
-import { join as join37 } from "node:path";
+import { lstat as lstat6, readFile as readFile12, rm as rm5 } from "node:fs/promises";
+import { join as join38 } from "node:path";
 var RETIRED_MANAGED_AGENT_FILES = [
   {
     fileName: "codex-ultrawork-reviewer.toml",
@@ -68130,11 +68245,11 @@ var RETIRED_MANAGED_AGENT_FILES = [
   }
 ];
 async function purgeRetiredManagedAgentFiles(input) {
-  const agentsDir = join37(input.codexHome, "agents");
+  const agentsDir = join38(input.codexHome, "agents");
   if (!await exists3(agentsDir))
     return;
   for (const retiredAgent of RETIRED_MANAGED_AGENT_FILES) {
-    const agentPath = join37(agentsDir, retiredAgent.fileName);
+    const agentPath = join38(agentsDir, retiredAgent.fileName);
     if (!await exists3(agentPath))
       continue;
     const agentStat = await lstat6(agentPath);
@@ -68151,7 +68266,7 @@ function hasRequiredMarkers(content, markers) {
 }
 async function readTextIfExists(path7) {
   try {
-    return await readFile11(path7, "utf8");
+    return await readFile12(path7, "utf8");
   } catch (error) {
     if (nodeErrorCode(error) === "ENOENT")
       return null;
@@ -68177,7 +68292,7 @@ function nodeErrorCode(error) {
 // packages/omo-codex/src/install/link-cached-plugin-agents.ts
 var MANIFEST_FILE = ".installed-agents.json";
 async function capturePreservedAgentReasoning(input) {
-  const agentsDir = join38(input.codexHome, "agents");
+  const agentsDir = join39(input.codexHome, "agents");
   if (!await exists4(agentsDir))
     return new Map;
   const preserved = new Map;
@@ -68185,7 +68300,7 @@ async function capturePreservedAgentReasoning(input) {
   for (const entry of agentEntries) {
     if (!entry.name.endsWith(".toml"))
       continue;
-    const content = await readTextIfExists2(join38(agentsDir, entry.name));
+    const content = await readTextIfExists2(join39(agentsDir, entry.name));
     if (content === null)
       continue;
     const effort = extractReasoningEffort(content);
@@ -68195,7 +68310,7 @@ async function capturePreservedAgentReasoning(input) {
   return preserved;
 }
 async function capturePreservedAgentServiceTier(input) {
-  const agentsDir = join38(input.codexHome, "agents");
+  const agentsDir = join39(input.codexHome, "agents");
   if (!await exists4(agentsDir))
     return new Map;
   const preserved = new Map;
@@ -68203,7 +68318,7 @@ async function capturePreservedAgentServiceTier(input) {
   for (const entry of agentEntries) {
     if (!entry.name.endsWith(".toml"))
       continue;
-    const content = await readTextIfExists2(join38(agentsDir, entry.name));
+    const content = await readTextIfExists2(join39(agentsDir, entry.name));
     if (content === null)
       continue;
     preserved.set(agentNameFromToml(entry.name), extractServiceTier(content));
@@ -68217,13 +68332,13 @@ async function linkCachedPluginAgents(input) {
     await writeManifest(input.pluginRoot, []);
     return [];
   }
-  const agentsDir = join38(input.codexHome, "agents");
+  const agentsDir = join39(input.codexHome, "agents");
   await mkdir6(agentsDir, { recursive: true });
   const linked = [];
   for (const agentPath of bundledAgents) {
     const agentFileName = basename8(agentPath);
     const agentName = agentNameFromToml(agentFileName);
-    const linkPath = join38(agentsDir, agentFileName);
+    const linkPath = join39(agentsDir, agentFileName);
     await replaceWithCopy(linkPath, agentPath);
     await restorePreservedReasoning({
       agentName,
@@ -68244,7 +68359,7 @@ async function linkCachedPluginAgents(input) {
 async function restorePreservedServiceTier(input) {
   if (!input.preserved)
     return;
-  const content = await readFile12(input.linkPath, "utf8");
+  const content = await readFile13(input.linkPath, "utf8");
   if (extractServiceTier(content) === input.value)
     return;
   const replacement = replaceServiceTier(content, input.value);
@@ -68253,7 +68368,7 @@ async function restorePreservedServiceTier(input) {
   await writeFile6(input.linkPath, replacement.content);
 }
 async function discoverBundledAgents(pluginRoot) {
-  const componentsRoot = join38(pluginRoot, "components");
+  const componentsRoot = join39(pluginRoot, "components");
   if (!await exists4(componentsRoot))
     return [];
   const componentEntries = await readdir4(componentsRoot, { withFileTypes: true });
@@ -68261,14 +68376,14 @@ async function discoverBundledAgents(pluginRoot) {
   for (const entry of componentEntries) {
     if (!entry.isDirectory())
       continue;
-    const agentsRoot = join38(componentsRoot, entry.name, "agents");
+    const agentsRoot = join39(componentsRoot, entry.name, "agents");
     if (!await exists4(agentsRoot))
       continue;
     const agentEntries = await readdir4(agentsRoot, { withFileTypes: true });
     for (const file2 of agentEntries) {
       if (!file2.isFile() || !file2.name.endsWith(".toml"))
         continue;
-      agents.push(join38(agentsRoot, file2.name));
+      agents.push(join39(agentsRoot, file2.name));
     }
   }
   agents.sort();
@@ -68288,7 +68403,7 @@ async function prepareReplacement(linkPath) {
   await rm6(linkPath, { force: true });
 }
 async function writeManifest(pluginRoot, agentPaths) {
-  const manifestPath = join38(pluginRoot, MANIFEST_FILE);
+  const manifestPath = join39(pluginRoot, MANIFEST_FILE);
   const payload = { agents: [...agentPaths].sort() };
   await writeFile6(manifestPath, `${JSON.stringify(payload, null, "\t")}
 `);
@@ -68296,7 +68411,7 @@ async function writeManifest(pluginRoot, agentPaths) {
 async function restorePreservedReasoning(input) {
   if (input.value === undefined)
     return;
-  const content = await readFile12(input.target, "utf8");
+  const content = await readFile13(input.target, "utf8");
   const bundledEffort = extractReasoningEffort(content);
   if (bundledEffort === input.value)
     return;
@@ -68307,7 +68422,7 @@ async function restorePreservedReasoning(input) {
 }
 async function readTextIfExists2(path7) {
   try {
-    return await readFile12(path7, "utf8");
+    return await readFile13(path7, "utf8");
   } catch (error) {
     if (nodeErrorCode2(error) === "ENOENT")
       return null;
@@ -68415,12 +68530,12 @@ function nodeErrorCode2(error) {
 }
 
 // packages/omo-codex/src/install/codex-marketplace.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join39 } from "node:path";
+import { readFile as readFile14 } from "node:fs/promises";
+import { join as join40 } from "node:path";
 var DEFAULT_MARKETPLACE_PATH = "packages/omo-codex/marketplace.json";
 async function readMarketplace(repoRoot, options) {
-  const marketplacePath = options?.marketplacePath ?? join39(repoRoot, DEFAULT_MARKETPLACE_PATH);
-  const raw = await readFile13(marketplacePath, "utf8");
+  const marketplacePath = options?.marketplacePath ?? join40(repoRoot, DEFAULT_MARKETPLACE_PATH);
+  const raw = await readFile14(marketplacePath, "utf8");
   const parsed = JSON.parse(raw);
   if (!isPlainRecord3(parsed))
     throw new Error("marketplace.json must be an object");
@@ -68438,10 +68553,10 @@ async function readMarketplace(repoRoot, options) {
 function resolvePluginSource(repoRoot, plugin, options) {
   const sourcePath = localSourcePath(options?.pathOverride ?? plugin.source);
   const relativePath = sourcePath.slice(2);
-  return join39(repoRoot, ...relativePath.split(/[\\/]/));
+  return join40(repoRoot, ...relativePath.split(/[\\/]/));
 }
 async function readPluginManifest(pluginRoot) {
-  const raw = await readFile13(join39(pluginRoot, ".codex-plugin", "plugin.json"), "utf8");
+  const raw = await readFile14(join40(pluginRoot, ".codex-plugin", "plugin.json"), "utf8");
   const parsed = JSON.parse(raw);
   if (!isPlainRecord3(parsed))
     throw new Error(`${pluginRoot} plugin.json must be an object`);
@@ -68451,15 +68566,27 @@ async function readPluginManifest(pluginRoot) {
   if (parsed.version !== undefined && (typeof parsed.version !== "string" || parsed.version.trim() === "")) {
     throw new Error(`${pluginRoot} plugin.json version must be a non-empty string`);
   }
-  if (parsed.hooks !== undefined && (typeof parsed.hooks !== "string" || parsed.hooks.trim() === "")) {
-    throw new Error(`${pluginRoot} plugin.json hooks must be a non-empty string`);
+  if (parsed.hooks !== undefined && !isPluginHooksManifestValue(parsed.hooks)) {
+    throw new Error(`${pluginRoot} plugin.json hooks must be a non-empty string or string array`);
   }
   return {
     name: parsed.name,
     version: typeof parsed.version === "string" ? parsed.version.trim() : undefined,
-    hooks: typeof parsed.hooks === "string" ? parsed.hooks.trim() : undefined
+    hooks: normalizePluginHooksManifestValue(parsed.hooks)
   };
 }
+function isPluginHooksManifestValue(value) {
+  if (typeof value === "string")
+    return value.trim() !== "";
+  return Array.isArray(value) && value.every((item) => typeof item === "string" && item.trim() !== "");
+}
+function normalizePluginHooksManifestValue(value) {
+  if (typeof value === "string")
+    return value.trim();
+  if (Array.isArray(value))
+    return value.map((item) => item.trim());
+  return;
+}
 function validatePathSegment(value, label) {
   if (!/^[A-Za-z0-9._+-]+$/.test(value)) {
     throw new Error(`${label} contains unsupported characters: ${value}`);
@@ -68511,7 +68638,7 @@ function validateLocalSourcePath(path7) {
 
 // packages/omo-codex/src/install/codex-marketplace-snapshot.ts
 import { cp as cp3, mkdir as mkdir7, rename as rename3, rm as rm7, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join40, sep as sep5 } from "node:path";
+import { join as join41, sep as sep6 } from "node:path";
 var INSTALLED_MARKETPLACES_DIR = ".tmp/marketplaces";
 async function writeInstalledMarketplaceSnapshot(input) {
   const marketplaceRoot = installedMarketplaceRoot(input.codexHome, input.marketplace.name);
@@ -68524,21 +68651,21 @@ async function writeInstalledMarketplaceSnapshot(input) {
   return snapshotPlugins;
 }
 function installedMarketplaceRoot(codexHome, marketplaceName) {
-  return join40(codexHome, INSTALLED_MARKETPLACES_DIR, marketplaceName);
+  return join41(codexHome, INSTALLED_MARKETPLACES_DIR, marketplaceName);
 }
 async function writeMarketplaceManifest(marketplaceRoot, marketplace) {
-  const manifestDir = join40(marketplaceRoot, ".agents", "plugins");
+  const manifestDir = join41(marketplaceRoot, ".agents", "plugins");
   await mkdir7(manifestDir, { recursive: true });
-  const tempPath = join40(manifestDir, `.marketplace-${process.pid}-${Date.now()}.json.tmp`);
+  const tempPath = join41(manifestDir, `.marketplace-${process.pid}-${Date.now()}.json.tmp`);
   await writeFile7(tempPath, `${JSON.stringify(marketplace, null, "\t")}
 `);
-  await rename3(tempPath, join40(manifestDir, "marketplace.json"));
+  await rename3(tempPath, join41(manifestDir, "marketplace.json"));
 }
 async function writeSnapshotPlugin(marketplaceRoot, plugin) {
-  const pluginsDir = join40(marketplaceRoot, "plugins");
+  const pluginsDir = join41(marketplaceRoot, "plugins");
   await mkdir7(pluginsDir, { recursive: true });
-  const targetPath = join40(pluginsDir, plugin.name);
-  const tempPath = join40(pluginsDir, `.tmp-${plugin.name}-${process.pid}-${Date.now()}`);
+  const targetPath = join41(pluginsDir, plugin.name);
+  const tempPath = join41(pluginsDir, `.tmp-${plugin.name}-${process.pid}-${Date.now()}`);
   await rm7(tempPath, { recursive: true, force: true });
   await cp3(plugin.sourcePath, tempPath, {
     recursive: true,
@@ -68551,19 +68678,19 @@ async function writeSnapshotPlugin(marketplaceRoot, plugin) {
   return { name: plugin.name, path: targetPath };
 }
 function shouldCopyMarketplaceSourcePath(path7, root) {
-  const relative5 = path7 === root ? "" : path7.slice(root.length + sep5.length);
+  const relative5 = path7 === root ? "" : path7.slice(root.length + sep6.length);
   if (relative5 === "")
     return true;
-  const parts = relative5.split(sep5);
+  const parts = relative5.split(sep6);
   return !parts.some((part) => part === ".git" || part === "node_modules");
 }
 
 // packages/omo-codex/src/install/lazycodex-version-stamp.ts
-import { readdir as readdir5, readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join41 } from "node:path";
+import { readdir as readdir5, readFile as readFile15, writeFile as writeFile8 } from "node:fs/promises";
+import { join as join42 } from "node:path";
 async function readDistributionManifest(repoRoot) {
   try {
-    const parsed = JSON.parse(await readFile14(join41(repoRoot, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile15(join42(repoRoot, "package.json"), "utf8"));
     if (!isPlainRecord3(parsed) || typeof parsed.version !== "string" || parsed.version.trim().length === 0)
       return;
     return {
@@ -68583,15 +68710,19 @@ function resolveLazyCodexPluginVersion(input) {
   return input.manifestVersion ?? "local";
 }
 async function stampLazyCodexPluginVersion(input) {
-  await stampJsonVersion(join41(input.pluginRoot, ".codex-plugin", "plugin.json"), input.version);
-  await stampJsonVersion(join41(input.pluginRoot, "package.json"), input.version);
-  await stampHookStatusMessages(join41(input.pluginRoot, "hooks", "hooks.json"), input.version);
+  const manifestPath = join42(input.pluginRoot, ".codex-plugin", "plugin.json");
+  const hookPaths = await readPluginHookPaths(manifestPath);
+  await stampJsonVersion(manifestPath, input.version);
+  await stampJsonVersion(join42(input.pluginRoot, "package.json"), input.version);
+  for (const hookPath of hookPaths) {
+    await stampHookStatusMessages(join42(input.pluginRoot, hookPath), input.version);
+  }
   await stampComponentVersions(input);
 }
 async function writeLazyCodexInstallSnapshot(input) {
   if (input.distributionManifest === undefined)
     return;
-  await writeFile8(join41(input.pluginRoot, "lazycodex-install.json"), `${JSON.stringify({
+  await writeFile8(join42(input.pluginRoot, "lazycodex-install.json"), `${JSON.stringify({
     packageName: input.distributionManifest.name,
     version: input.distributionManifest.version
   }, null, "\t")}
@@ -68599,7 +68730,7 @@ async function writeLazyCodexInstallSnapshot(input) {
 }
 async function stampJsonVersion(path7, version) {
   try {
-    const parsed = JSON.parse(await readFile14(path7, "utf8"));
+    const parsed = JSON.parse(await readFile15(path7, "utf8"));
     if (!isPlainRecord3(parsed))
       return;
     parsed.version = version;
@@ -68611,9 +68742,29 @@ async function stampJsonVersion(path7, version) {
     throw error;
   }
 }
+async function readPluginHookPaths(manifestPath) {
+  try {
+    const parsed = JSON.parse(await readFile15(manifestPath, "utf8"));
+    if (!isPlainRecord3(parsed))
+      return [];
+    if (typeof parsed.hooks === "string" && parsed.hooks.trim().length > 0)
+      return [stripDotSlash3(parsed.hooks)];
+    if (Array.isArray(parsed.hooks)) {
+      return parsed.hooks.filter((hookPath) => typeof hookPath === "string" && hookPath.trim().length > 0).map(stripDotSlash3);
+    }
+    return [];
+  } catch (error) {
+    if (error instanceof Error)
+      return [];
+    throw error;
+  }
+}
+function stripDotSlash3(path7) {
+  return path7.startsWith("./") ? path7.slice(2) : path7;
+}
 async function stampHookStatusMessages(path7, version) {
   try {
-    const parsed = JSON.parse(await readFile14(path7, "utf8"));
+    const parsed = JSON.parse(await readFile15(path7, "utf8"));
     if (!isPlainRecord3(parsed))
       return;
     stampHookGroups(parsed.hooks, version);
@@ -68628,16 +68779,16 @@ async function stampHookStatusMessages(path7, version) {
 async function stampComponentVersions(input) {
   let entries;
   try {
-    entries = await readdir5(join41(input.pluginRoot, "components"));
+    entries = await readdir5(join42(input.pluginRoot, "components"));
   } catch (error) {
     if (error instanceof Error)
       return;
     throw error;
   }
   for (const entry of entries) {
-    const componentRoot = join41(input.pluginRoot, "components", entry);
-    await stampJsonVersion(join41(componentRoot, "package.json"), input.version);
-    await stampHookStatusMessages(join41(componentRoot, "hooks", "hooks.json"), input.version);
+    const componentRoot = join42(input.pluginRoot, "components", entry);
+    await stampJsonVersion(join42(componentRoot, "package.json"), input.version);
+    await stampHookStatusMessages(join42(componentRoot, "hooks", "hooks.json"), input.version);
   }
 }
 function stampHookGroups(hooks, version) {
@@ -68658,7 +68809,7 @@ function stampHookGroups(hooks, version) {
 function stampHookStatusMessage(hook, version) {
   if (!isPlainRecord3(hook) || typeof hook.statusMessage !== "string")
     return;
-  hook.statusMessage = hook.statusMessage.replace(/^LazyCodex\([^)]+\):/, `LazyCodex(${version}):`);
+  hook.statusMessage = hook.statusMessage.replace(/^LazyCodex\([^)]+\):\s*/, "(OmO) ");
 }
 
 // packages/omo-codex/src/install/codex-process.ts
@@ -68690,8 +68841,8 @@ var defaultRunCommand = async (command, args, options) => {
 };
 
 // packages/omo-codex/src/install/codex-project-local-cleanup.ts
-import { copyFile as copyFile2, lstat as lstat8, readFile as readFile15, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname14, join as join42, resolve as resolve12 } from "node:path";
+import { copyFile as copyFile2, lstat as lstat8, readFile as readFile16, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname14, join as join43, resolve as resolve12 } from "node:path";
 var LEGACY_AGENT_CONFLICT_KEYS = ["max_threads"];
 var PROJECT_LOCAL_ARTIFACT_PATHS = [
   ".codex/hooks.json",
@@ -68710,7 +68861,7 @@ async function repairNearestProjectLocalCodexArtifacts(input) {
   const artifacts = await collectProjectLocalArtifacts(project.artifactRoots);
   const configs = [];
   for (const configPath of project.configPaths) {
-    const original = await readFile15(configPath, "utf8");
+    const original = await readFile16(configPath, "utf8");
     const repair = repairProjectLocalCodexConfigText(original);
     if (!repair.changed) {
       configs.push({
@@ -68794,17 +68945,17 @@ async function findProjectLocalCodexConfigs(startDirectory, codexHome) {
   if (startDirectoryStat !== null && !startDirectoryStat.isDirectory()) {
     throw new ProjectLocalCleanupStartDirectoryError(startDirectory);
   }
-  const codexHomeConfigPath = codexHome === undefined ? null : join42(resolve12(codexHome), "config.toml");
+  const codexHomeConfigPath = codexHome === undefined ? null : join43(resolve12(codexHome), "config.toml");
   let current = resolve12(startDirectory);
   const configPathsFromCwd = [];
   while (true) {
-    const configPath = join42(current, ".codex", "config.toml");
+    const configPath = join43(current, ".codex", "config.toml");
     if (await isRegularProjectLocalConfig(current, configPath)) {
       if (codexHomeConfigPath === null || resolve12(configPath) !== codexHomeConfigPath) {
         configPathsFromCwd.push(configPath);
       }
     }
-    if (await exists5(join42(current, ".git"))) {
+    if (await exists5(join43(current, ".git"))) {
       return configPathsFromCwd.length === 0 ? null : {
         projectRoot: current,
         configPaths: [...configPathsFromCwd].reverse(),
@@ -68824,7 +68975,7 @@ async function findProjectLocalCodexConfigs(startDirectory, codexHome) {
   }
 }
 async function isRegularProjectLocalConfig(directory, configPath) {
-  const codexDirStat = await maybeLstat(join42(directory, ".codex"));
+  const codexDirStat = await maybeLstat(join43(directory, ".codex"));
   if (codexDirStat === null || !codexDirStat.isDirectory() || codexDirStat.isSymbolicLink())
     return false;
   const configStat = await maybeLstat(configPath);
@@ -68844,7 +68995,7 @@ async function collectProjectLocalArtifacts(projectRoots) {
   const seenPaths = new Set;
   for (const projectRoot of projectRoots) {
     for (const relativePath of PROJECT_LOCAL_ARTIFACT_PATHS) {
-      const artifactPath = join42(projectRoot, relativePath);
+      const artifactPath = join43(projectRoot, relativePath);
       if (seenPaths.has(artifactPath))
         continue;
       const entryStat = await maybeLstat(artifactPath);
@@ -68919,13 +69070,13 @@ function formatUnknownError(error) {
 }
 
 // packages/omo-codex/src/install/lsp-daemon-reaper.ts
-import { readFile as readFile16, readdir as readdir6, rm as rm8 } from "node:fs/promises";
+import { readFile as readFile17, readdir as readdir6, rm as rm8 } from "node:fs/promises";
 import { connect } from "node:net";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 async function reapLspDaemons(codexHome, deps = {}) {
   const killProcess = deps.killProcess ?? sendSigterm;
   const isDaemonLive = deps.isDaemonLive ?? probeSocketLive;
-  const daemonRoot = join43(codexHome, "codex-lsp", "daemon");
+  const daemonRoot = join44(codexHome, "codex-lsp", "daemon");
   const reaped = [];
   let entries;
   try {
@@ -68934,9 +69085,9 @@ async function reapLspDaemons(codexHome, deps = {}) {
     return reaped;
   }
   for (const entry of entries) {
-    const versionDir = join43(daemonRoot, entry);
-    const pid = await readPidFile(join43(versionDir, "daemon.pid"));
-    const socketPath = await readEndpointFile(join43(versionDir, "daemon.endpoint"));
+    const versionDir = join44(daemonRoot, entry);
+    const pid = await readPidFile(join44(versionDir, "daemon.pid"));
+    const socketPath = await readEndpointFile(join44(versionDir, "daemon.endpoint"));
     if (pid !== null && socketPath !== null && await isDaemonLive(socketPath) && killProcess(pid)) {
       reaped.push(pid);
     }
@@ -68946,7 +69097,7 @@ async function reapLspDaemons(codexHome, deps = {}) {
 }
 async function readEndpointFile(path7) {
   try {
-    const content = (await readFile16(path7, "utf8")).trim();
+    const content = (await readFile17(path7, "utf8")).trim();
     return content.length > 0 ? content : null;
   } catch {
     return null;
@@ -68954,7 +69105,7 @@ async function readEndpointFile(path7) {
 }
 async function readPidFile(path7) {
   try {
-    const pid = Number.parseInt((await readFile16(path7, "utf8")).trim(), 10);
+    const pid = Number.parseInt((await readFile17(path7, "utf8")).trim(), 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
     return null;
@@ -68990,7 +69141,7 @@ function sendSigterm(pid) {
 
 // packages/omo-codex/src/install/codex-installer-bin-dir.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join44, resolve as resolve13 } from "node:path";
+import { join as join45, resolve as resolve13 } from "node:path";
 function resolveCodexInstallerBinDir(input) {
   const explicitBinDir = input.binDir ?? input.env?.CODEX_LOCAL_BIN_DIR;
   if (explicitBinDir !== undefined && explicitBinDir.trim().length > 0)
@@ -68999,15 +69150,15 @@ function resolveCodexInstallerBinDir(input) {
   const defaultCodexHome = resolve13(homeDir, ".codex");
   const resolvedCodexHome = resolve13(input.codexHome);
   if (resolvedCodexHome !== defaultCodexHome)
-    return join44(resolvedCodexHome, "bin");
+    return join45(resolvedCodexHome, "bin");
   return resolve13(homeDir, ".local", "bin");
 }
 
 // packages/omo-codex/src/install/omo-sot-migration.ts
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 async function seedAndMigrateOmoSot(input) {
   const commandEnv = { ...input.env };
-  const scriptPath = join45(input.repoRoot, "packages", "omo-codex", "plugin", "scripts", "migrate-omo-sot.mjs");
+  const scriptPath = join46(input.repoRoot, "packages", "omo-codex", "plugin", "scripts", "migrate-omo-sot.mjs");
   try {
     await input.runCommand(process.execPath, [scriptPath, "--seed"], {
       cwd: input.repoRoot,
@@ -69022,7 +69173,7 @@ async function seedAndMigrateOmoSot(input) {
 
 // packages/omo-codex/src/install/install-ast-grep-sg.ts
 init_src();
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 function describeResult(result) {
   if (result.kind === "succeeded")
     return null;
@@ -69036,7 +69187,7 @@ async function installAstGrepForCodex(options) {
     return;
   const platform = options.platform ?? process.platform;
   const targetDir = astGrepRuntimeDir(options.codexHome, platform, options.arch ?? process.arch);
-  const skillDir = join46(plugin.path, "skills", "ast-grep");
+  const skillDir = join47(plugin.path, "skills", "ast-grep");
   const installer = options.installer ?? runAstGrepSkillInstall;
   try {
     const result = await installer({ platform, skillDir, targetDir });
@@ -69069,7 +69220,7 @@ async function runCodexInstaller(options = {}) {
   const env3 = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
   const repoRoot = resolve14(options.repoRoot ?? findRepoRoot({ importerDir: import.meta.dir, env: env3 }));
-  const codexHome = resolve14(options.codexHome ?? env3.CODEX_HOME ?? join49(homedir6(), ".codex"));
+  const codexHome = resolve14(options.codexHome ?? env3.CODEX_HOME ?? join50(homedir6(), ".codex"));
   const projectDirectory = resolve14(options.projectDirectory ?? env3.OMO_CODEX_PROJECT ?? process.cwd());
   const binDir = resolveCodexInstallerBinDir({ binDir: options.binDir, codexHome, env: env3 });
   const runCommand = options.runCommand ?? defaultRunCommand;
@@ -69087,9 +69238,9 @@ async function runCodexInstaller(options = {}) {
   if (!gitBashResolution.found) {
     throw new Error(gitBashResolution.installHint);
   }
-  const codexPackageRoot = join49(repoRoot, "packages", "omo-codex");
+  const codexPackageRoot = join50(repoRoot, "packages", "omo-codex");
   const marketplace = await readMarketplace(repoRoot, {
-    marketplacePath: join49(codexPackageRoot, "marketplace.json")
+    marketplacePath: join50(codexPackageRoot, "marketplace.json")
   });
   const distributionManifest = await readDistributionManifest(repoRoot);
   const installed = [];
@@ -69131,7 +69282,7 @@ async function runCodexInstaller(options = {}) {
       if (runtimeLink !== null)
         log4(`Linked ${runtimeLink.name} -> ${runtimeLink.target}`);
       else
-        log4(`Warning: skipped the omo runtime wrapper because ${join49(repoRoot, "dist", "cli", "index.js")} is missing; omo sparkshell/ulw-loop commands will be unavailable until a package shipping dist/cli is installed`);
+        log4(`Warning: skipped the omo runtime wrapper because ${join50(repoRoot, "dist", "cli", "index.js")} is missing; omo sparkshell/ulw-loop commands will be unavailable until a package shipping dist/cli is installed`);
     }
     pluginSources.push({ name: entry.name, sourcePath });
     installed.push(plugin);
@@ -69184,13 +69335,13 @@ async function runCodexInstaller(options = {}) {
     });
   }
   await reapLspDaemons(codexHome).catch(() => []);
-  const marketplaceRoot = join49(codexHome, "plugins", "cache", marketplace.name);
+  const marketplaceRoot = join50(codexHome, "plugins", "cache", marketplace.name);
   await writeCachedMarketplaceManifest({
     marketplaceName: marketplace.name,
     marketplaceRoot,
     plugins: installed
   });
-  const configPath = join49(codexHome, "config.toml");
+  const configPath = join50(codexHome, "config.toml");
   await updateCodexConfig({
     configPath,
     repoRoot: codexPackageRoot,
@@ -69249,7 +69400,7 @@ function findRepoRootFromImporter(importerDir) {
   for (let depth = 0;depth <= 7; depth += 1) {
     if (isRepoRootWithCodexPlugin(current))
       return current;
-    for (const wrapperPackageRoot of [join49(current, "node_modules", "oh-my-openagent"), join49(current, "oh-my-openagent")]) {
+    for (const wrapperPackageRoot of [join50(current, "node_modules", "oh-my-openagent"), join50(current, "oh-my-openagent")]) {
       if (isRepoRootWithCodexPlugin(wrapperPackageRoot))
         return wrapperPackageRoot;
     }
@@ -69267,7 +69418,7 @@ function findRepoRoot(input) {
   return findRepoRootFromImporter(input.importerDir);
 }
 function isRepoRootWithCodexPlugin(repoRoot) {
-  return existsSync29(join49(repoRoot, "packages", "omo-codex", "plugin", ".codex-plugin", "plugin.json"));
+  return existsSync29(join50(repoRoot, "packages", "omo-codex", "plugin", ".codex-plugin", "plugin.json"));
 }
 function codexMarketplaceSource(marketplaceRoot) {
   return { sourceType: "local", source: marketplaceRoot };
@@ -69402,12 +69553,12 @@ function defaultRunCommand2(command, args) {
   });
 }
 // packages/omo-codex/src/install/codex-cleanup.ts
-import { lstat as lstat10, readFile as readFile18, readdir as readdir7, rm as rm9, rmdir } from "node:fs/promises";
+import { lstat as lstat10, readFile as readFile19, readdir as readdir7, rm as rm9, rmdir } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { isAbsolute as isAbsolute8, join as join50, relative as relative6, resolve as resolve15 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join51, relative as relative6, resolve as resolve15 } from "node:path";
 
 // packages/omo-codex/src/install/codex-cleanup-config.ts
-import { lstat as lstat9, mkdir as mkdir8, readFile as readFile17, writeFile as writeFile10 } from "node:fs/promises";
+import { lstat as lstat9, mkdir as mkdir8, readFile as readFile18, writeFile as writeFile10 } from "node:fs/promises";
 import { dirname as dirname16 } from "node:path";
 var MANAGED_MARKETPLACES = ["sisyphuslabs", "lazycodex", "code-yeongyu-codex-plugins"];
 var LEGACY_MANAGED_CODEX_AGENT_NAMES_TO_PURGE2 = ["codex-ultrawork-reviewer"];
@@ -69437,7 +69588,7 @@ function cleanupCodexLightConfigText(config) {
 async function cleanupCodexConfig(configPath, now) {
   if (!await configExists(configPath))
     return { changed: false };
-  const original = await readFile17(configPath, "utf8");
+  const original = await readFile18(configPath, "utf8");
   const next = cleanupCodexLightConfigText(original);
   if (next === original)
     return { changed: false };
@@ -69569,8 +69720,8 @@ function nodeErrorCode4(error) {
 var INSTALLED_AGENTS_MANIFEST = ".installed-agents.json";
 async function cleanupCodexLight(input = {}) {
   const env3 = input.env ?? process.env;
-  const codexHome = resolve15(input.codexHome ?? env3.CODEX_HOME ?? join50(homedir8(), ".codex"));
-  const configPath = join50(codexHome, "config.toml");
+  const codexHome = resolve15(input.codexHome ?? env3.CODEX_HOME ?? join51(homedir8(), ".codex"));
+  const configPath = join51(codexHome, "config.toml");
   const agentPaths = await collectInstalledAgentPaths(codexHome, configPath);
   const configCleanup = await cleanupCodexConfig(configPath, input.now);
   const agentCleanup = await removeManifestListedAgentLinks(codexHome, agentPaths);
@@ -69606,17 +69757,17 @@ async function cleanupCodexLight(input = {}) {
 }
 function managedGlobalStatePaths(codexHome) {
   return [
-    join50(codexHome, "plugins", "cache", "sisyphuslabs"),
-    join50(codexHome, ".tmp", "marketplaces", "sisyphuslabs"),
-    join50(codexHome, "runtime", "ast-grep"),
-    join50(codexHome, "runtime", "node"),
-    join50(codexHome, "plugins", "data", "omo-sisyphuslabs", "bootstrap")
+    join51(codexHome, "plugins", "cache", "sisyphuslabs"),
+    join51(codexHome, ".tmp", "marketplaces", "sisyphuslabs"),
+    join51(codexHome, "runtime", "ast-grep"),
+    join51(codexHome, "runtime", "node"),
+    join51(codexHome, "plugins", "data", "omo-sisyphuslabs", "bootstrap")
   ];
 }
 var BOOTSTRAP_DATA_GLOB_MAX_DEPTH = 5;
 async function collectBootstrapDataDirsByGlob(codexHome) {
   const results = [];
-  await walkForManagedBootstrapDirs(join50(codexHome, "plugins"), 0, results);
+  await walkForManagedBootstrapDirs(join51(codexHome, "plugins"), 0, results);
   return results;
 }
 async function walkForManagedBootstrapDirs(directory, depth, results) {
@@ -69628,9 +69779,9 @@ async function walkForManagedBootstrapDirs(directory, depth, results) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const childPath = join50(directory, entry.name);
+    const childPath = join51(directory, entry.name);
     if (isManagedBootstrapOwnerName(entry.name)) {
-      const bootstrapDir = join50(childPath, "bootstrap");
+      const bootstrapDir = join51(childPath, "bootstrap");
       if (await exists6(bootstrapDir))
         results.push(bootstrapDir);
       continue;
@@ -69659,19 +69810,19 @@ async function attemptRemove(path7) {
 }
 async function pruneEmptyRuntimeDirBestEffort(codexHome) {
   try {
-    await rmdir(join50(codexHome, "runtime"));
+    await rmdir(join51(codexHome, "runtime"));
   } catch {}
 }
 async function collectInstalledAgentPaths(codexHome, configPath) {
   const manifestPaths = [
-    join50(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo", INSTALLED_AGENTS_MANIFEST)
+    join51(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo", INSTALLED_AGENTS_MANIFEST)
   ];
-  const versionRoot = join50(codexHome, "plugins", "cache", "sisyphuslabs", "omo");
+  const versionRoot = join51(codexHome, "plugins", "cache", "sisyphuslabs", "omo");
   if (await exists6(versionRoot)) {
     const entries = await readdir7(versionRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory())
-        manifestPaths.push(join50(versionRoot, entry.name, INSTALLED_AGENTS_MANIFEST));
+        manifestPaths.push(join51(versionRoot, entry.name, INSTALLED_AGENTS_MANIFEST));
     }
   }
   const paths = new Set;
@@ -69688,19 +69839,19 @@ async function collectInstalledAgentPaths(codexHome, configPath) {
 async function readManagedAgentPathsFromConfig(codexHome, configPath) {
   if (!await exists6(configPath))
     return [];
-  const config = await readFile18(configPath, "utf8");
-  return MANAGED_CODEX_AGENT_NAMES2.filter((agentName) => config.includes(`config_file = ${JSON.stringify(`./agents/${agentName}.toml`)}`)).map((agentName) => join50(codexHome, "agents", `${agentName}.toml`));
+  const config = await readFile19(configPath, "utf8");
+  return MANAGED_CODEX_AGENT_NAMES2.filter((agentName) => config.includes(`config_file = ${JSON.stringify(`./agents/${agentName}.toml`)}`)).map((agentName) => join51(codexHome, "agents", `${agentName}.toml`));
 }
 async function readInstalledAgentManifest(manifestPath) {
   if (!await exists6(manifestPath))
     return [];
-  const parsed = JSON.parse(await readFile18(manifestPath, "utf8"));
+  const parsed = JSON.parse(await readFile19(manifestPath, "utf8"));
   if (!isPlainRecord3(parsed) || !Array.isArray(parsed.agents))
     return [];
   return parsed.agents.filter((path7) => typeof path7 === "string");
 }
 async function removeManifestListedAgentLinks(codexHome, paths) {
-  const agentsDir = join50(codexHome, "agents");
+  const agentsDir = join51(codexHome, "agents");
   const removed = [];
   const skipped = [];
   for (const path7 of paths) {
@@ -69784,19 +69935,19 @@ init_provider_availability();
 
 // packages/omo-opencode/src/cli/config-manager/add-tui-plugin-to-tui-config.ts
 import { existsSync as existsSync32, mkdirSync as mkdirSync10, readFileSync as readFileSync16 } from "node:fs";
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 
 // packages/omo-opencode/src/cli/doctor/checks/tui-plugin-config.ts
 init_shared();
 import { existsSync as existsSync31, readFileSync as readFileSync15 } from "node:fs";
-import { join as join51 } from "node:path";
+import { join as join52 } from "node:path";
 var TUI_SUBPATH = "tui";
 var TUI_EXPORT_SUBPATH = `./${TUI_SUBPATH}`;
 function fileEntryPackageJsonPath(entry) {
   let path7 = entry.slice("file:".length);
   if (path7.startsWith("//"))
     path7 = path7.slice(2);
-  return join51(path7, "package.json");
+  return join52(path7, "package.json");
 }
 function packageJsonExportsTui(pkgJsonPath) {
   if (!existsSync31(pkgJsonPath))
@@ -69834,7 +69985,7 @@ function packageExportsTuiForServerEntry(entry) {
   const packageName = packageNameFromServerEntry(entry);
   if (packageName === null)
     return null;
-  return packageJsonExportsTui(join51(getOpenCodeConfigDir({ binary: "opencode" }), "node_modules", packageName, "package.json"));
+  return packageJsonExportsTui(join52(getOpenCodeConfigDir({ binary: "opencode" }), "node_modules", packageName, "package.json"));
 }
 function isOurFilePluginEntry(entry) {
   if (!entry.startsWith("file:"))
@@ -69907,7 +70058,7 @@ function detectServerPluginRegistration() {
   }
 }
 function detectTuiPluginRegistration() {
-  const tuiJsonPath = join51(getOpenCodeConfigDir({ binary: "opencode" }), "tui.json");
+  const tuiJsonPath = join52(getOpenCodeConfigDir({ binary: "opencode" }), "tui.json");
   if (!existsSync31(tuiJsonPath)) {
     return {
       registered: false,
@@ -70063,10 +70214,10 @@ function readConfig(path7) {
   return null;
 }
 function readServerConfig(configDir) {
-  const jsoncPath = join52(configDir, "opencode.jsonc");
+  const jsoncPath = join53(configDir, "opencode.jsonc");
   if (existsSync32(jsoncPath))
     return readConfig(jsoncPath);
-  const jsonPath = join52(configDir, "opencode.json");
+  const jsonPath = join53(configDir, "opencode.json");
   if (existsSync32(jsonPath))
     return readConfig(jsonPath);
   return null;
@@ -70108,7 +70259,7 @@ function ensureTuiPluginEntry(opts = {}) {
   if (!desiredEntry) {
     return { changed: false, reason: "no-server-entry" };
   }
-  const tuiJsonPath = join52(configDir, "tui.json");
+  const tuiJsonPath = join53(configDir, "tui.json");
   const { config, malformed } = readTuiConfig(tuiJsonPath);
   if (malformed) {
     return { changed: false, reason: "malformed" };
@@ -70124,7 +70275,7 @@ function ensureTuiPluginEntry(opts = {}) {
 
 // packages/omo-opencode/src/cli/install-ast-grep-sg.ts
 import { homedir as homedir9 } from "node:os";
-import { join as join53 } from "node:path";
+import { join as join54 } from "node:path";
 
 // packages/shared-skills/index.mjs
 import { fileURLToPath } from "node:url";
@@ -70143,9 +70294,9 @@ function describeResult2(result) {
 }
 async function installAstGrepForOpenCode(options = {}) {
   const platform = options.platform ?? process.platform;
-  const baseDir = join53(options.homeDir ?? homedir9(), ".omo");
+  const baseDir = join54(options.homeDir ?? homedir9(), ".omo");
   const targetDir = astGrepRuntimeDir(baseDir, platform, options.arch ?? process.arch);
-  const skillDir = join53(options.sharedSkillsRoot ?? sharedSkillsRootPath(), "ast-grep");
+  const skillDir = join54(options.sharedSkillsRoot ?? sharedSkillsRootPath(), "ast-grep");
   const installer = options.installer ?? runAstGrepSkillInstall;
   try {
     const result = await installer({ platform, skillDir, targetDir });
@@ -88591,9 +88742,9 @@ function readCurrentTopLevelTask(planPath) {
 }
 // packages/boulder-state/src/storage/path.ts
 import { existsSync as existsSync36 } from "node:fs";
-import { isAbsolute as isAbsolute9, join as join55, relative as relative7, resolve as resolve16 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join56, relative as relative7, resolve as resolve16 } from "node:path";
 function getBoulderFilePath(directory) {
-  return join55(directory, BOULDER_DIR, BOULDER_FILE);
+  return join56(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function resolveTrackedPath(baseDirectory, trackedPath) {
   return isAbsolute9(trackedPath) ? resolve16(trackedPath) : resolve16(baseDirectory, trackedPath);
@@ -88822,9 +88973,9 @@ init_state();
 var CONTINUATION_MARKER_DIR = ".omo/run-continuation";
 // packages/omo-opencode/src/features/run-continuation-state/storage.ts
 import { existsSync as existsSync39, mkdirSync as mkdirSync11, readFileSync as readFileSync21, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join56 } from "node:path";
+import { join as join57 } from "node:path";
 function getMarkerPath(directory, sessionID) {
-  return join56(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join57(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
@@ -88897,7 +89048,7 @@ async function isSessionInBoulderLineage(input) {
 init_shared();
 init_compaction_marker();
 import { readFileSync as readFileSync22, readdirSync as readdirSync6 } from "node:fs";
-import { join as join57 } from "node:path";
+import { join as join58 } from "node:path";
 var defaultSessionLastAgentDeps = {
   getMessageDir,
   isSqliteBackend,
@@ -88957,7 +89108,7 @@ async function getLastAgentFromSession(sessionID, client3, deps = {}) {
   try {
     const messages = readdirSync6(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync22(join57(messageDir, fileName), "utf-8");
+        const content = readFileSync22(join58(messageDir, fileName), "utf-8");
         const parsed = JSON.parse(content);
         return {
           fileName,
@@ -89001,7 +89152,7 @@ init_agent_display_names();
 // packages/omo-opencode/src/hooks/ralph-loop/storage.ts
 init_frontmatter2();
 import { existsSync as existsSync40, readFileSync as readFileSync23, writeFileSync as writeFileSync7, unlinkSync as unlinkSync5, mkdirSync as mkdirSync12 } from "node:fs";
-import { dirname as dirname19, join as join58 } from "node:path";
+import { dirname as dirname19, join as join59 } from "node:path";
 
 // packages/omo-opencode/src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".omo/ralph-loop.local.md";
@@ -89010,7 +89161,7 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // packages/omo-opencode/src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join58(directory, customPath) : join58(directory, DEFAULT_STATE_FILE);
+  return customPath ? join59(directory, customPath) : join59(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
@@ -90123,7 +90274,7 @@ init_extract_semver();
 init_bun_which_shim();
 import { existsSync as existsSync48, accessSync as accessSync4, constants as constants9 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 
 // packages/omo-opencode/src/cli/doctor/framework/spawn-with-timeout.ts
 init_spawn_with_windows_hide();
@@ -90215,17 +90366,17 @@ function getDesktopAppPaths(platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join65(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join66(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
       ];
     case "win32": {
       const programFiles = process.env.ProgramFiles;
       const localAppData = process.env.LOCALAPPDATA;
       const paths = [];
       if (programFiles) {
-        paths.push(join65(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join66(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join65(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join66(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -90233,8 +90384,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join65(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join65(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join66(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join66(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -90266,7 +90417,7 @@ async function findOpenCodeBinary(platform = process.platform, checkExists = exi
   const candidates = getCommandCandidates2(platform);
   for (const entry of pathEnv.split(delimiter3).filter(Boolean)) {
     for (const command of candidates) {
-      const fullPath = join65(entry, command);
+      const fullPath = join66(entry, command);
       if (checkExists(fullPath) && isExecutable2(fullPath)) {
         return { binary: command, path: fullPath };
       }
@@ -90408,22 +90559,22 @@ init_package_json_locator();
 import { existsSync as existsSync50, readFileSync as readFileSync32, readdirSync as readdirSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir14 } from "node:os";
-import { join as join66 } from "node:path";
+import { join as join67 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join66(homedir14(), "Library", "Caches");
+    return join67(homedir14(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join66(homedir14(), "AppData", "Local");
-  return join66(homedir14(), ".cache");
+    return process.env.LOCALAPPDATA ?? join67(homedir14(), "AppData", "Local");
+  return join67(homedir14(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join66(xdgCacheHome, "opencode");
+    return join67(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join66(getPlatformDefaultCacheDir(), "opencode");
+  const platformDefault = join67(getPlatformDefaultCacheDir(), "opencode");
   if (existsSync50(fromShared) || !existsSync50(platformDefault))
     return fromShared;
   return platformDefault;
@@ -90455,11 +90606,11 @@ function normalizeVersion(value) {
 function createPackageCandidates(rootDir) {
   return ACCEPTED_PACKAGE_NAMES.map((packageName) => ({
     packageName,
-    installedPackagePath: join66(rootDir, "node_modules", packageName, "package.json")
+    installedPackagePath: join67(rootDir, "node_modules", packageName, "package.json")
   }));
 }
 function createTaggedInstallCandidates(rootDir) {
-  const packagesDir = join66(rootDir, "packages");
+  const packagesDir = join67(rootDir, "packages");
   if (!existsSync50(packagesDir))
     return [];
   const candidates = [];
@@ -90467,14 +90618,14 @@ function createTaggedInstallCandidates(rootDir) {
     const packageName = ACCEPTED_PACKAGE_NAMES.find((name) => entryName.startsWith(`${name}@`));
     if (packageName === undefined)
       continue;
-    const installDir = join66(packagesDir, entryName);
+    const installDir = join67(packagesDir, entryName);
     candidates.push({
       cacheDir: installDir,
-      cachePackagePath: join66(installDir, "package.json"),
+      cachePackagePath: join67(installDir, "package.json"),
       packageCandidates: [
         {
           packageName,
-          installedPackagePath: join66(installDir, "node_modules", packageName, "package.json")
+          installedPackagePath: join67(installDir, "node_modules", packageName, "package.json")
         }
       ]
     });
@@ -90519,13 +90670,13 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join66(configDir, "package.json"),
+      cachePackagePath: join67(configDir, "package.json"),
       packageCandidates: createPackageCandidates(configDir)
     },
     ...createTaggedInstallCandidates(configDir),
     {
       cacheDir,
-      cachePackagePath: join66(cacheDir, "package.json"),
+      cachePackagePath: join67(cacheDir, "package.json"),
       packageCandidates: createPackageCandidates(cacheDir)
     },
     ...createTaggedInstallCandidates(cacheDir)
@@ -90828,18 +90979,18 @@ function validatePluginConfig(directory) {
 init_shared();
 import { existsSync as existsSync52, readFileSync as readFileSync35 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
-import { join as join67 } from "node:path";
+import { join as join68 } from "node:path";
 function getUserConfigDir2() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig)
-    return join67(xdgConfig, "opencode");
-  return join67(homedir16(), ".config", "opencode");
+    return join68(xdgConfig, "opencode");
+  return join68(homedir16(), ".config", "opencode");
 }
 function loadCustomProviderNames() {
   const configDir = getUserConfigDir2();
   const candidatePaths = [
-    join67(configDir, "opencode.json"),
-    join67(configDir, "opencode.jsonc")
+    join68(configDir, "opencode.json"),
+    join68(configDir, "opencode.jsonc")
   ];
   for (const configPath of candidatePaths) {
     if (!existsSync52(configPath))
@@ -90860,7 +91011,7 @@ function loadCustomProviderNames() {
   return [];
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join67(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join68(getOpenCodeCacheDir(), "models.json");
   const customProviders = loadCustomProviderNames();
   if (!existsSync52(cacheFile)) {
     if (customProviders.length > 0) {
@@ -90897,8 +91048,8 @@ init_model_capabilities2();
 init_shared();
 init_plugin_identity();
 import { readFileSync as readFileSync36 } from "node:fs";
-import { join as join68 } from "node:path";
-var PROJECT_CONFIG_DIR = join68(process.cwd(), ".opencode");
+import { join as join69 } from "node:path";
+var PROJECT_CONFIG_DIR = join69(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR, {
     basenames: [CONFIG_BASENAME],
@@ -90936,7 +91087,7 @@ function loadOmoConfig() {
 
 // packages/omo-opencode/src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 
 // packages/omo-opencode/src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -90978,7 +91129,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join69(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join70(getOpenCodeCacheDir(), "models.json");
   details.push("═══ Available Models (from cache) ═══");
   details.push("");
   if (options.available.cacheExists) {
@@ -91257,25 +91408,25 @@ init_src();
 import { existsSync as existsSync53 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname25, join as join71 } from "node:path";
+import { dirname as dirname25, join as join72 } from "node:path";
 
 // packages/omo-opencode/src/hooks/comment-checker/downloader.ts
-import { join as join70 } from "path";
+import { join as join71 } from "path";
 import { homedir as homedir17, tmpdir as tmpdir3 } from "os";
 init_binary_downloader();
 init_logger2();
 init_plugin_identity();
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE = join70(tmpdir3(), "comment-checker-debug.log");
+var DEBUG_FILE = join71(tmpdir3(), "comment-checker-debug.log");
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join70(homedir17(), "AppData", "Local");
-    return join70(base2, CACHE_DIR_NAME, "bin");
+    const base2 = localAppData || join71(homedir17(), "AppData", "Local");
+    return join71(base2, CACHE_DIR_NAME, "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join70(homedir17(), ".cache");
-  return join70(base, CACHE_DIR_NAME, "bin");
+  const base = xdgCache || join71(homedir17(), ".cache");
+  return join71(base, CACHE_DIR_NAME, "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
@@ -91325,7 +91476,7 @@ async function getBinaryVersion(binary) {
   }
 }
 async function checkAstGrepCli() {
-  const runtimeDir = astGrepRuntimeDir(join71(homedir18(), ".omo"));
+  const runtimeDir = astGrepRuntimeDir(join72(homedir18(), ".omo"));
   const sgPath = findSgBinarySync({ runtimeDir });
   if (sgPath === null) {
     return {
@@ -91355,10 +91506,10 @@ function findCommentCheckerPackageBinary(baseDirOverride, resolvePackageJsonPath
   const platformKey = `${process.platform}-${process.arch === "x64" ? "x64" : process.arch}`;
   try {
     const packageDir = baseDirOverride ?? dirname25(resolvePackageJsonPath());
-    const vendorPath = join71(packageDir, "vendor", platformKey, binaryName);
+    const vendorPath = join72(packageDir, "vendor", platformKey, binaryName);
     if (existsSync53(vendorPath))
       return vendorPath;
-    const binPath = join71(packageDir, "bin", binaryName);
+    const binPath = join72(packageDir, "bin", binaryName);
     if (existsSync53(binPath))
       return binPath;
   } catch (error51) {
@@ -91504,7 +91655,7 @@ async function getGhCliInfo(dependencies = {}) {
 
 // packages/omo-opencode/src/cli/doctor/checks/tools-lsp.ts
 import { readFileSync as readFileSync37 } from "node:fs";
-import { join as join72 } from "node:path";
+import { join as join73 } from "node:path";
 
 // packages/omo-opencode/src/mcp/lsp.ts
 import { existsSync as existsSync54 } from "node:fs";
@@ -91711,7 +91862,7 @@ function readOmoConfig(configDirectory) {
 }
 function isLspMcpDisabled(options) {
   const userConfigDirectory = options.configDirectory ?? getOpenCodeConfigDir({ binary: "opencode" });
-  const projectConfigDirectory = join72(options.cwd ?? process.cwd(), ".opencode");
+  const projectConfigDirectory = join73(options.cwd ?? process.cwd(), ".opencode");
   const userConfig = readOmoConfig(userConfigDirectory);
   const projectConfig = readOmoConfig(projectConfigDirectory);
   const disabledMcps = new Set([
@@ -91732,13 +91883,13 @@ function getInstalledLspServers(options = {}) {
 init_shared();
 import { existsSync as existsSync55, readFileSync as readFileSync38 } from "node:fs";
 import { homedir as homedir19 } from "node:os";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 var BUILTIN_MCP_SERVERS = ["websearch", "context7", "grep_app", "lsp"];
 function getMcpConfigPaths() {
   return [
-    join73(homedir19(), ".claude", ".mcp.json"),
-    join73(process.cwd(), ".mcp.json"),
-    join73(process.cwd(), ".claude", ".mcp.json")
+    join74(homedir19(), ".claude", ".mcp.json"),
+    join74(process.cwd(), ".mcp.json"),
+    join74(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
@@ -91983,9 +92134,9 @@ async function pathExists(dir) {
 // packages/omo-opencode/src/cli/doctor/checks/codex.ts
 init_src();
 import { existsSync as existsSync56 } from "node:fs";
-import { lstat as lstat11, readdir as readdir8, readFile as readFile19 } from "node:fs/promises";
+import { lstat as lstat11, readdir as readdir8, readFile as readFile20 } from "node:fs/promises";
 import { homedir as homedir21 } from "node:os";
-import { basename as basename12, join as join74, resolve as resolve19 } from "node:path";
+import { basename as basename12, join as join75, resolve as resolve19 } from "node:path";
 // packages/omo-opencode/package.json
 var package_default3 = {
   name: "@oh-my-opencode/omo-opencode",
@@ -92041,13 +92192,13 @@ var CODEX_BIN_NAMES = [
   "omo-git-bash-hook"
 ];
 async function gatherCodexSummary(deps = {}) {
-  const codexHome = resolve19(deps.codexHome ?? process.env.CODEX_HOME ?? join74(homedir21(), ".codex"));
+  const codexHome = resolve19(deps.codexHome ?? process.env.CODEX_HOME ?? join75(homedir21(), ".codex"));
   const binDir = resolveCodexInstallerBinDir({ binDir: deps.binDir, codexHome, env: process.env });
   const detection = await (deps.detectCodexInstallation ?? detectCodexInstallation)();
   const pluginRoot = await resolveInstalledPluginRoot(codexHome);
-  const manifest = pluginRoot === null ? null : await readJson(join74(pluginRoot, ".codex-plugin", "plugin.json"));
-  const installSnapshot = pluginRoot === null ? null : await readJson(join74(pluginRoot, "lazycodex-install.json"));
-  const configPath = join74(codexHome, "config.toml");
+  const manifest = pluginRoot === null ? null : await readJson(join75(pluginRoot, ".codex-plugin", "plugin.json"));
+  const installSnapshot = pluginRoot === null ? null : await readJson(join75(pluginRoot, "lazycodex-install.json"));
+  const configPath = join75(codexHome, "config.toml");
   const pluginVersion = stringField(manifest, "version");
   return {
     codexPath: detection.found && "path" in detection ? detection.path : null,
@@ -92103,7 +92254,7 @@ function buildCodexIssues(summary) {
   if (summary.pluginRoot === null) {
     issues.push({
       title: "OMO Codex plugin is not installed",
-      description: `Expected cached plugin at ${join74("plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME2, DEFAULT_PLUGIN_VERSION)} under CODEX_HOME.`,
+      description: `Expected cached plugin at ${join75("plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME2, DEFAULT_PLUGIN_VERSION)} under CODEX_HOME.`,
       fix: "Run: npx lazycodex-ai install",
       severity: "error",
       affects: ["plugin loading"]
@@ -92156,18 +92307,18 @@ function buildCodexIssues(summary) {
   return issues;
 }
 async function resolveInstalledPluginRoot(codexHome) {
-  const pluginRoot = join74(codexHome, "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME2);
+  const pluginRoot = join75(codexHome, "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME2);
   if (!existsSync56(pluginRoot))
     return null;
   const versions2 = await readdir8(pluginRoot, { withFileTypes: true });
   const candidates = versions2.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareVersionsDescending);
-  return candidates.length === 0 ? null : join74(pluginRoot, candidates[0] ?? DEFAULT_PLUGIN_VERSION);
+  return candidates.length === 0 ? null : join75(pluginRoot, candidates[0] ?? DEFAULT_PLUGIN_VERSION);
 }
 async function readCodexConfigSummary(configPath) {
   if (!existsSync56(configPath)) {
     return { exists: false, marketplaceConfigured: false, pluginEnabled: false, pluginsFeatureEnabled: false, pluginHooksFeatureEnabled: false };
   }
-  const content = await readFile19(configPath, "utf8");
+  const content = await readFile20(configPath, "utf8");
   return {
     exists: true,
     marketplaceConfigured: content.includes("[marketplaces.sisyphuslabs]"),
@@ -92179,13 +92330,13 @@ async function readCodexConfigSummary(configPath) {
 async function readLinkedBins(binDir) {
   const linked = [];
   for (const name of CODEX_BIN_NAMES) {
-    if (await pathExists2(join74(binDir, process.platform === "win32" ? `${name}.cmd` : name)))
+    if (await pathExists2(join75(binDir, process.platform === "win32" ? `${name}.cmd` : name)))
       linked.push(name);
   }
   return linked;
 }
 async function readLinkedAgents(codexHome) {
-  const agentsDir = join74(codexHome, "agents");
+  const agentsDir = join75(codexHome, "agents");
   if (!existsSync56(agentsDir))
     return [];
   const entries = await readdir8(agentsDir, { withFileTypes: true });
@@ -92193,7 +92344,7 @@ async function readLinkedAgents(codexHome) {
 }
 async function readJson(path16) {
   try {
-    const parsed = JSON.parse(await readFile19(path16, "utf8"));
+    const parsed = JSON.parse(await readFile20(path16, "utf8"));
     return isPlainRecord(parsed) ? parsed : null;
   } catch (error51) {
     if (error51 instanceof Error)
@@ -92243,9 +92394,9 @@ async function pathExists2(path16) {
 
 // packages/omo-opencode/src/cli/doctor/checks/codex-components.ts
 init_src();
-import { readdir as readdir9, readFile as readFile20, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir9, readFile as readFile21, stat as stat4 } from "node:fs/promises";
 import { homedir as homedir22 } from "node:os";
-import { dirname as dirname27, join as join75, relative as relative9, resolve as resolve20, sep as sep8 } from "node:path";
+import { dirname as dirname27, join as join76, relative as relative9, resolve as resolve20, sep as sep9 } from "node:path";
 var CODEX_COMPONENTS_CHECK_ID = "codex-components";
 var CODEX_COMPONENTS_CHECK_NAME = "codex-components";
 var PLUGIN_DATA_DIR_NAME = "omo-sisyphuslabs";
@@ -92255,7 +92406,7 @@ async function checkCodexComponents(deps = {}) {
   const env3 = deps.env ?? process.env;
   const platform = deps.platform ?? process.platform;
   const arch = deps.arch ?? process.arch;
-  const codexHome = resolve20(deps.codexHome ?? env3["CODEX_HOME"] ?? join75(homedir22(), ".codex"));
+  const codexHome = resolve20(deps.codexHome ?? env3["CODEX_HOME"] ?? join76(homedir22(), ".codex"));
   const summary = await gatherCodexSummary({ ...deps, codexHome });
   if (summary.pluginRoot === null) {
     return {
@@ -92280,7 +92431,7 @@ async function checkCodexComponents(deps = {}) {
     });
   }
   const runtimeSgDir = runtimeSgDirectory(codexHome, platform, arch);
-  const runtimeSgPath = join75(runtimeSgDir, sgBinaryName(platform));
+  const runtimeSgPath = join76(runtimeSgDir, sgBinaryName(platform));
   const sg = findSgBinarySync({
     arch,
     env: env3,
@@ -92364,7 +92515,7 @@ function recordBrokenTarget(broken, classified, origin) {
 async function classifyBundleTarget(bundleRoot, baseRoot, relativePath, allowEscape) {
   const targetPath = resolve20(baseRoot, relativePath);
   const bundleRootPath = resolve20(bundleRoot);
-  const bundleRootPrefix = bundleRootPath.endsWith(sep8) ? bundleRootPath : `${bundleRootPath}${sep8}`;
+  const bundleRootPrefix = bundleRootPath.endsWith(sep9) ? bundleRootPath : `${bundleRootPath}${sep9}`;
   if (targetPath !== bundleRootPath && !targetPath.startsWith(bundleRootPrefix)) {
     if (allowEscape)
       return null;
@@ -92379,7 +92530,7 @@ async function classifyBundleTarget(bundleRoot, baseRoot, relativePath, allowEsc
 }
 async function findHookManifestPaths(root) {
   const paths2 = await findManifestPaths(root, "hooks.json");
-  return paths2.filter((path16) => dirname27(path16).endsWith(`${sep8}hooks`));
+  return paths2.filter((path16) => dirname27(path16).endsWith(`${sep9}hooks`));
 }
 async function findManifestPaths(root, manifestName) {
   let entries;
@@ -92392,7 +92543,7 @@ async function findManifestPaths(root, manifestName) {
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === ".git")
       continue;
-    const entryPath = join75(root, entry.name);
+    const entryPath = join76(root, entry.name);
     if (entry.isDirectory()) {
       paths2.push(...await findManifestPaths(entryPath, manifestName));
       continue;
@@ -92435,18 +92586,18 @@ function isPluginRuntimePathArg(arg) {
   return (arg.startsWith("./") || arg.startsWith("../")) && arg.endsWith("/dist/cli.js");
 }
 function runtimeSgDirectory(codexHome, platform, arch) {
-  return join75(codexHome, "runtime", "ast-grep", runtimeSlug(platform, arch));
+  return join76(codexHome, "runtime", "ast-grep", runtimeSlug(platform, arch));
 }
 function describeSgSource(sgPath, env3, runtimeSgDir, platform) {
   const override = env3[SG_PATH_ENV_KEY]?.trim();
   if (override !== undefined && override.length > 0 && sgPath === override)
     return `env override ${SG_PATH_ENV_KEY}`;
-  if (sgPath === join75(runtimeSgDir, sgBinaryName(platform)))
+  if (sgPath === join76(runtimeSgDir, sgBinaryName(platform)))
     return "runtime dir";
   return "PATH";
 }
 async function readBootstrapStateSummary(codexHome) {
-  const statePath = join75(codexHome, "plugins", "data", PLUGIN_DATA_DIR_NAME, "bootstrap", "state.json");
+  const statePath = join76(codexHome, "plugins", "data", PLUGIN_DATA_DIR_NAME, "bootstrap", "state.json");
   const raw = await readJson2(statePath);
   if (raw === null)
     return null;
@@ -92495,7 +92646,7 @@ function degradedDetailLines(entries) {
 }
 async function readJson2(path16) {
   try {
-    const parsed = JSON.parse(await readFile20(path16, "utf8"));
+    const parsed = JSON.parse(await readFile21(path16, "utf8"));
     return isRecord5(parsed) ? parsed : null;
   } catch (error51) {
     if (error51 instanceof Error)
@@ -92523,17 +92674,17 @@ function isRecord5(value) {
 
 // packages/omo-opencode/src/cli/doctor/checks/codex-runtime-wrapper.ts
 import { existsSync as existsSync57 } from "node:fs";
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 import { homedir as homedir23 } from "node:os";
-import { join as join76, resolve as resolve21 } from "node:path";
+import { join as join77, resolve as resolve21 } from "node:path";
 var RUNTIME_WRAPPER_MARKER2 = "OMO_GENERATED_RUNTIME_WRAPPER";
 var CHECK_NAME = "codex-runtime-wrapper";
 var REINSTALL_COMMAND = "npx --yes lazycodex-ai@latest install --no-tui";
 async function checkCodexRuntimeWrapper(deps = {}) {
-  const codexHome = resolve21(deps.codexHome ?? process.env.CODEX_HOME ?? join76(homedir23(), ".codex"));
+  const codexHome = resolve21(deps.codexHome ?? process.env.CODEX_HOME ?? join77(homedir23(), ".codex"));
   const binDir = resolveCodexInstallerBinDir({ binDir: deps.binDir, codexHome, env: process.env });
   const platform = deps.platform ?? process.platform;
-  const wrapperPath = join76(binDir, platform === "win32" ? "omo.cmd" : "omo");
+  const wrapperPath = join77(binDir, platform === "win32" ? "omo.cmd" : "omo");
   const wrapper = await readRuntimeWrapper(wrapperPath);
   const issues = [];
   if (wrapper?.includes(RUNTIME_WRAPPER_MARKER2) === true) {
@@ -92558,7 +92709,7 @@ async function checkCodexRuntimeWrapper(deps = {}) {
 }
 async function readRuntimeWrapper(path16) {
   try {
-    return await readFile21(path16, "utf8");
+    return await readFile22(path16, "utf8");
   } catch (error51) {
     if (error51 instanceof Error)
       return null;
@@ -93038,12 +93189,12 @@ import {
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { basename as basename13, dirname as dirname28, join as join79 } from "node:path";
+import { basename as basename13, dirname as dirname28, join as join80 } from "node:path";
 
 // packages/mcp-client-core/src/config-dir.ts
 import { existsSync as existsSync58, realpathSync as realpathSync8 } from "node:fs";
 import { homedir as homedir24 } from "node:os";
-import { join as join77, resolve as resolve22 } from "node:path";
+import { join as join78, resolve as resolve22 } from "node:path";
 function resolveConfigPath2(pathValue) {
   const resolvedPath = resolve22(pathValue);
   if (!existsSync58(resolvedPath))
@@ -93061,13 +93212,13 @@ function getOpenCodeCliConfigDir(env3 = process.env) {
   if (customConfigDir) {
     return resolveConfigPath2(customConfigDir);
   }
-  const xdgConfigDir = env3["XDG_CONFIG_HOME"]?.trim() || join77(homedir24(), ".config");
-  return resolveConfigPath2(join77(xdgConfigDir, "opencode"));
+  const xdgConfigDir = env3["XDG_CONFIG_HOME"]?.trim() || join78(homedir24(), ".config");
+  return resolveConfigPath2(join78(xdgConfigDir, "opencode"));
 }
 
 // packages/mcp-client-core/src/mcp-oauth/storage-index.ts
 import { chmodSync as chmodSync3, existsSync as existsSync59, readFileSync as readFileSync40, renameSync as renameSync6, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join78 } from "node:path";
+import { join as join79 } from "node:path";
 var INDEX_FILE_NAME = "index.json";
 function isTokenIndex(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -93075,7 +93226,7 @@ function isTokenIndex(value) {
   return Object.values(value).every((entry) => typeof entry === "string");
 }
 function getIndexPath(storageDir) {
-  return join78(storageDir, INDEX_FILE_NAME);
+  return join79(storageDir, INDEX_FILE_NAME);
 }
 function readTokenIndex(storageDir) {
   const indexPath = getIndexPath(storageDir);
@@ -93119,16 +93270,16 @@ function deleteTokenIndexEntry(storageDir, hash2) {
 var STORAGE_DIR_NAME = "mcp-oauth";
 var LEGACY_STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStorageDir() {
-  return join79(getOpenCodeCliConfigDir(), STORAGE_DIR_NAME);
+  return join80(getOpenCodeCliConfigDir(), STORAGE_DIR_NAME);
 }
 function getMcpOauthServerHash(serverHost, resource) {
   return createHash4("sha256").update(buildKey(serverHost, resource)).digest("hex").slice(0, 32);
 }
 function getMcpOauthStoragePath(serverHost, resource) {
-  return join79(getMcpOauthStorageDir(), `${getMcpOauthServerHash(serverHost, resource)}.json`);
+  return join80(getMcpOauthStorageDir(), `${getMcpOauthServerHash(serverHost, resource)}.json`);
 }
 function getLegacyStoragePath() {
-  return join79(getOpenCodeCliConfigDir(), LEGACY_STORAGE_FILE_NAME);
+  return join80(getOpenCodeCliConfigDir(), LEGACY_STORAGE_FILE_NAME);
 }
 function normalizeHost2(serverHost) {
   let host = serverHost.trim();
@@ -93307,7 +93458,7 @@ function listTokensByHost(serverHost) {
   for (const [hash2, indexedKey] of Object.entries(index)) {
     if (!indexedKey.startsWith(prefix))
       continue;
-    const indexedToken = readTokenFile(join79(getMcpOauthStorageDir(), `${hash2}.json`));
+    const indexedToken = readTokenFile(join80(getMcpOauthStorageDir(), `${hash2}.json`));
     if (indexedToken)
       result[indexedKey] = indexedToken;
   }
@@ -93322,7 +93473,7 @@ function listAllTokens() {
   for (const entry of readdirSync9(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".json") || entry.name === "index.json")
       continue;
-    const token = readTokenFile(join79(dir, entry.name));
+    const token = readTokenFile(join80(dir, entry.name));
     const hash2 = basename13(entry.name, ".json");
     if (token)
       result[index[hash2] ?? hash2] = token;
@@ -94143,7 +94294,7 @@ import { isAbsolute as isAbsolute10, resolve as resolve23 } from "node:path";
 init_src();
 import { existsSync as existsSync63 } from "node:fs";
 import { homedir as homedir26 } from "node:os";
-import { join as join80 } from "node:path";
+import { join as join81 } from "node:path";
 
 // packages/omo-opencode/src/cli/sparkshell-appserver-websocket.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
@@ -94304,8 +94455,8 @@ function resolveAppServerSocketPath(env3) {
   if (explicit) {
     return explicit;
   }
-  const codexHome = env3["CODEX_HOME"]?.trim() || join80(homedir26(), ".codex");
-  return join80(codexHome, "app-server-control", "app-server-control.sock");
+  const codexHome = env3["CODEX_HOME"]?.trim() || join81(homedir26(), ".codex");
+  return join81(codexHome, "app-server-control", "app-server-control.sock");
 }
 function resolveAppServerTimeoutMs(env3) {
   const parsed = Number.parseInt(env3["OMO_SPARKSHELL_APP_SERVER_TIMEOUT_MS"]?.trim() ?? "", 10);
@@ -94877,7 +95028,7 @@ function isLowSurrogate(codeUnit) {
 init_src();
 import { existsSync as existsSync64, readdirSync as readdirSync10, readFileSync as readFileSync42 } from "node:fs";
 import { homedir as homedir27 } from "node:os";
-import { join as join81 } from "node:path";
+import { join as join82 } from "node:path";
 var SPARKSHELL_SESSION_CONTEXT_ENV = "OMO_SPARKSHELL_SESSION_CONTEXT";
 var SPARKSHELL_SESSION_ID_ENV = "OMO_SPARKSHELL_SESSION_ID";
 var CODEX_THREAD_ID_ENV = "CODEX_THREAD_ID";
@@ -94893,8 +95044,8 @@ function findRolloutPath(sessionId, env3, deps = {}) {
   const fileExists = deps.fileExists ?? existsSync64;
   const listDirectory = deps.listDirectory ?? ((path16) => readdirSync10(path16));
   const homeDirectory = deps.homeDirectory ?? homedir27;
-  const codexHome = env3["CODEX_HOME"]?.trim() || join81(homeDirectory(), ".codex");
-  const roots = [join81(codexHome, "sessions"), join81(codexHome, "archived_sessions")];
+  const codexHome = env3["CODEX_HOME"]?.trim() || join82(homeDirectory(), ".codex");
+  const roots = [join82(codexHome, "sessions"), join82(codexHome, "archived_sessions")];
   const fileSuffix = `-${sessionId}.jsonl`;
   const scanDay = (dayDir) => {
     if (!fileExists(dayDir)) {
@@ -94902,14 +95053,14 @@ function findRolloutPath(sessionId, env3, deps = {}) {
     }
     for (const name of listSafely(listDirectory, dayDir)) {
       if (name.startsWith("rollout-") && name.endsWith(fileSuffix)) {
-        return join81(dayDir, name);
+        return join82(dayDir, name);
       }
     }
     return null;
   };
   for (const dayDir of uuidV7DayDirCandidates(sessionId)) {
     for (const root of roots) {
-      const found = scanDay(join81(root, dayDir));
+      const found = scanDay(join82(root, dayDir));
       if (found) {
         return found;
       }
@@ -94920,9 +95071,9 @@ function findRolloutPath(sessionId, env3, deps = {}) {
       continue;
     }
     for (const year of numericNamesDescending(listSafely(listDirectory, root))) {
-      for (const month of numericNamesDescending(listSafely(listDirectory, join81(root, year)))) {
-        for (const day of numericNamesDescending(listSafely(listDirectory, join81(root, year, month)))) {
-          const found = scanDay(join81(root, year, month, day));
+      for (const month of numericNamesDescending(listSafely(listDirectory, join82(root, year)))) {
+        for (const day of numericNamesDescending(listSafely(listDirectory, join82(root, year, month)))) {
+          const found = scanDay(join82(root, year, month, day));
           if (found) {
             return found;
           }
@@ -95082,7 +95233,7 @@ function uuidV7DayDirCandidates(sessionId) {
   const candidates = [];
   for (const offsetDays of [0, 1, -1]) {
     const date5 = new Date(ms + offsetDays * DAY_MS);
-    candidates.push(join81(String(date5.getFullYear()), pad2(date5.getMonth() + 1), pad2(date5.getDate())));
+    candidates.push(join82(String(date5.getFullYear()), pad2(date5.getMonth() + 1), pad2(date5.getDate())));
   }
   return candidates;
 }
@@ -95123,7 +95274,7 @@ function isFalsy2(value) {
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { mkdtempSync, readFileSync as readFileSync43, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 var SPARKSHELL_SPARK_ENV = "OMO_SPARKSHELL_SPARK";
 var SPARKSHELL_SPARK_MODEL_ENV = "OMO_SPARKSHELL_SPARK_MODEL";
 var SPARKSHELL_SPARK_TIMEOUT_ENV = "OMO_SPARKSHELL_SPARK_TIMEOUT_MS";
@@ -95197,8 +95348,8 @@ function buildSparkExecArgs(env3, lastMessagePath) {
 function createDefaultSparkSummarizer(env3, cwd) {
   return (request) => {
     const binary = env3[SPARKSHELL_SPARK_BIN_ENV]?.trim() || "codex";
-    const tempDir = mkdtempSync(join82(tmpdir4(), "omo-sparkshell-spark-"));
-    const lastMessagePath = join82(tempDir, "last-message.txt");
+    const tempDir = mkdtempSync(join83(tmpdir4(), "omo-sparkshell-spark-"));
+    const lastMessagePath = join83(tempDir, "last-message.txt");
     try {
       const result = spawnSync3(binary, [...buildSparkExecArgs(env3, lastMessagePath)], {
         cwd,