oh-my-opencode 5.1.48 → 5.1.51

package/packages/omo-codex/scripts/install-dist/install-local.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// omo-codex-install:59bc5768b3b3ef6732c97bec7583a523952e5e1d9fdf5d8e5fb245658043bfca:fadb66139b4d0de34630f6b4bddc87783374d2be2659a207a4bb01c2c2f852d0
+// omo-codex-install:2cc6bdfa5c18e3ada377e31b95394052d0d763fa5ca10fb77204728c12f8ab45:ea48fd64c2b141e89231f77a680d39339a6c5b336e6b0cfc9d5a100ac79018bd
 var __esm = (fn, res, err) => () => {
   if (fn)
     try {
@@ -108,9 +108,9 @@ var init_atomic_write = __esm(() => {
 
 // packages/telemetry-core/src/day-claim.ts
 import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2, readdirSync, rmSync as rmSync2 } from "node:fs";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 function getTelemetryDayClaimFilePath(stateDir, dayUTC) {
-  return join34(stateDir, `${CLAIM_PREFIX}${dayUTC}${CLAIM_SUFFIX}`);
+  return join35(stateDir, `${CLAIM_PREFIX}${dayUTC}${CLAIM_SUFFIX}`);
 }
 function claimUtcDay(stateDir, dayUTC) {
   try {
@@ -136,7 +136,7 @@ function pruneSupersededClaims(stateDir, dayUTC) {
     if (!entry.startsWith(CLAIM_PREFIX) || !entry.endsWith(CLAIM_SUFFIX))
       continue;
     try {
-      rmSync2(join34(stateDir, entry), { force: true });
+      rmSync2(join35(stateDir, entry), { force: true });
     } catch {}
   }
 }
@@ -145,20 +145,20 @@ var init_day_claim = () => {};
 
 // packages/telemetry-core/src/activity-state.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "node:fs";
-import { basename as basename6, join as join35 } from "node:path";
+import { basename as basename6, join as join36 } 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 : join35(options.env.XDG_DATA_HOME, product.cacheDirName);
+  const xdgStateDir = options.env?.XDG_DATA_HOME === undefined ? undefined : join36(options.env.XDG_DATA_HOME, product.cacheDirName);
   if (dataDir === xdgStateDir || xdgStateDir === undefined && basename6(dataDir) === product.cacheDirName) {
     return dataDir;
   }
-  return join35(dataDir, product.cacheDirName);
+  return join36(dataDir, product.cacheDirName);
 }
 function getTelemetryActivityStateFilePath(stateDir) {
-  return join35(stateDir, POSTHOG_ACTIVITY_STATE_FILE);
+  return join36(stateDir, POSTHOG_ACTIVITY_STATE_FILE);
 }
 function getDailyActiveCaptureState(input) {
   const dayUTC = getUtcDayString(input.now ?? new Date);
@@ -242,9 +242,9 @@ var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com", DEFAULT_POSTHOG_API_KEY =
 
 // packages/telemetry-core/src/diagnostics.ts
 import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "node:fs";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 function getTelemetryDiagnosticsFilePath(diagnosticsDir) {
-  return join36(diagnosticsDir, DIAGNOSTICS_FILE_NAME);
+  return join37(diagnosticsDir, DIAGNOSTICS_FILE_NAME);
 }
 function writeTelemetryDiagnostic(input, options) {
   const now = options.now ?? new Date;
@@ -453,14 +453,10 @@ var init_event_id = __esm(() => {
 });
 
 // packages/telemetry-core/src/machine-id.ts
-import { createHash as createHash5 } from "node:crypto";
 import os2 from "node:os";
 function getDefaultTelemetryOsProvider() {
   return os2;
 }
-function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetryOsProvider()) {
-  return createHash5("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
-}
 var init_machine_id = () => {};
 
 // packages/telemetry-core/src/injected-client.ts
@@ -610,7 +606,7 @@ var init_injected_client = __esm(() => {
 });
 
 // node_modules/.bun/posthog-node@5.52.4/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname11, posix as posix3, sep as sep7 } from "node:path";
+import { dirname as dirname11, posix as posix3, sep as sep8 } from "node:path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -619,7 +615,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname11(process.argv[1]) : process.cwd(), isWindows = sep7 === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname11(process.argv[1]) : process.cwd(), isWindows = sep8 === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -6979,16 +6975,16 @@ var init_context_lines_node = __esm(() => {
 });
 
 // node_modules/.bun/posthog-node@5.52.4/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
-import { isAbsolute as isAbsolute8, relative as relative4, sep as sep8 } from "node:path";
+import { isAbsolute as isAbsolute8, relative as relative5, sep as sep9 } from "node:path";
 function createRelativePathModifier(basePath = process.cwd()) {
-  const isWindows = sep8 === "\\";
+  const isWindows = sep9 === "\\";
   const toUnix = (p) => isWindows ? p.replace(/\\/g, "/") : p;
   const normalizedBase = toUnix(basePath);
   return async (frames) => {
     for (const frame of frames)
       if (!(!frame.filename || frame.filename.startsWith("node:") || frame.filename.startsWith("data:"))) {
         if (isAbsolute8(frame.filename))
-          frame.filename = toUnix(relative4(normalizedBase, toUnix(frame.filename)));
+          frame.filename = toUnix(relative5(normalizedBase, toUnix(frame.filename)));
       }
     return frames;
   };
@@ -10086,6 +10082,55 @@ var init_posthog_transport = __esm(() => {
 // packages/telemetry-core/src/events.ts
 var init_events = () => {};
 
+// packages/telemetry-core/src/install-id.ts
+import { createHash as createHash5, randomBytes } from "node:crypto";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname12, join as join38 } from "node:path";
+function getTelemetryInstallDistinctId(stateDir) {
+  return createHash5("sha256").update(readOrCreateInstallId(join38(stateDir, TELEMETRY_INSTALL_ID_FILE_NAME))).digest("hex");
+}
+function readOrCreateInstallId(path) {
+  const persisted = readInstallId(path);
+  if (persisted !== undefined)
+    return persisted;
+  const installId = randomBytes(32).toString("hex");
+  try {
+    mkdirSync5(dirname12(path), { recursive: true });
+    writeFileSync2(path, `${installId}
+`, { flag: "wx", mode: 384 });
+    fallbackInstallIds.delete(path);
+    return installId;
+  } catch {
+    const concurrentlyCreated = readInstallId(path);
+    if (concurrentlyCreated !== undefined)
+      return concurrentlyCreated;
+    try {
+      writeFileSync2(path, `${installId}
+`, { flag: "w", mode: 384 });
+      fallbackInstallIds.delete(path);
+      return installId;
+    } catch {}
+    const fallback = fallbackInstallIds.get(path);
+    if (fallback !== undefined)
+      return fallback;
+    fallbackInstallIds.set(path, installId);
+    return installId;
+  }
+}
+function readInstallId(path) {
+  try {
+    const value = readFileSync5(path, "utf8").trim();
+    return INSTALL_ID_PATTERN.test(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+var TELEMETRY_INSTALL_ID_FILE_NAME = "install-id", INSTALL_ID_PATTERN, fallbackInstallIds;
+var init_install_id = __esm(() => {
+  INSTALL_ID_PATTERN = /^[0-9a-f]{64}$/;
+  fallbackInstallIds = new Map;
+});
+
 // packages/telemetry-core/src/posthog-client.ts
 function createTelemetryClient2(input) {
   return createTelemetryClient({ ...input, transportFactory: input.transportFactory ?? createDefaultPostHogTransport });
@@ -10112,6 +10157,7 @@ var init_src = __esm(() => {
   init_env();
   init_event_id();
   init_events();
+  init_install_id();
   init_machine_id();
   init_posthog_client();
   init_record_daily_active();
@@ -10123,7 +10169,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@oh-my-opencode/omo-codex",
-    version: "5.1.48",
+    version: "5.1.51",
     type: "module",
     private: true,
     description: "Codex harness adapter for oh-my-openagent. Vendored Codex plugin namespace (omo) + TypeScript installer + telemetry.",
@@ -10159,7 +10205,7 @@ var init_package = __esm(() => {
       "@oh-my-opencode/utils": "workspace:*"
     },
     devDependencies: {
-      "bun-types": "1.4.3"
+      "bun-types": "1.4.4"
     }
   };
 });
@@ -10174,7 +10220,6 @@ function createCodexTelemetryProductConfig(packageVersion = getProductVersion(),
     defaultApiKey: DEFAULT_POSTHOG_API_KEY,
     defaultHost: DEFAULT_POSTHOG_HOST,
     eventName: EVENT_NAME,
-    machineIdPrefix: MACHINE_ID_PREFIX,
     packageName: PACKAGE_NAME,
     packageVersion,
     platform: "omo-codex",
@@ -10189,7 +10234,7 @@ function createCodexTelemetryProductConfig(packageVersion = getProductVersion(),
     additionalProperties
   };
 }
-var PRODUCT_NAME = "omo-codex", PACKAGE_NAME = "@oh-my-opencode/omo-codex", CACHE_DIR_NAME = "omo-codex", EVENT_NAME = "omo_codex_daily_active", PRODUCT_ENV_PREFIX = "OMO_CODEX", MACHINE_ID_PREFIX = "omo-codex:";
+var PRODUCT_NAME = "omo-codex", PACKAGE_NAME = "@oh-my-opencode/omo-codex", CACHE_DIR_NAME = "omo-codex", EVENT_NAME = "omo_codex_daily_active", PRODUCT_ENV_PREFIX = "OMO_CODEX";
 var init_product_identity = __esm(() => {
   init_src();
   init_package();
@@ -10267,7 +10312,7 @@ function createPostHogClient(source, options = {}) {
   }
   const activityStateProvider = resolveActivityStateProvider(options);
   return {
-    trackActive: (distinctId, reason) => {
+    trackActive: (reason) => {
       const activityState = options.stateDir === undefined ? activityStateProvider() : getDailyActiveCaptureState({
         diagnostics: writeTelemetryDiagnostic2,
         now: options.now,
@@ -10278,7 +10323,7 @@ function createPostHogClient(source, options = {}) {
       }
       client.trackActive({
         dayUTC: activityState.dayUTC,
-        distinctId,
+        distinctId: getTelemetryInstallDistinctId(options.stateDir ?? getActivityStateDir()),
         reason
       });
     },
@@ -10287,15 +10332,13 @@ function createPostHogClient(source, options = {}) {
     }
   };
 }
-function getPostHogDistinctId() {
-  return getTelemetryDistinctId(MACHINE_ID_PREFIX, resolveOsProvider());
-}
 function createInstallPostHog() {
   return createPostHogClient("install");
 }
 var osProviderOverride2 = null, activityStateProviderOverride = null, transportFactoryOverride = null, NO_OP_POSTHOG;
 var init_posthog = __esm(() => {
   init_src();
+  init_data_path();
   init_diagnostics2();
   init_posthog_activity_state();
   init_product_identity();
@@ -10316,7 +10359,7 @@ var init_telemetry = __esm(() => {
 
 // packages/omo-codex/src/install/install-local-cli.ts
 import { readFile as readFile26 } from "node:fs/promises";
-import { dirname as dirname13, join as join41, resolve as resolve11 } from "node:path";
+import { dirname as dirname14, join as join43, resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/utils/src/runtime/spawn.ts
@@ -10587,7 +10630,7 @@ var defaultRunCommand = async (command, args, options) => {
 };
 
 // packages/omo-codex/src/install/install-codex.ts
-import { join as join37, resolve as resolve10 } from "node:path";
+import { join as join39, resolve as resolve10 } from "node:path";
 import { existsSync as existsSync7 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 
@@ -11141,8 +11184,8 @@ async function existingNonSymlink(path) {
   }
 }
 // packages/omo-codex/src/install/codex-cache-install.ts
-import { cp as cp2, mkdir as mkdir3, readFile as readFile8, readdir as readdir4, rename, rm as rm4 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname4, join as join10, sep as sep5 } from "node:path";
+import { cp as cp3, mkdir as mkdir3, readFile as readFile8, readdir as readdir5, rename as rename2, rm as rm5 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname4, join as join11, sep as sep6 } from "node:path";
 
 // packages/omo-codex/src/install/codex-cache-bundled-mcps.ts
 import { cp, mkdir as mkdir2, readFile as readFile4, stat as stat3 } from "node:fs/promises";
@@ -11494,9 +11537,66 @@ async function rewriteCachedManifestRoot(pluginRoot, fromRoot, toRoot) {
 `);
 }
 
+// packages/omo-codex/src/install/codex-cache-payload.ts
+import { cp as cp2, lstat as lstat5, mkdtemp, readdir as readdir4, rename, rm as rm4 } from "node:fs/promises";
+import { join as join9, relative as relative4, sep as sep4 } from "node:path";
+var NPM_BIN_PATH_SEGMENT = `${sep4}node_modules${sep4}.bin${sep4}`;
+async function finalizeCachedPluginPayload(pluginRoot) {
+  await materializeDirectory(pluginRoot);
+  const unsupported = await unsupportedEntries(pluginRoot, pluginRoot);
+  if (unsupported.length > 0) {
+    throw new Error(`Codex plugin contains unsupported entry types: ${unsupported.sort().join(", ")}`);
+  }
+}
+async function materializeDirectory(directory) {
+  for (const name of await readdir4(directory)) {
+    const path = join9(directory, name);
+    let entry = await lstat5(path);
+    if (path.includes(NPM_BIN_PATH_SEGMENT) && !entry.isFile() && !entry.isDirectory()) {
+      await rm4(path, { recursive: true, force: true });
+      continue;
+    }
+    if (entry.isSymbolicLink()) {
+      const staging = await mkdtemp(join9(directory, ".omo-materialize-"));
+      try {
+        const copyPath = join9(staging, "entry");
+        await cp2(path, copyPath, {
+          recursive: true,
+          dereference: true,
+          filter: async (source) => {
+            if (!source.includes(NPM_BIN_PATH_SEGMENT))
+              return true;
+            const sourceEntry = await lstat5(source);
+            return sourceEntry.isFile() || sourceEntry.isDirectory();
+          }
+        });
+        await rm4(path, { force: true, recursive: true });
+        await rename(copyPath, path);
+      } finally {
+        await rm4(staging, { recursive: true, force: true });
+      }
+      entry = await lstat5(path);
+    }
+    if (entry.isDirectory())
+      await materializeDirectory(path);
+  }
+}
+async function unsupportedEntries(root, directory) {
+  const unsupported = [];
+  for (const name of await readdir4(directory)) {
+    const path = join9(directory, name);
+    const entry = await lstat5(path);
+    if (entry.isDirectory())
+      unsupported.push(...await unsupportedEntries(root, path));
+    else if (!entry.isFile())
+      unsupported.push(relative4(root, path));
+  }
+  return unsupported;
+}
+
 // packages/omo-codex/src/install/codex-hook-targets.ts
 import { readFile as readFile7 } from "node:fs/promises";
-import { join as join9, sep as sep4 } from "node:path";
+import { join as join10, sep as sep5 } from "node:path";
 var PLUGIN_ROOT_TARGET_PATTERN = /\$\{PLUGIN_ROOT\}[\\/]+([^"']+)/g;
 async function findMissingHookCommandTargets(pluginRoot) {
   const commands = [];
@@ -11513,7 +11613,7 @@ async function findMissingHookCommandTargets(pluginRoot) {
       const targetSuffix = match[1];
       if (targetSuffix === undefined)
         continue;
-      const target = join9(pluginRoot, ...targetSuffix.split(/[\\/]+/));
+      const target = join10(pluginRoot, ...targetSuffix.split(/[\\/]+/));
       if (seen.has(target))
         continue;
       seen.add(target);
@@ -11524,17 +11624,17 @@ async function findMissingHookCommandTargets(pluginRoot) {
   return missing;
 }
 async function hookManifestPaths(pluginRoot) {
-  const pluginManifestPath = join9(pluginRoot, ".codex-plugin", "plugin.json");
+  const pluginManifestPath = join10(pluginRoot, ".codex-plugin", "plugin.json");
   if (!await fileExistsStrict(pluginManifestPath))
-    return [join9(pluginRoot, "hooks", "hooks.json")];
+    return [join10(pluginRoot, "hooks", "hooks.json")];
   const parsed = JSON.parse(await readFile7(pluginManifestPath, "utf8"));
   if (!isPlainRecord(parsed))
     return [];
   if (typeof parsed.hooks === "string" && parsed.hooks.trim() !== "") {
-    return [join9(pluginRoot, stripDotSlash(parsed.hooks))];
+    return [join10(pluginRoot, stripDotSlash(parsed.hooks))];
   }
   if (Array.isArray(parsed.hooks)) {
-    return parsed.hooks.filter((hookPath) => typeof hookPath === "string" && hookPath.trim() !== "").map((hookPath) => join9(pluginRoot, stripDotSlash(hookPath)));
+    return parsed.hooks.filter((hookPath) => typeof hookPath === "string" && hookPath.trim() !== "").map((hookPath) => join10(pluginRoot, stripDotSlash(hookPath)));
   }
   return [];
 }
@@ -11545,7 +11645,7 @@ async function assertHookCommandTargets(pluginRoot) {
   const missing = await findMissingHookCommandTargets(pluginRoot);
   if (missing.length === 0)
     return;
-  const relativeMissing = missing.map((path) => path.split(`${pluginRoot}${sep4}`).join("").split(sep4).join("/"));
+  const relativeMissing = missing.map((path) => path.split(`${pluginRoot}${sep5}`).join("").split(sep5).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) {
@@ -11572,9 +11672,9 @@ async function installCachedPlugin(input) {
     await maybeRunNpmInstall(input.sourcePath, input.runCommand, npmInstallEnv);
     await maybeRunNpmBuild(input.sourcePath, input.runCommand, env);
   }
-  const targetPath = join10(input.codexHome, "plugins", "cache", input.marketplaceName, input.name, input.version);
+  const targetPath = join11(input.codexHome, "plugins", "cache", input.marketplaceName, input.name, input.version);
   const tempPath = createTempSiblingPath(targetPath);
-  await rm4(tempPath, { recursive: true, force: true });
+  await rm5(tempPath, { recursive: true, force: true });
   try {
     await copyDirectory(input.sourcePath, tempPath);
     const rewroteLocalFileDependencies = await rewriteCachedPackageLocalFileDependencies(tempPath, input.sourcePath);
@@ -11590,30 +11690,31 @@ async function installCachedPlugin(input) {
     await rewriteCachedMcpManifest(tempPath, input.sourcePath);
     await rewriteCachedManifestRoot(tempPath, tempPath, targetPath);
     await assertHookCommandTargets(tempPath);
-    await promoteDirectory(tempPath, targetPath, input.renameDirectory ?? rename);
-    const versions = await readdir4(dirname4(targetPath), { withFileTypes: true });
+    await finalizeCachedPluginPayload(tempPath);
+    await promoteDirectory(tempPath, targetPath, input.renameDirectory ?? rename2);
+    const versions = await readdir5(dirname4(targetPath), { withFileTypes: true });
     for (const entry of versions) {
       if (!entry.isDirectory() || entry.name === input.version || entry.name.startsWith("."))
         continue;
       if (!/^[a-zA-Z0-9_+-][a-zA-Z0-9._+-]*$/.test(entry.name))
         continue;
-      await rm4(join10(dirname4(targetPath), entry.name), { recursive: true, force: true });
+      await rm5(join11(dirname4(targetPath), entry.name), { recursive: true, force: true });
     }
   } catch (error) {
-    await rm4(tempPath, { recursive: true, force: true });
+    await rm5(tempPath, { recursive: true, force: true });
     throw error;
   }
   return { name: input.name, version: input.version, path: targetPath };
 }
 async function maybeRunNpmInstall(cwd, runCommand, env, args = ["install"]) {
-  if (!await fileExistsStrict(join10(cwd, "package.json")))
+  if (!await fileExistsStrict(join11(cwd, "package.json")))
     return;
   await runCommand("npm", args, { cwd, env });
 }
 async function maybeRunNpmBuild(cwd, runCommand, env) {
-  if (!await fileExistsStrict(join10(cwd, "package.json")))
+  if (!await fileExistsStrict(join11(cwd, "package.json")))
     return;
-  const packageJson = JSON.parse(await readFile8(join10(cwd, "package.json"), "utf8"));
+  const packageJson = JSON.parse(await readFile8(join11(cwd, "package.json"), "utf8"));
   if (!isPlainRecord(packageJson))
     return;
   const scripts = packageJson.scripts;
@@ -11622,9 +11723,9 @@ async function maybeRunNpmBuild(cwd, runCommand, env) {
   await runCommand("npm", ["run", "build"], { cwd, env });
 }
 async function maybeRunNpmSyncSkills(cwd, runCommand, env) {
-  if (!await fileExistsStrict(join10(cwd, "package.json")))
+  if (!await fileExistsStrict(join11(cwd, "package.json")))
     return;
-  const packageJson = JSON.parse(await readFile8(join10(cwd, "package.json"), "utf8"));
+  const packageJson = JSON.parse(await readFile8(join11(cwd, "package.json"), "utf8"));
   if (!isPlainRecord(packageJson))
     return;
   const scripts = packageJson.scripts;
@@ -11636,18 +11737,18 @@ function sanitizeNpmInstallEnv(env) {
   return Object.fromEntries(Object.entries(env).filter(([key]) => key.toLowerCase() !== "npm_config_allow_scripts"));
 }
 function createTempSiblingPath(targetPath) {
-  return join10(dirname4(targetPath), `.tmp-${basename2(targetPath)}-${process.pid}-${Date.now()}`);
+  return join11(dirname4(targetPath), `.tmp-${basename2(targetPath)}-${process.pid}-${Date.now()}`);
 }
 function createBackupSiblingPath(targetPath) {
-  return join10(dirname4(targetPath), `.backup-${basename2(targetPath)}-${process.pid}-${Date.now()}`);
+  return join11(dirname4(targetPath), `.backup-${basename2(targetPath)}-${process.pid}-${Date.now()}`);
 }
 async function copyDirectory(sourcePath, targetPath) {
   await mkdir3(dirname4(targetPath), { recursive: true });
-  await cp2(sourcePath, targetPath, { recursive: true, filter: (source) => shouldCopyPluginPath(source, sourcePath) });
+  await cp3(sourcePath, targetPath, { recursive: true, filter: (source) => shouldCopyPluginPath(source, sourcePath) });
 }
 async function promoteDirectory(tempPath, targetPath, renameDirectory) {
   const backupPath = createBackupSiblingPath(targetPath);
-  await rm4(backupPath, { recursive: true, force: true });
+  await rm5(backupPath, { recursive: true, force: true });
   let backupMoved = false;
   try {
     if (await fileExistsStrict(targetPath)) {
@@ -11661,19 +11762,19 @@ async function promoteDirectory(tempPath, targetPath, renameDirectory) {
     throw error;
   }
   if (backupMoved)
-    await rm4(backupPath, { recursive: true, force: true });
+    await rm5(backupPath, { recursive: true, force: true });
 }
 async function restoreBackupDirectory(backupPath, targetPath, renameDirectory) {
   if (!await fileExistsStrict(backupPath))
     return;
-  await rm4(targetPath, { recursive: true, force: true });
+  await rm5(targetPath, { recursive: true, force: true });
   await renameDirectory(backupPath, targetPath);
 }
 function shouldCopyPluginPath(path, root) {
-  const relative = path === root ? "" : path.slice(root.length + sep5.length);
+  const relative = path === root ? "" : path.slice(root.length + sep6.length);
   if (relative === "")
     return true;
-  const parts = relative.split(sep5);
+  const parts = relative.split(sep6);
   if (parts.some((part) => part === ".git" || part === "node_modules"))
     return false;
   return !isNestedComponentMcpManifest(parts);
@@ -11687,18 +11788,18 @@ var removedSparkshellPromptSurfaceFiles = new Set(["directive.md", "plugin.json"
 var removedSparkshellTextFilePattern = /\.(?:json|md|toml|ya?ml)$/i;
 async function assertNoRemovedSparkshellPromptReferences(pluginRoot) {
   for (const filePath of await listRemovedSparkshellPromptSurfaceFiles(pluginRoot, "")) {
-    const content = await readFile8(join10(pluginRoot, filePath), "utf8");
+    const content = await readFile8(join11(pluginRoot, filePath), "utf8");
     if (!removedSparkshellReferencePattern.test(content))
       continue;
     throw new Error(`removed sparkshell reference found in Codex plugin prompt surface: ${filePath}`);
   }
 }
 async function listRemovedSparkshellPromptSurfaceFiles(pluginRoot, relativeDirectory) {
-  const directory = relativeDirectory === "" ? pluginRoot : join10(pluginRoot, relativeDirectory);
-  const entries = await readdir4(directory, { withFileTypes: true });
+  const directory = relativeDirectory === "" ? pluginRoot : join11(pluginRoot, relativeDirectory);
+  const entries = await readdir5(directory, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const relativePath = relativeDirectory === "" ? entry.name : join10(relativeDirectory, entry.name);
+    const relativePath = relativeDirectory === "" ? entry.name : join11(relativeDirectory, entry.name);
     if (entry.isDirectory()) {
       if (shouldDescendIntoRemovedSparkshellPromptSurface(relativePath)) {
         files.push(...await listRemovedSparkshellPromptSurfaceFiles(pluginRoot, relativePath));
@@ -11711,7 +11812,7 @@ async function listRemovedSparkshellPromptSurfaceFiles(pluginRoot, relativeDirec
   return files.sort();
 }
 function shouldDescendIntoRemovedSparkshellPromptSurface(relativePath) {
-  const parts = relativePath.split(sep5);
+  const parts = relativePath.split(sep6);
   if (parts.some((part) => part === ".git" || part === "dist" || part === "node_modules"))
     return false;
   if (parts[0] === "components") {
@@ -11724,7 +11825,7 @@ function shouldDescendIntoRemovedSparkshellPromptSurface(relativePath) {
 function shouldCheckRemovedSparkshellPromptFile(relativePath) {
   if (!removedSparkshellTextFilePattern.test(relativePath))
     return false;
-  const parts = relativePath.split(sep5);
+  const parts = relativePath.split(sep6);
   const fileName = parts.at(-1) ?? "";
   if (parts[0] === "components") {
     if (parts.length === 3)
@@ -11738,25 +11839,25 @@ async function copyRootRuntimeDists(input) {
   if (repoRoot === null)
     return;
   for (const runtimePath of ["dist/cli", "dist/cli-node"]) {
-    const sourcePath = join10(repoRoot, runtimePath);
-    if (!await fileExistsStrict(join10(sourcePath, "index.js")))
+    const sourcePath = join11(repoRoot, runtimePath);
+    if (!await fileExistsStrict(join11(sourcePath, "index.js")))
       continue;
-    await mkdir3(dirname4(join10(input.pluginRoot, runtimePath)), { recursive: true });
-    await cp2(sourcePath, join10(input.pluginRoot, runtimePath), { recursive: true });
+    await mkdir3(dirname4(join11(input.pluginRoot, runtimePath)), { recursive: true });
+    await cp3(sourcePath, join11(input.pluginRoot, runtimePath), { recursive: true });
   }
 }
-var canonicalPromptRelativePaths = [join10("packages", "prompts-core", "prompts", "ultrawork", "codex.md")];
+var canonicalPromptRelativePaths = [join11("packages", "prompts-core", "prompts", "ultrawork", "codex.md")];
 async function copyCanonicalPromptSources(input) {
   const repoRoot = repoRootForCodexPluginSource(input.sourcePath);
   if (repoRoot === null)
     return;
   for (const relativePath of canonicalPromptRelativePaths) {
-    const sourceFile = join10(repoRoot, relativePath);
+    const sourceFile = join11(repoRoot, relativePath);
     if (!await fileExistsStrict(sourceFile))
       continue;
-    const targetFile = join10(input.pluginRoot, relativePath);
+    const targetFile = join11(input.pluginRoot, relativePath);
     await mkdir3(dirname4(targetFile), { recursive: true });
-    await cp2(sourceFile, targetFile);
+    await cp3(sourceFile, targetFile);
   }
 }
 function repoRootForCodexPluginSource(sourcePath) {
@@ -11771,10 +11872,10 @@ function repoRootForCodexPluginSource(sourcePath) {
   return dirname4(packagesRoot);
 }
 // packages/omo-codex/src/install/codex-cache-prune.ts
-import { lstat as lstat5, readdir as readdir5, rm as rm5, stat as stat4 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { lstat as lstat6, readdir as readdir6, rm as rm6, stat as stat4 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 async function pruneMarketplaceCache(input) {
-  const cacheRoot = join11(input.codexHome, "plugins", "cache", input.marketplaceName);
+  const cacheRoot = join12(input.codexHome, "plugins", "cache", input.marketplaceName);
   if (!await fileExistsStrict(cacheRoot))
     return;
   const keep = new Set(input.keepPluginNames);
@@ -11782,28 +11883,28 @@ async function pruneMarketplaceCache(input) {
   for (const entry of entries) {
     if (!entry.isDirectory() || keep.has(entry.name))
       continue;
-    await rm5(join11(cacheRoot, entry.name), { recursive: true, force: true });
+    await rm6(join12(cacheRoot, entry.name), { recursive: true, force: true });
   }
 }
 async function pruneMarketplacePluginCaches(input) {
-  const cacheRoot = join11(input.codexHome, "plugins", "cache", input.marketplaceName);
+  const cacheRoot = join12(input.codexHome, "plugins", "cache", input.marketplaceName);
   if (!await fileExistsStrict(cacheRoot))
     return;
   for (const pluginName of input.pluginNames) {
-    await rm5(join11(cacheRoot, pluginName), { recursive: true, force: true });
+    await rm6(join12(cacheRoot, pluginName), { recursive: true, force: true });
   }
   const remainingEntries = await readCacheEntryNames(cacheRoot);
   if (remainingEntries.length === 0) {
-    await rm5(cacheRoot, { recursive: true, force: true });
+    await rm6(cacheRoot, { recursive: true, force: true });
   }
 }
 async function readCacheEntries(path) {
   const emptyEntries = [];
-  return readCacheRoot(path, () => readdir5(path, { withFileTypes: true }), emptyEntries);
+  return readCacheRoot(path, () => readdir6(path, { withFileTypes: true }), emptyEntries);
 }
 async function readCacheEntryNames(path) {
   const emptyNames = [];
-  return readCacheRoot(path, () => readdir5(path), emptyNames);
+  return readCacheRoot(path, () => readdir6(path), emptyNames);
 }
 async function readCacheRoot(path, readEntries, fallback) {
   try {
@@ -11818,7 +11919,7 @@ async function readCacheRoot(path, readEntries, fallback) {
 }
 async function isBrokenCacheSymlink(path) {
   try {
-    const entry = await lstat5(path);
+    const entry = await lstat6(path);
     if (!entry.isSymbolicLink())
       return false;
   } catch (error) {
@@ -11836,18 +11937,18 @@ async function isBrokenCacheSymlink(path) {
   }
 }
 // packages/omo-codex/src/install/codex-cached-marketplace-manifest.ts
-import { mkdir as mkdir4, rename as rename2, rm as rm6, stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { mkdir as mkdir4, rename as rename3, rm as rm7, stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join13 } from "node:path";
 async function writeCachedMarketplaceManifest(input) {
-  const marketplaceDir = join12(input.marketplaceRoot, ".agents", "plugins");
+  const marketplaceDir = join13(input.marketplaceRoot, ".agents", "plugins");
   await mkdir4(marketplaceDir, { recursive: true });
   for (const plugin of input.plugins) {
-    const pluginPath = join12(input.marketplaceRoot, plugin.name, plugin.version);
+    const pluginPath = join13(input.marketplaceRoot, plugin.name, plugin.version);
     if (!await isDirectory2(pluginPath))
       throw new Error(`Cannot write cached marketplace manifest: ${pluginPath} does not exist`);
   }
-  const manifestPath = join12(marketplaceDir, "marketplace.json");
-  const tempPath = join12(marketplaceDir, `.marketplace.json.tmp-${process.pid}-${Date.now()}`);
+  const manifestPath = join13(marketplaceDir, "marketplace.json");
+  const tempPath = join13(marketplaceDir, `.marketplace.json.tmp-${process.pid}-${Date.now()}`);
   try {
     await writeFile4(tempPath, `${JSON.stringify({
       name: input.marketplaceName,
@@ -11857,9 +11958,9 @@ async function writeCachedMarketplaceManifest(input) {
       }))
     }, null, "\t")}
 `);
-    await rename2(tempPath, manifestPath);
+    await rename3(tempPath, manifestPath);
   } catch (error) {
-    await rm6(tempPath, { force: true });
+    await rm7(tempPath, { force: true });
     throw error;
   }
 }
@@ -11876,7 +11977,7 @@ async function isDirectory2(path) {
 // packages/omo-codex/src/install/codex-package-layout.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile as readFile9 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 var PACKAGED_CODEX_INSTALLER_NAMES = new Set([
   "@code-yeongyu/lazycodex",
   "@code-yeongyu/lazycodex-ai",
@@ -11886,9 +11987,9 @@ var PACKAGED_CODEX_INSTALLER_NAMES = new Set([
   "oh-my-openagent"
 ]);
 async function shouldBuildSourcePackages(repoRoot) {
-  if (existsSync2(join13(repoRoot, "packages", "omo-opencode", "src", "index.ts")))
+  if (existsSync2(join14(repoRoot, "packages", "omo-opencode", "src", "index.ts")))
     return true;
-  const packageJsonPath = join13(repoRoot, "package.json");
+  const packageJsonPath = join14(repoRoot, "package.json");
   if (!existsSync2(packageJsonPath))
     return true;
   const packageJson = JSON.parse(await readFile9(packageJsonPath, "utf8"));
@@ -12495,13 +12596,13 @@ function tomlKeySegment(value) {
 }
 
 // packages/omo-codex/src/install/codex-config-atomic-write.ts
-import { lstat as lstat6, readlink as readlink4, realpath, rename as rename3, unlink, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute5, join as join14, resolve as resolve6 } from "node:path";
+import { lstat as lstat7, readlink as readlink4, realpath, rename as rename4, unlink, writeFile as writeFile5 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute5, join as join15, resolve as resolve6 } 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 = join14(dirname5(writeTarget), `.tmp-${basename3(writeTarget)}-${process.pid}-${Date.now()}`);
+  const temporaryPath = join15(dirname5(writeTarget), `.tmp-${basename3(writeTarget)}-${process.pid}-${Date.now()}`);
   await writeFile5(temporaryPath, data);
   try {
     await renameWithRetry(temporaryPath, writeTarget);
@@ -12516,7 +12617,7 @@ async function writeFileAtomic(targetPath, data) {
 }
 async function resolveSymlinkTarget(targetPath) {
   try {
-    const linkStats = await lstat6(targetPath);
+    const linkStats = await lstat7(targetPath);
     if (!linkStats.isSymbolicLink())
       return targetPath;
   } catch (error) {
@@ -12536,7 +12637,7 @@ async function resolveSymlinkTarget(targetPath) {
 async function renameWithRetry(fromPath, toPath) {
   for (let attempt = 0;; attempt += 1) {
     try {
-      await rename3(fromPath, toPath);
+      await rename4(fromPath, toPath);
       return;
     } catch (error) {
       if (!isRetriableRenameError(error) || attempt >= RENAME_RETRY_DELAYS_MS.length) {
@@ -13001,7 +13102,7 @@ function isRootSetting(line, key) {
 
 // packages/omo-codex/src/install/codex-model-catalog.ts
 import { readFile as readFile10 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 
 // packages/model-core/src/latest-models.ts
 var LATEST_MODEL_BY_FAMILY = {
@@ -13050,7 +13151,7 @@ var FALLBACK_CODEX_MODEL_CATALOG = {
   ]
 };
 async function readCodexModelCatalog(codexPackageRoot) {
-  const catalogPath = join15(codexPackageRoot, "plugin", "model-catalog.json");
+  const catalogPath = join16(codexPackageRoot, "plugin", "model-catalog.json");
   try {
     const parsed = JSON.parse(await readFile10(catalogPath, "utf8"));
     return parseCodexModelCatalog(parsed) ?? FALLBACK_CODEX_MODEL_CATALOG;
@@ -13134,7 +13235,7 @@ function isRootSetting2(line, key) {
 
 // packages/omo-codex/src/install/codex-multi-agent-v2-config.ts
 import { readFileSync } from "node:fs";
-import { dirname as dirname6, isAbsolute as isAbsolute6, join as join16 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute6, join as join17 } from "node:path";
 var CODEX_AGENTS_HEADER = "agents";
 var CODEX_MULTI_AGENT_V2_HEADER = "features.multi_agent_v2";
 function ensureCodexMultiAgentV2Config(config, options = {}) {
@@ -13162,8 +13263,8 @@ function resolveCodexMultiAgentVersion(config, configPath) {
 }
 function resolveCatalogPath(configuredPath, configPath) {
   if (configuredPath === null)
-    return join16(dirname6(configPath), "models_cache.json");
-  return isAbsolute6(configuredPath) ? configuredPath : join16(dirname6(configPath), configuredPath);
+    return join17(dirname6(configPath), "models_cache.json");
+  return isAbsolute6(configuredPath) ? configuredPath : join17(dirname6(configPath), configuredPath);
 }
 function readCatalogMultiAgentVersion(model, cachePath) {
   let raw;
@@ -13326,7 +13427,7 @@ function isMissingFileError(error) {
 // packages/omo-codex/src/install/codex-hook-trust.ts
 import { createHash } from "node:crypto";
 import { readFile as readFile12 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var EVENT_LABELS = new Map([
   ["PreToolUse", "pre_tool_use"],
   ["PermissionRequest", "permission_request"],
@@ -13340,7 +13441,7 @@ var EVENT_LABELS = new Map([
   ["Stop", "stop"]
 ]);
 async function trustedHookStatesForPlugin(input) {
-  const manifestPath = join17(input.pluginRoot, ".codex-plugin", "plugin.json");
+  const manifestPath = join18(input.pluginRoot, ".codex-plugin", "plugin.json");
   if (!await exists(manifestPath))
     return [];
   const manifest = JSON.parse(await readFile12(manifestPath, "utf8"));
@@ -13348,7 +13449,7 @@ async function trustedHookStatesForPlugin(input) {
     return [];
   const states = [];
   for (const hookPath of hookManifestPaths2(manifest.hooks)) {
-    const hooksPath = join17(input.pluginRoot, hookPath);
+    const hooksPath = join18(input.pluginRoot, hookPath);
     if (!await exists(hooksPath))
       continue;
     const parsed = JSON.parse(await readFile12(hooksPath, "utf8"));
@@ -21524,7 +21625,7 @@ function validateConfigLayer(path, data) {
 
 // packages/omo-config-core/src/loader/paths.ts
 import { userInfo } from "node:os";
-import { dirname as dirname8, join as join18, posix, resolve as resolve7 } from "node:path";
+import { dirname as dirname8, join as join19, posix, resolve as resolve7 } from "node:path";
 
 // packages/omo-config-core/src/internal/posix-path.ts
 function toPosixPath2(path) {
@@ -21539,14 +21640,14 @@ function resolveHomeDir(env = process.env) {
   return homeDir.startsWith("/") ? posix.resolve(homeDir) : toPosixPath2(resolve7(homeDir));
 }
 function resolveUserOmoConfigDirectory(env = process.env) {
-  return join18(resolveHomeDir(env), ".omo");
+  return join19(resolveHomeDir(env), ".omo");
 }
 function detectUserOmoJsonPath(env, fileSystem) {
   const configDir = resolveUserOmoConfigDirectory(env);
-  const jsoncPath = join18(configDir, "omo.jsonc");
+  const jsoncPath = join19(configDir, "omo.jsonc");
   if (fileSystem.existsSync(jsoncPath))
     return jsoncPath;
-  const jsonPath = join18(configDir, "omo.json");
+  const jsonPath = join19(configDir, "omo.json");
   return fileSystem.existsSync(jsonPath) ? jsonPath : jsoncPath;
 }
 function isSymlinkedProjectPath(path, fileSystem) {
@@ -21564,13 +21665,13 @@ function isLoadableProjectConfigFile(path, fileSystem) {
   return fileSystem.existsSync(path) && !isSymlinkedProjectPath(path, fileSystem);
 }
 function detectOmoJsonPath(dir, fileSystem) {
-  const omoDir = join18(dir, ".omo");
+  const omoDir = join19(dir, ".omo");
   if (isSymlinkedProjectPath(omoDir, fileSystem))
     return null;
-  const jsoncPath = join18(omoDir, "omo.jsonc");
+  const jsoncPath = join19(omoDir, "omo.jsonc");
   if (isLoadableProjectConfigFile(jsoncPath, fileSystem))
     return jsoncPath;
-  const jsonPath = join18(omoDir, "omo.json");
+  const jsonPath = join19(omoDir, "omo.json");
   return isLoadableProjectConfigFile(jsonPath, fileSystem) ? jsonPath : null;
 }
 function realpathOrSelf(path, fileSystem) {
@@ -21890,8 +21991,8 @@ function recordAt(value, key) {
 }
 
 // packages/omo-codex/src/install/codex-marketplace-snapshot.ts
-import { cp as cp3, mkdir as mkdir6, rename as rename4, rm as rm7, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join19, sep as sep6 } from "node:path";
+import { cp as cp4, mkdir as mkdir6, rename as rename5, rm as rm8, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join20, sep as sep7 } from "node:path";
 var INSTALLED_MARKETPLACES_DIR = ".tmp/marketplaces";
 async function writeInstalledMarketplaceSnapshot(input) {
   const marketplaceRoot = installedMarketplaceRoot(input.codexHome, input.marketplace.name);
@@ -21904,51 +22005,51 @@ async function writeInstalledMarketplaceSnapshot(input) {
   return snapshotPlugins;
 }
 function installedMarketplaceRoot(codexHome, marketplaceName) {
-  return join19(codexHome, INSTALLED_MARKETPLACES_DIR, marketplaceName);
+  return join20(codexHome, INSTALLED_MARKETPLACES_DIR, marketplaceName);
 }
 async function writeMarketplaceManifest(marketplaceRoot, marketplace) {
-  const manifestDir = join19(marketplaceRoot, ".agents", "plugins");
+  const manifestDir = join20(marketplaceRoot, ".agents", "plugins");
   await mkdir6(manifestDir, { recursive: true });
-  const tempPath = join19(manifestDir, `.marketplace-${process.pid}-${Date.now()}.json.tmp`);
+  const tempPath = join20(manifestDir, `.marketplace-${process.pid}-${Date.now()}.json.tmp`);
   await writeFile6(tempPath, `${JSON.stringify(marketplace, null, "\t")}
 `);
-  await rename4(tempPath, join19(manifestDir, "marketplace.json"));
+  await rename5(tempPath, join20(manifestDir, "marketplace.json"));
 }
 async function writeSnapshotPlugin(marketplaceRoot, plugin) {
-  const pluginsDir = join19(marketplaceRoot, "plugins");
+  const pluginsDir = join20(marketplaceRoot, "plugins");
   await mkdir6(pluginsDir, { recursive: true });
-  const targetPath = join19(pluginsDir, plugin.name);
-  const tempPath = join19(pluginsDir, `.tmp-${plugin.name}-${process.pid}-${Date.now()}`);
-  await rm7(tempPath, { recursive: true, force: true });
-  await cp3(plugin.sourcePath, tempPath, {
+  const targetPath = join20(pluginsDir, plugin.name);
+  const tempPath = join20(pluginsDir, `.tmp-${plugin.name}-${process.pid}-${Date.now()}`);
+  await rm8(tempPath, { recursive: true, force: true });
+  await cp4(plugin.sourcePath, tempPath, {
     recursive: true,
     filter: (source) => shouldCopyMarketplaceSourcePath(source, plugin.sourcePath)
   });
   await copyBundledMcpRuntimeDists({ pluginRoot: tempPath, sourceRoot: plugin.sourcePath });
-  await rm7(targetPath, { recursive: true, force: true });
-  await rename4(tempPath, targetPath);
+  await rm8(targetPath, { recursive: true, force: true });
+  await rename5(tempPath, targetPath);
   await rewriteCachedMcpManifest(targetPath, plugin.sourcePath);
   return { name: plugin.name, path: targetPath };
 }
 function shouldCopyMarketplaceSourcePath(path, root) {
-  const relative = path === root ? "" : path.slice(root.length + sep6.length);
+  const relative = path === root ? "" : path.slice(root.length + sep7.length);
   if (relative === "")
     return true;
-  const parts = relative.split(sep6);
+  const parts = relative.split(sep7);
   return !parts.some((part) => part === ".git" || part === "node_modules");
 }
 
 // packages/omo-codex/src/install/link-cached-plugin-agents.ts
-import { copyFile, lstat as lstat10, mkdir as mkdir7, readdir as readdir7, readFile as readFile17, rm as rm11, writeFile as writeFile9 } from "node:fs/promises";
-import { basename as basename4, join as join24 } from "node:path";
+import { copyFile, lstat as lstat11, mkdir as mkdir7, readdir as readdir8, readFile as readFile17, rm as rm12, writeFile as writeFile9 } from "node:fs/promises";
+import { basename as basename4, join as join25 } from "node:path";
 
 // packages/omo-codex/src/install/agent-model-overrides.ts
-import { readFile as readFile14, rm as rm8, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { readFile as readFile14, rm as rm9, writeFile as writeFile8 } from "node:fs/promises";
+import { join as join22 } from "node:path";
 
 // packages/omo-codex/src/install/preserved-agent-settings.ts
-import { lstat as lstat7, readFile as readFile13, readdir as readdir6, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { lstat as lstat8, readFile as readFile13, readdir as readdir7, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join21 } from "node:path";
 
 // packages/omo-codex/src/install/managed-agent-reasoning-defaults.ts
 var MANAGED_REASONING_DEFAULT_UPGRADES = new Map([
@@ -22141,15 +22242,15 @@ function resolveManagedAgentReasoning(input) {
 
 // packages/omo-codex/src/install/preserved-agent-settings.ts
 async function capturePreservedAgentReasoning(input) {
-  const agentsDir = join20(input.codexHome, "agents");
+  const agentsDir = join21(input.codexHome, "agents");
   if (!await exists2(agentsDir))
     return new Map;
   const preserved = new Map;
-  const agentEntries = await readdir6(agentsDir, { withFileTypes: true });
+  const agentEntries = await readdir7(agentsDir, { withFileTypes: true });
   for (const entry of agentEntries) {
     if (!entry.name.endsWith(".toml"))
       continue;
-    const content = await readTextIfExists(join20(agentsDir, entry.name));
+    const content = await readTextIfExists(join21(agentsDir, entry.name));
     if (content === null)
       continue;
     const effort = extractReasoningEffort(content);
@@ -22163,15 +22264,15 @@ async function capturePreservedAgentReasoning(input) {
   return preserved;
 }
 async function capturePreservedAgentServiceTier(input) {
-  const agentsDir = join20(input.codexHome, "agents");
+  const agentsDir = join21(input.codexHome, "agents");
   if (!await exists2(agentsDir))
     return new Map;
   const preserved = new Map;
-  const agentEntries = await readdir6(agentsDir, { withFileTypes: true });
+  const agentEntries = await readdir7(agentsDir, { withFileTypes: true });
   for (const entry of agentEntries) {
     if (!entry.name.endsWith(".toml"))
       continue;
-    const content = await readTextIfExists(join20(agentsDir, entry.name));
+    const content = await readTextIfExists(join21(agentsDir, entry.name));
     if (content === null)
       continue;
     preserved.set(agentNameFromToml(entry.name), extractServiceTier(content));
@@ -22300,7 +22401,7 @@ function agentNameFromToml(fileName) {
 }
 async function exists2(path) {
   try {
-    await lstat7(path);
+    await lstat8(path);
     return true;
   } catch (error) {
     if (nodeErrorCode(error) !== "ENOENT")
@@ -22339,7 +22440,7 @@ async function readAgentModelReceipts(codexHome) {
 async function writeAgentModelReceipts(codexHome, receipts) {
   const path = receiptPath(codexHome);
   if (receipts.size === 0) {
-    await rm8(path, { force: true });
+    await rm9(path, { force: true });
     return;
   }
   await writeFile8(path, `${JSON.stringify(Object.fromEntries(receipts), null, "\t")}
@@ -22360,7 +22461,7 @@ async function applyAgentOverride(input) {
   await writeFile8(input.linkPath, content);
 }
 function receiptPath(codexHome) {
-  return join21(codexHome, "agents", RECEIPT_FILE);
+  return join22(codexHome, "agents", RECEIPT_FILE);
 }
 function parseJson(content) {
   try {
@@ -22392,8 +22493,8 @@ function handEditedAgentModel(installedModel, receipt) {
 }
 
 // packages/omo-codex/src/install/retired-managed-agent-purge.ts
-import { lstat as lstat8, readFile as readFile15, rm as rm9 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { lstat as lstat9, readFile as readFile15, rm as rm10 } from "node:fs/promises";
+import { join as join23 } from "node:path";
 var RETIRED_MANAGED_AGENT_FILES = [
   {
     fileName: "codex-ultrawork-reviewer.toml",
@@ -22405,20 +22506,20 @@ var RETIRED_MANAGED_AGENT_FILES = [
   }
 ];
 async function purgeRetiredManagedAgentFiles(input) {
-  const agentsDir = join22(input.codexHome, "agents");
+  const agentsDir = join23(input.codexHome, "agents");
   if (!await exists3(agentsDir))
     return;
   for (const retiredAgent of RETIRED_MANAGED_AGENT_FILES) {
-    const agentPath = join22(agentsDir, retiredAgent.fileName);
+    const agentPath = join23(agentsDir, retiredAgent.fileName);
     if (!await exists3(agentPath))
       continue;
-    const agentStat = await lstat8(agentPath);
+    const agentStat = await lstat9(agentPath);
     if (agentStat.isDirectory() && !agentStat.isSymbolicLink())
       continue;
     const content = await readTextIfExists2(agentPath);
     if (content === null || !hasRequiredMarkers(content, retiredAgent.requiredMarkers))
       continue;
-    await rm9(agentPath, { force: true });
+    await rm10(agentPath, { force: true });
   }
 }
 function hasRequiredMarkers(content, markers) {
@@ -22435,7 +22536,7 @@ async function readTextIfExists2(path) {
 }
 async function exists3(path) {
   try {
-    await lstat8(path);
+    await lstat9(path);
     return true;
   } catch (error) {
     if (nodeErrorCode2(error) !== "ENOENT")
@@ -22451,15 +22552,15 @@ function nodeErrorCode2(error) {
 
 // packages/omo-codex/src/install/default-agent-role.ts
 import { createHash as createHash3 } from "node:crypto";
-import { lstat as lstat9, readFile as readFile16, rm as rm10 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { lstat as lstat10, readFile as readFile16, rm as rm11 } from "node:fs/promises";
+import { join as join24 } from "node:path";
 var REGISTRATION = { name: "default", configFile: "./agents/default.toml" };
 async function installDefaultAgentRole(input) {
-  const target = join23(input.codexHome, "agents", "default.toml");
-  const receipt = join23(input.codexHome, "agents", ".lazycodex-default.sha256");
-  const configPath = join23(input.codexHome, "config.toml");
+  const target = join24(input.codexHome, "agents", "default.toml");
+  const receipt = join24(input.codexHome, "agents", ".lazycodex-default.sha256");
+  const configPath = join24(input.codexHome, "config.toml");
   const config = await readIfPresent(configPath);
-  const entry = await lstat9(target).catch((error) => {
+  const entry = await lstat10(target).catch((error) => {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return null;
     throw error;
@@ -22480,8 +22581,8 @@ async function installDefaultAgentRole(input) {
         if (next !== config)
           await writeFileAtomic(configPath, next);
       }
-      await rm10(target);
-      await rm10(receipt);
+      await rm11(target);
+      await rm11(receipt);
     }
     return null;
   }
@@ -22518,7 +22619,7 @@ async function linkCachedPluginAgents(input) {
     await writeManifest(input.pluginRoot, []);
     return [];
   }
-  const agentsDir = join24(input.codexHome, "agents");
+  const agentsDir = join25(input.codexHome, "agents");
   await mkdir7(agentsDir, { recursive: true });
   const previousReceipts = await readAgentModelReceipts(input.codexHome);
   const receipts = new Map;
@@ -22526,7 +22627,7 @@ async function linkCachedPluginAgents(input) {
   for (const agentPath of bundledAgents) {
     const agentFileName = basename4(agentPath);
     const agentName = agentNameFromToml2(agentFileName);
-    const linkPath = join24(agentsDir, agentFileName);
+    const linkPath = join25(agentsDir, agentFileName);
     receipts.set(agentName, await syncAgentFile({ ...input, agentName, agentPath, linkPath, previousReceipt: previousReceipts.get(agentName) }));
     linked.push({ name: agentFileName, path: linkPath, target: agentPath });
   }
@@ -22566,22 +22667,22 @@ async function syncAgentFile(input) {
   };
 }
 async function discoverBundledAgents(pluginRoot) {
-  const componentsRoot = join24(pluginRoot, "components");
+  const componentsRoot = join25(pluginRoot, "components");
   if (!await exists4(componentsRoot))
     return [];
-  const componentEntries = await readdir7(componentsRoot, { withFileTypes: true });
+  const componentEntries = await readdir8(componentsRoot, { withFileTypes: true });
   const agents = [];
   for (const entry of componentEntries) {
     if (!entry.isDirectory())
       continue;
-    const agentsRoot = join24(componentsRoot, entry.name, "agents");
+    const agentsRoot = join25(componentsRoot, entry.name, "agents");
     if (!await exists4(agentsRoot))
       continue;
-    const agentEntries = await readdir7(agentsRoot, { withFileTypes: true });
+    const agentEntries = await readdir8(agentsRoot, { withFileTypes: true });
     for (const file of agentEntries) {
       if (!file.isFile() || !file.name.endsWith(".toml"))
         continue;
-      agents.push(join24(agentsRoot, file.name));
+      agents.push(join25(agentsRoot, file.name));
     }
   }
   agents.sort();
@@ -22594,14 +22695,14 @@ async function replaceWithCopy(linkPath, target) {
 async function prepareReplacement(linkPath) {
   if (!await exists4(linkPath))
     return;
-  const entryStat = await lstat10(linkPath);
+  const entryStat = await lstat11(linkPath);
   if (entryStat.isDirectory() && !entryStat.isSymbolicLink()) {
     throw new Error(`${linkPath} already exists and is a directory; refusing to replace`);
   }
-  await rm11(linkPath, { force: true });
+  await rm12(linkPath, { force: true });
 }
 async function writeManifest(pluginRoot, agentPaths) {
-  const manifestPath = join24(pluginRoot, MANIFEST_FILE);
+  const manifestPath = join25(pluginRoot, MANIFEST_FILE);
   const payload = { agents: [...agentPaths].sort() };
   await writeFile9(manifestPath, `${JSON.stringify(payload, null, "\t")}
 `);
@@ -22611,7 +22712,7 @@ function agentNameFromToml2(fileName) {
 }
 async function exists4(path) {
   try {
-    await lstat10(path);
+    await lstat11(path);
     return true;
   } catch (error) {
     if (nodeErrorCode3(error) !== "ENOENT")
@@ -22673,10 +22774,10 @@ function agentNameFromToml3(fileName) {
 
 // packages/omo-codex/src/install/codex-marketplace.ts
 import { readFile as readFile18 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 var DEFAULT_MARKETPLACE_PATH = "packages/omo-codex/marketplace.json";
 async function readMarketplace(repoRoot, options) {
-  const marketplacePath = options?.marketplacePath ?? join25(repoRoot, DEFAULT_MARKETPLACE_PATH);
+  const marketplacePath = options?.marketplacePath ?? join26(repoRoot, DEFAULT_MARKETPLACE_PATH);
   const raw = await readFile18(marketplacePath, "utf8");
   const parsed = JSON.parse(raw);
   if (!isPlainRecord(parsed))
@@ -22695,10 +22796,10 @@ async function readMarketplace(repoRoot, options) {
 function resolvePluginSource(repoRoot, plugin, options) {
   const sourcePath = localSourcePath(options?.pathOverride ?? plugin.source);
   const relativePath = sourcePath.slice(2);
-  return join25(repoRoot, ...relativePath.split(/[\\/]/));
+  return join26(repoRoot, ...relativePath.split(/[\\/]/));
 }
 async function readPluginManifest(pluginRoot) {
-  const raw = await readFile18(join25(pluginRoot, ".codex-plugin", "plugin.json"), "utf8");
+  const raw = await readFile18(join26(pluginRoot, ".codex-plugin", "plugin.json"), "utf8");
   const parsed = JSON.parse(raw);
   if (!isPlainRecord(parsed))
     throw new Error(`${pluginRoot} plugin.json must be an object`);
@@ -22779,11 +22880,11 @@ function validateLocalSourcePath(path) {
 }
 
 // packages/omo-codex/src/install/lazycodex-version-stamp.ts
-import { readdir as readdir8, readFile as readFile19, writeFile as writeFile10 } from "node:fs/promises";
-import { join as join26 } from "node:path";
+import { readdir as readdir9, readFile as readFile19, writeFile as writeFile10 } from "node:fs/promises";
+import { join as join27 } from "node:path";
 async function readDistributionManifest(repoRoot) {
   try {
-    const parsed = JSON.parse(await readFile19(join26(repoRoot, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile19(join27(repoRoot, "package.json"), "utf8"));
     if (!isPlainRecord(parsed) || typeof parsed.version !== "string" || parsed.version.trim().length === 0)
       return;
     return {
@@ -22807,19 +22908,19 @@ function resolveLazyCodexPluginVersion(input) {
   return input.manifestVersion ?? "local";
 }
 async function stampLazyCodexPluginVersion(input) {
-  const manifestPath = join26(input.pluginRoot, ".codex-plugin", "plugin.json");
+  const manifestPath = join27(input.pluginRoot, ".codex-plugin", "plugin.json");
   const hookPaths = await readPluginHookPaths(manifestPath);
   await stampJsonVersion(manifestPath, input.version);
-  await stampJsonVersion(join26(input.pluginRoot, "package.json"), input.version);
+  await stampJsonVersion(join27(input.pluginRoot, "package.json"), input.version);
   for (const hookPath of hookPaths) {
-    await stampHookStatusMessages(join26(input.pluginRoot, hookPath), input.version);
+    await stampHookStatusMessages(join27(input.pluginRoot, hookPath), input.version);
   }
   await stampComponentVersions(input);
 }
 async function writeLazyCodexInstallSnapshot(input) {
   if (input.distributionManifest === undefined)
     return;
-  await writeFile10(join26(input.pluginRoot, "lazycodex-install.json"), `${JSON.stringify({
+  await writeFile10(join27(input.pluginRoot, "lazycodex-install.json"), `${JSON.stringify({
     packageName: input.distributionManifest.name,
     version: input.distributionManifest.version
   }, null, "\t")}
@@ -22876,16 +22977,16 @@ async function stampHookStatusMessages(path, version) {
 async function stampComponentVersions(input) {
   let entries;
   try {
-    entries = await readdir8(join26(input.pluginRoot, "components"));
+    entries = await readdir9(join27(input.pluginRoot, "components"));
   } catch (error) {
     if (error instanceof Error)
       return;
     throw error;
   }
   for (const entry of entries) {
-    const componentRoot = join26(input.pluginRoot, "components", entry);
-    await stampJsonVersion(join26(componentRoot, "package.json"), input.version);
-    await stampHookStatusMessages(join26(componentRoot, "hooks", "hooks.json"), input.version);
+    const componentRoot = join27(input.pluginRoot, "components", entry);
+    await stampJsonVersion(join27(componentRoot, "package.json"), input.version);
+    await stampHookStatusMessages(join27(componentRoot, "hooks", "hooks.json"), input.version);
   }
 }
 function stampHookGroups(hooks, version) {
@@ -22914,8 +23015,8 @@ function normalizeHookStatusVersion(version) {
 }
 
 // packages/omo-codex/src/install/codex-project-local-cleanup.ts
-import { copyFile as copyFile2, lstat as lstat11, readFile as readFile20, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname9, join as join27, resolve as resolve8 } from "node:path";
+import { copyFile as copyFile2, lstat as lstat12, readFile as readFile20, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname9, join as join28, resolve as resolve8 } from "node:path";
 var LEGACY_AGENT_CONFLICT_KEYS = ["max_threads"];
 var PROJECT_LOCAL_ARTIFACT_PATHS = [
   ".codex/hooks.json",
@@ -23018,17 +23119,17 @@ async function findProjectLocalCodexConfigs(startDirectory, codexHome) {
   if (startDirectoryStat !== null && !startDirectoryStat.isDirectory()) {
     throw new ProjectLocalCleanupStartDirectoryError(startDirectory);
   }
-  const codexHomeConfigPath = codexHome === undefined ? null : join27(resolve8(codexHome), "config.toml");
+  const codexHomeConfigPath = codexHome === undefined ? null : join28(resolve8(codexHome), "config.toml");
   let current = resolve8(startDirectory);
   const configPathsFromCwd = [];
   while (true) {
-    const configPath = join27(current, ".codex", "config.toml");
+    const configPath = join28(current, ".codex", "config.toml");
     if (await isRegularProjectLocalConfig(current, configPath)) {
       if (codexHomeConfigPath === null || resolve8(configPath) !== codexHomeConfigPath) {
         configPathsFromCwd.push(configPath);
       }
     }
-    if (await exists5(join27(current, ".git"))) {
+    if (await exists5(join28(current, ".git"))) {
       return configPathsFromCwd.length === 0 ? null : {
         projectRoot: current,
         configPaths: [...configPathsFromCwd].reverse(),
@@ -23048,7 +23149,7 @@ async function findProjectLocalCodexConfigs(startDirectory, codexHome) {
   }
 }
 async function isRegularProjectLocalConfig(directory, configPath) {
-  const codexDirStat = await maybeLstat(join27(directory, ".codex"));
+  const codexDirStat = await maybeLstat(join28(directory, ".codex"));
   if (codexDirStat === null || !codexDirStat.isDirectory() || codexDirStat.isSymbolicLink())
     return false;
   const configStat = await maybeLstat(configPath);
@@ -23068,7 +23169,7 @@ async function collectProjectLocalArtifacts(projectRoots) {
   const seenPaths = new Set;
   for (const projectRoot of projectRoots) {
     for (const relativePath of PROJECT_LOCAL_ARTIFACT_PATHS) {
-      const artifactPath = join27(projectRoot, relativePath);
+      const artifactPath = join28(projectRoot, relativePath);
       if (seenPaths.has(artifactPath))
         continue;
       const entryStat = await maybeLstat(artifactPath);
@@ -23102,7 +23203,7 @@ function formatBackupTimestamp(date) {
 }
 async function maybeLstat(path) {
   try {
-    return await lstat11(path);
+    return await lstat12(path);
   } catch (error) {
     if (nodeErrorCode4(error) === "ENOENT")
       return null;
@@ -23144,13 +23245,13 @@ function formatUnknownError(error) {
 
 // packages/omo-codex/src/install/lsp-daemon-reaper.ts
 import { createHash as createHash4 } from "node:crypto";
-import { lstat as lstat12, readFile as readFile22, readdir as readdir10, rm as rm12 } from "node:fs/promises";
+import { lstat as lstat13, readFile as readFile22, readdir as readdir11, rm as rm13 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join28, posix as posix2 } from "node:path";
+import { join as join29, posix as posix2 } from "node:path";
 
 // packages/omo-codex/src/install/lsp-daemon-reaper-attestation.ts
 import { execFile } from "node:child_process";
-import { readFile as readFile21, readdir as readdir9, readlink as readlink5 } from "node:fs/promises";
+import { readFile as readFile21, readdir as readdir10, readlink as readlink5 } from "node:fs/promises";
 import { connect } from "node:net";
 import { basename as basename5 } from "node:path";
 var PROBE_TIMEOUT_MS = 500;
@@ -23193,7 +23294,7 @@ async function attestLegacyDaemonOwnership(input, deps = {}) {
 }
 async function attestLinuxOwnership(input, deps) {
   const readFileImpl = deps.readFile ?? readFile21;
-  const readDirImpl = deps.readDir ?? readdir9;
+  const readDirImpl = deps.readDir ?? readdir10;
   const readLinkImpl = deps.readLink ?? readlink5;
   const procNetUnix = await readText(readFileImpl, "/proc/net/unix");
   if (procNetUnix === null)
@@ -23319,17 +23420,17 @@ async function readBinary(readFileImpl, path) {
 var LEGACY_EXIT_WAIT_TIMEOUT_MS = 5000;
 var LEGACY_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
 async function reapLspDaemons(codexHome, deps = {}) {
-  const daemonRoot = join28(codexHome, "codex-lsp", "daemon");
+  const daemonRoot = join29(codexHome, "codex-lsp", "daemon");
   const platform = deps.platform ?? process.platform;
   const tmpDir = deps.tmpDir ?? tmpdir();
   const probe = deps.probeLegacyJsonRpc ?? probeLegacyJsonRpcEndpoint;
   const attest = deps.attestLegacyDaemonOwnership ?? ((input) => attestLegacyDaemonOwnership(input));
   const killProcess = deps.killProcess ?? sendSigterm;
   const waitForProcessExit = deps.waitForProcessExit ?? defaultWaitForProcessExit;
-  const entries = await readdir10(daemonRoot, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir11(daemonRoot, { withFileTypes: true }).catch(() => []);
   const results = [];
   for (const entry of [...entries].sort((left, right) => left.name.localeCompare(right.name))) {
-    const versionPath = join28(daemonRoot, entry.name);
+    const versionPath = join29(daemonRoot, entry.name);
     const parsedVersion = parseVersionEntry(entry.name);
     if (parsedVersion === null || !entry.isDirectory()) {
       await removeVersionDir(versionPath);
@@ -23377,7 +23478,7 @@ function parseVersionEntry(entryName) {
   return LEGACY_VERSION_PATTERN.test(version) ? version : null;
 }
 async function readLegacyMetadata(input) {
-  const pidText = await readRegularTrimmedFile(join28(input.versionPath, "daemon.pid"));
+  const pidText = await readRegularTrimmedFile(join29(input.versionPath, "daemon.pid"));
   if (pidText === "non_regular")
     return { kind: "remove", reason: "removed non-regular legacy daemon metadata" };
   if (pidText === null)
@@ -23385,7 +23486,7 @@ async function readLegacyMetadata(input) {
   const pid = Number.parseInt(pidText, 10);
   if (!Number.isInteger(pid) || pid <= 0)
     return { kind: "remove", reason: "removed malformed legacy daemon metadata" };
-  const endpointText = await readRegularTrimmedFile(join28(input.versionPath, "daemon.endpoint"));
+  const endpointText = await readRegularTrimmedFile(join29(input.versionPath, "daemon.endpoint"));
   if (endpointText === "non_regular")
     return { kind: "remove", reason: "removed non-regular legacy daemon metadata" };
   if (endpointText === null)
@@ -23412,7 +23513,7 @@ function legacyEndpointCandidates(input) {
   return [natural, hashed];
 }
 async function readRegularTrimmedFile(path) {
-  const stats = await lstat12(path).catch(() => null);
+  const stats = await lstat13(path).catch(() => null);
   if (stats === null)
     return null;
   if (!stats.isFile())
@@ -23424,7 +23525,7 @@ function shortDigest(value) {
   return createHash4("sha256").update(value).digest("hex").slice(0, 16);
 }
 async function removeVersionDir(path) {
-  await rm12(path, { recursive: true, force: true });
+  await rm13(path, { recursive: true, force: true });
 }
 function removed(version, reason) {
   return { version, status: "removed", reason };
@@ -23464,7 +23565,7 @@ function processIsRunning(pid) {
 
 // packages/omo-codex/src/install/codex-installer-bin-dir.ts
 import { homedir } from "node:os";
-import { join as join29, resolve as resolve9 } from "node:path";
+import { join as join30, resolve as resolve9 } from "node:path";
 function resolveCodexInstallerBinDir(input) {
   const explicitBinDir = input.binDir ?? input.env?.CODEX_LOCAL_BIN_DIR;
   if (explicitBinDir !== undefined && explicitBinDir.trim().length > 0)
@@ -23473,22 +23574,22 @@ function resolveCodexInstallerBinDir(input) {
   const defaultCodexHome = resolve9(homeDir, ".codex");
   const resolvedCodexHome = resolve9(input.codexHome);
   if (resolvedCodexHome !== defaultCodexHome)
-    return join29(resolvedCodexHome, "bin");
+    return join30(resolvedCodexHome, "bin");
   return resolve9(homeDir, ".local", "bin");
 }
 
 // packages/omo-codex/src/install/codex-installed-bin-dir.ts
-import { readFile as readFile23, readdir as readdir11, writeFile as writeFile12 } from "node:fs/promises";
-import { join as join30 } from "node:path";
+import { readFile as readFile23, readdir as readdir12, writeFile as writeFile12 } from "node:fs/promises";
+import { join as join31 } from "node:path";
 var INSTALLED_BIN_DIR_MANIFEST = ".installed-bin-dir.json";
 async function writeInstalledCodexBinDir(input) {
-  await writeFile12(join30(input.pluginRoot, INSTALLED_BIN_DIR_MANIFEST), `${JSON.stringify({ binDir: input.binDir }, null, 2)}
+  await writeFile12(join31(input.pluginRoot, INSTALLED_BIN_DIR_MANIFEST), `${JSON.stringify({ binDir: input.binDir }, null, 2)}
 `);
 }
 
 // packages/omo-codex/src/install/codex-git-bash-hooks.ts
 import { readFile as readFile24, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 var WINDOWS_ONLY_GIT_BASH_HOOKS = new Set([
   "./hooks/pre-tool-use-recommending-git-bash-mcp.json",
   "./hooks/post-compact-resetting-git-bash-mcp-reminder.json"
@@ -23496,7 +23597,7 @@ var WINDOWS_ONLY_GIT_BASH_HOOKS = new Set([
 async function removeGitBashHooksOffWindows(input) {
   if (input.platform === "win32")
     return;
-  const manifestPath = join31(input.pluginRoot, ".codex-plugin", "plugin.json");
+  const manifestPath = join32(input.pluginRoot, ".codex-plugin", "plugin.json");
   const parsed = JSON.parse(await readFile24(manifestPath, "utf8"));
   if (!isPlainRecord(parsed) || !Array.isArray(parsed.hooks))
     return;
@@ -23508,12 +23609,12 @@ async function removeGitBashHooksOffWindows(input) {
 }
 
 // packages/omo-codex/src/install/install-ast-grep-sg.ts
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 
 // packages/utils/src/ast-grep/install-script.ts
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 
 // packages/utils/src/ast-grep/sg-manifest.ts
 function normalizeRuntimePlatform(platform = process.platform) {
@@ -23535,7 +23636,7 @@ var AST_GREP_BIN_DIR_ENV_KEY = "OMO_AST_GREP_BIN_DIR";
 var KILL_GRACE_MS = 1000;
 var AST_GREP_INSTALL_TIMEOUT_MS = 30000;
 function astGrepRuntimeDir(baseDir, platform = process.platform, arch = process.arch) {
-  return join32(baseDir, "runtime", "ast-grep", runtimeSlug(platform, arch));
+  return join33(baseDir, "runtime", "ast-grep", runtimeSlug(platform, arch));
 }
 function isMissingExecutable(error) {
   if (!("code" in error))
@@ -23573,7 +23674,7 @@ function defaultSpawnProcess(command, args, options) {
   };
 }
 function scriptPathForPlatform(skillDir, platform) {
-  return join32(skillDir, platform === "win32" ? "install.ps1" : "install.sh");
+  return join33(skillDir, platform === "win32" ? "install.ps1" : "install.sh");
 }
 function invocationsForPlatform(scriptPath, platform) {
   if (platform !== "win32")
@@ -23659,7 +23760,7 @@ async function installAstGrepForCodex(options) {
     return;
   const platform = options.platform ?? process.platform;
   const targetDir = astGrepRuntimeDir(options.codexHome, platform, options.arch ?? process.arch);
-  const skillDir = join33(plugin.path, "skills", "ast-grep");
+  const skillDir = join34(plugin.path, "skills", "ast-grep");
   const installer = options.installer ?? runAstGrepSkillInstall;
   try {
     const result = await installer({ platform, skillDir, targetDir });
@@ -23677,7 +23778,7 @@ async function trackCodexInstallTelemetry() {
   try {
     await Promise.resolve().then(() => init_telemetry());
     const posthog = createInstallPostHog();
-    posthog.trackActive(getPostHogDistinctId(), "install_completed");
+    posthog.trackActive("install_completed");
     await posthog.shutdown();
   } catch (error) {
     if (error instanceof Error)
@@ -23692,7 +23793,7 @@ async function runCodexInstaller(options = {}) {
   const env = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
   const repoRoot = resolve10(options.repoRoot ?? findRepoRoot({ importerDir: import.meta.dir, env }));
-  const codexHome = resolve10(options.codexHome ?? env.CODEX_HOME ?? join37(homedir2(), ".codex"));
+  const codexHome = resolve10(options.codexHome ?? env.CODEX_HOME ?? join39(homedir2(), ".codex"));
   const projectDirectory = resolve10(options.projectDirectory ?? env.OMO_CODEX_PROJECT ?? process.cwd());
   const binDir = resolveCodexInstallerBinDir({ binDir: options.binDir, codexHome, env });
   const runCommand = options.runCommand ?? defaultRunCommand;
@@ -23709,9 +23810,9 @@ async function runCodexInstaller(options = {}) {
   if (!gitBashResolution.found) {
     throw new Error(gitBashResolution.installHint);
   }
-  const codexPackageRoot = join37(repoRoot, "packages", "omo-codex");
+  const codexPackageRoot = join39(repoRoot, "packages", "omo-codex");
   const marketplace = await readMarketplace(repoRoot, {
-    marketplacePath: join37(codexPackageRoot, "marketplace.json")
+    marketplacePath: join39(codexPackageRoot, "marketplace.json")
   });
   const distributionManifest = await readDistributionManifest(repoRoot);
   const installed = [];
@@ -23756,7 +23857,7 @@ async function runCodexInstaller(options = {}) {
       if (runtimeLink !== null)
         log(`Linked ${runtimeLink.name} -> ${runtimeLink.target}`);
       else
-        log(`Warning: skipped the omo-agent-toolkit runtime wrapper because ${join37(repoRoot, "dist", "cli", "index.js")} is missing; omo-agent-toolkit ulw-loop commands will be unavailable until a package shipping dist/cli is installed`);
+        log(`Warning: skipped the omo-agent-toolkit runtime wrapper because ${join39(repoRoot, "dist", "cli", "index.js")} is missing; omo-agent-toolkit ulw-loop commands will be unavailable until a package shipping dist/cli is installed`);
     }
     pluginSources.push({ name: entry.name, sourcePath });
     installed.push(plugin);
@@ -23806,13 +23907,13 @@ async function runCodexInstaller(options = {}) {
       continue;
     log(`Warning: deferred legacy Codex LSP daemon cleanup for v${cleanup.version}: ${cleanup.reason}`);
   }
-  const marketplaceRoot = join37(codexHome, "plugins", "cache", marketplace.name);
+  const marketplaceRoot = join39(codexHome, "plugins", "cache", marketplace.name);
   await writeCachedMarketplaceManifest({
     marketplaceName: marketplace.name,
     marketplaceRoot,
     plugins: installed
   });
-  const configPath = join37(codexHome, "config.toml");
+  const configPath = join39(codexHome, "config.toml");
   await updateCodexConfig({
     configPath,
     repoRoot: codexPackageRoot,
@@ -23857,7 +23958,7 @@ function findRepoRootFromImporter(importerDir) {
   for (let depth = 0;depth <= 7; depth += 1) {
     if (isRepoRootWithCodexPlugin(current))
       return current;
-    for (const wrapperPackageRoot of [join37(current, "node_modules", "oh-my-openagent"), join37(current, "oh-my-openagent")]) {
+    for (const wrapperPackageRoot of [join39(current, "node_modules", "oh-my-openagent"), join39(current, "oh-my-openagent")]) {
       if (isRepoRootWithCodexPlugin(wrapperPackageRoot))
         return wrapperPackageRoot;
     }
@@ -23875,7 +23976,7 @@ function findRepoRoot(input) {
   return findRepoRootFromImporter(input.importerDir);
 }
 function isRepoRootWithCodexPlugin(repoRoot) {
-  return existsSync7(join37(repoRoot, "packages", "omo-codex", "plugin", ".codex-plugin", "plugin.json"));
+  return existsSync7(join39(repoRoot, "packages", "omo-codex", "plugin", ".codex-plugin", "plugin.json"));
 }
 function codexMarketplaceSource(marketplaceRoot) {
   return { sourceType: "local", source: marketplaceRoot };
@@ -24187,13 +24288,13 @@ function shellQuote(value) {
 
 // packages/omo-codex/src/install/lazycodex-manual-update.ts
 import { spawn as spawn3, spawnSync as spawnSync2 } from "node:child_process";
-import { readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname12, join as join39 } from "node:path";
+import { readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname13, join as join41 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 
 // packages/omo-codex/src/install/lazycodex-bun-global-paths.ts
-import { join as join38 } from "node:path";
+import { join as join40 } from "node:path";
 function isBunGlobalEntrypointPath(invokedPath, env) {
   if (typeof invokedPath !== "string" || invokedPath.trim().length === 0)
     return false;
@@ -24204,8 +24305,8 @@ function resolveBunGlobalRoots(env) {
   const bunInstallRoot = env.BUN_INSTALL?.trim();
   const homeRoot = env.HOME?.trim();
   return [
-    ...bunInstallRoot ? [join38(bunInstallRoot, "bin"), join38(bunInstallRoot, "install", "global", "node_modules")] : [],
-    ...homeRoot ? [join38(homeRoot, ".bun", "bin"), join38(homeRoot, ".bun", "install", "global", "node_modules")] : []
+    ...bunInstallRoot ? [join40(bunInstallRoot, "bin"), join40(bunInstallRoot, "install", "global", "node_modules")] : [],
+    ...homeRoot ? [join40(homeRoot, ".bun", "bin"), join40(homeRoot, ".bun", "install", "global", "node_modules")] : []
   ].map(normalizePathForPrefix);
 }
 function normalizePathForPrefix(path) {
@@ -24297,8 +24398,8 @@ function resolveArgs(env) {
 function resolveCurrentVersion(env) {
   if (env.LAZYCODEX_CURRENT_VERSION?.trim())
     return env.LAZYCODEX_CURRENT_VERSION.trim();
-  const pluginRoot = dirname12(dirname12(fileURLToPath(import.meta.url)));
-  return readVersionManifest(resolveInstalledVersionPath(env, pluginRoot)) ?? readVersionManifest(join39(pluginRoot, "..", "..", "..", "package.json")) ?? readVersionManifest(join39(pluginRoot, ".codex-plugin", "plugin.json"));
+  const pluginRoot = dirname13(dirname13(fileURLToPath(import.meta.url)));
+  return readVersionManifest(resolveInstalledVersionPath(env, pluginRoot)) ?? readVersionManifest(join41(pluginRoot, "..", "..", "..", "package.json")) ?? readVersionManifest(join41(pluginRoot, ".codex-plugin", "plugin.json"));
 }
 function resolveLatestVersion(env) {
   if (env.LAZYCODEX_LATEST_VERSION?.trim())
@@ -24414,11 +24515,11 @@ function compareVersions(left, right) {
 function resolveInstalledVersionPath(env, pluginRoot) {
   if (env.LAZYCODEX_INSTALLED_VERSION_FILE?.trim())
     return env.LAZYCODEX_INSTALLED_VERSION_FILE.trim();
-  return join39(pluginRoot, INSTALLED_VERSION_FILE);
+  return join41(pluginRoot, INSTALLED_VERSION_FILE);
 }
 function readVersionManifest(path) {
   try {
-    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
     if (typeof parsed === "object" && parsed !== null && "version" in parsed && typeof parsed.version === "string") {
       return parsed.version;
     }
@@ -24431,10 +24532,10 @@ function readVersionManifest(path) {
 }
 // packages/omo-codex/src/install/codex-git-bash-mcp-env.ts
 import { readFile as readFile25, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join40 } from "node:path";
+import { join as join42 } from "node:path";
 var GIT_BASH_ENV_KEY2 = "OMO_CODEX_GIT_BASH_PATH";
 async function stampGitBashMcpEnv(input) {
-  const manifestPath = join40(input.pluginRoot, ".mcp.json");
+  const manifestPath = join42(input.pluginRoot, ".mcp.json");
   if (!await fileExistsStrict(manifestPath))
     return false;
   const parsed = JSON.parse(await readFile25(manifestPath, "utf8"));
@@ -24465,7 +24566,7 @@ async function installMarketplaceLocally(options = {}) {
   return runCodexInstaller(options);
 }
 function resolveDefaultRepoRootForEntrypoint(entrypointPath) {
-  return resolve11(dirname13(entrypointPath), "..", "..", "..");
+  return resolve11(dirname14(entrypointPath), "..", "..", "..");
 }
 function resolveDefaultRepoRoot() {
   return resolveDefaultRepoRootForEntrypoint(fileURLToPath2(import.meta.url));
@@ -24481,7 +24582,7 @@ async function runLazyCodexInstallLocalCli(input) {
     return 0;
   }
   if (parsed.kind === "version") {
-    const packageJson = JSON.parse(await readFile26(join41(input.defaultRepoRoot, "package.json"), "utf8"));
+    const packageJson = JSON.parse(await readFile26(join43(input.defaultRepoRoot, "package.json"), "utf8"));
     const version = typeof packageJson.version === "string" ? packageJson.version : "unknown";
     input.log(`lazycodex-ai ${version}`);
     return 0;