oh-my-opencode 4.19.3 → 5.0.0-beta.1

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

@@ -439,7 +439,7 @@ async function readOptionalFile(path) {
 
 // components/bootstrap/src/worker.ts
 import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile14 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { dirname as dirname9, join as join22, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -449,6 +449,10 @@ import { rm as rm4 } from "node:fs/promises";
 import { dirname as dirname4, join as join7 } from "node:path";
 import { promisify } from "node:util";
 
+// ../../utils/src/ast-grep/sg-candidates.ts
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+
 // ../../utils/src/ast-grep/sg-manifest.ts
 var SG_PINNED_VERSION = "0.43.0";
 var SG_RELEASE_ASSETS = {
@@ -494,10 +498,113 @@ function sgBinaryName(platform = process.platform) {
   return normalizeRuntimePlatform(platform) === "win32" ? "sg.exe" : "sg";
 }
 
+// ../../utils/src/ast-grep/install-script.ts
+var AST_GREP_BIN_DIR_ENV_KEY = "OMO_AST_GREP_BIN_DIR";
+
+// ../../utils/src/ast-grep/types.ts
+var SG_PATH_ENV_KEY = "OMO_AST_GREP_SG_PATH";
+var SG_BINARY_NOT_FOUND = "BINARY_NOT_FOUND";
+
+// ../../utils/src/ast-grep/sg-candidates.ts
+var HOMEBREW_PREFIXES = {
+  darwin: ["/opt/homebrew/bin", "/usr/local/bin"],
+  linux: ["/home/linuxbrew/.linuxbrew/bin", "/usr/local/bin"],
+  win32: []
+};
+function nonEmptyValue(value) {
+  const trimmed = value?.trim();
+  return trimmed === undefined || trimmed.length === 0 ? null : trimmed;
+}
+function astGrepBinaryName(platform) {
+  return platform === "win32" ? "ast-grep.exe" : "ast-grep";
+}
+function candidate(tier, path) {
+  return { path, tier };
+}
+function envOverrideCandidates(env) {
+  const override = nonEmptyValue(env[SG_PATH_ENV_KEY]);
+  return override === null ? [] : [candidate("env-override", override)];
+}
+function omoRuntimeCandidates(options) {
+  const binaryName = sgBinaryName(options.platform);
+  const slug = runtimeSlug(options.platform, options.arch);
+  const paths = [];
+  if (options.runtimeDir !== undefined)
+    paths.push(join4(options.runtimeDir, binaryName));
+  const codexHome = nonEmptyValue(options.env["CODEX_HOME"]);
+  if (codexHome !== null)
+    paths.push(join4(codexHome, "runtime", "ast-grep", slug, binaryName));
+  paths.push(join4(options.homeDir, ".omo", "runtime", "ast-grep", slug, binaryName));
+  return paths.map((path) => candidate("omo-runtime", path));
+}
+function skillBinCandidates(options) {
+  const names = [astGrepBinaryName(options.platform), sgBinaryName(options.platform)];
+  const directories = [];
+  const cacheDir = nonEmptyValue(options.env[AST_GREP_BIN_DIR_ENV_KEY]);
+  if (cacheDir !== null)
+    directories.push(cacheDir);
+  if (options.packageDir !== undefined)
+    directories.push(join4(options.packageDir, "bin"));
+  return directories.flatMap((directory) => names.map((name) => candidate("skill-bin", join4(directory, name))));
+}
+function homebrewCandidates(platform) {
+  const prefixes = platform === "darwin" || platform === "linux" || platform === "win32" ? HOMEBREW_PREFIXES[platform] : [];
+  const names = [astGrepBinaryName(platform), sgBinaryName(platform)];
+  return prefixes.flatMap((prefix) => names.map((name) => candidate("homebrew", join4(prefix, name))));
+}
+function planSgCandidates(options) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const homeDir = options.homeDir ?? homedir3();
+  return {
+    afterPath: homebrewCandidates(platform),
+    beforePath: [
+      ...envOverrideCandidates(env),
+      ...omoRuntimeCandidates({ arch, env, homeDir, platform, runtimeDir: options.runtimeDir }),
+      ...skillBinCandidates({ env, packageDir: options.packageDir, platform })
+    ],
+    pathCommands: ["ast-grep", "sg"]
+  };
+}
+
+// ../../utils/src/ast-grep/sg-install-hints.ts
+var OMO_PROVISION_HINT = "Start an OMO session so the bundled ast-grep skill provisions the pinned runtime automatically";
+var ENV_OVERRIDE_HINT = `Or point ${SG_PATH_ENV_KEY} at an existing ast-grep binary`;
+var DARWIN_HINTS = [
+  "brew install ast-grep",
+  "npm install -g @ast-grep/cli",
+  "cargo install ast-grep --locked"
+];
+var LINUX_HINTS = [
+  "npm install -g @ast-grep/cli",
+  "cargo install ast-grep --locked",
+  "brew install ast-grep  # linuxbrew"
+];
+var WIN32_HINTS = [
+  "scoop install main/ast-grep",
+  "winget install ast-grep",
+  "choco install ast-grep",
+  "npm install -g @ast-grep/cli"
+];
+function platformHints(platform) {
+  if (platform === "darwin")
+    return DARWIN_HINTS;
+  if (platform === "win32")
+    return WIN32_HINTS;
+  return LINUX_HINTS;
+}
+function sgInstallHints(platform = process.platform) {
+  return [...platformHints(platform), OMO_PROVISION_HINT, ENV_OVERRIDE_HINT];
+}
+function sgBinaryNotFoundMessage(platform = process.platform) {
+  return `ast-grep binary not found for ${platform}: no candidate passed the --version probe across the env override, OMO runtime, skill bin cache, PATH, or Homebrew prefixes.`;
+}
+
 // ../../utils/src/ast-grep/sg-provisioner.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { chmod, mkdir as mkdir3, rename as rename2, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
-import { basename as basename2, isAbsolute, join as join4, relative, resolve as resolve2 } from "node:path";
+import { basename as basename2, isAbsolute, join as join5, relative, resolve as resolve2 } from "node:path";
 import { inflateRawSync } from "node:zlib";
 var DEFAULT_DOWNLOAD_TIMEOUT_MS = 60000;
 var EOCD_SIGNATURE = 101010256;
@@ -603,7 +710,7 @@ function extractStandaloneSgBinary(zip, platform) {
   const entries = listZipEntries(zip);
   const preferredNames = [`ast-grep${suffix}`, `sg${suffix}`];
   for (const preferred of preferredNames) {
-    const entry = entries.find((candidate) => zipEntryBaseName(candidate.name) === preferred);
+    const entry = entries.find((candidate2) => zipEntryBaseName(candidate2.name) === preferred);
     if (entry !== undefined)
       return readZipEntryBytes(zip, entry);
   }
@@ -623,8 +730,8 @@ async function provisionSgBinary(options) {
     throw new SgProvisionError("unsupported_platform", `ast-grep ${SG_PINNED_VERSION} has no asset for ${slug}`);
   }
   const targetDir = resolve2(options.targetDir);
-  const destination = join4(targetDir, sgBinaryName(platform));
-  const tempPath = join4(targetDir, `.sg-${randomUUID2().slice(0, 8)}.partial`);
+  const destination = join5(targetDir, sgBinaryName(platform));
+  const tempPath = join5(targetDir, `.sg-${randomUUID2().slice(0, 8)}.partial`);
   assertInsideTarget(targetDir, destination);
   assertInsideTarget(targetDir, tempPath);
   try {
@@ -649,11 +756,10 @@ async function provisionSgBinary(options) {
 // ../../utils/src/ast-grep/sg-resolver.ts
 import { execFileSync } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
-import { join as join6 } from "node:path";
 
 // ../../utils/src/runtime/which.ts
 import { accessSync, constants } from "node:fs";
-import { delimiter, join as join5 } from "node:path";
+import { delimiter, join as join6 } from "node:path";
 var runtime = globalThis;
 function isUnsafeCommandName(commandName) {
   if (commandName.includes("/") || commandName.includes("\\"))
@@ -708,7 +814,7 @@ function bunWhich(commandName) {
     return null;
   for (const pathEntry of pathEntries) {
     for (const candidateName of candidateNames) {
-      const candidatePath = join5(pathEntry, candidateName);
+      const candidatePath = join6(pathEntry, candidateName);
       if (isExecutable(candidatePath))
         return candidatePath;
     }
@@ -716,13 +822,15 @@ function bunWhich(commandName) {
   return null;
 }
 
-// ../../utils/src/ast-grep/types.ts
-var SG_PATH_ENV_KEY = "OMO_AST_GREP_SG_PATH";
-
 // ../../utils/src/ast-grep/sg-resolver.ts
-function nonEmptyValue(value) {
-  const trimmed = value?.trim();
-  return trimmed === undefined || trimmed.length === 0 ? null : trimmed;
+var SG_VERSION_PROBE_TIMEOUT_MS = 5000;
+var cacheEntry = null;
+function cacheFingerprint(options, plan) {
+  return JSON.stringify([
+    options.platform ?? process.platform,
+    options.arch ?? process.arch,
+    plan.beforePath.map((candidate2) => candidate2.path)
+  ]);
 }
 function defaultFileExists(filePath) {
   if (!existsSync(filePath))
@@ -730,9 +838,7 @@ function defaultFileExists(filePath) {
   try {
     const stats = statSync(filePath);
     return stats.isFile() && stats.size > 0;
-  } catch (error) {
-    if (error instanceof Error)
-      return false;
+  } catch {
     return false;
   }
 }
@@ -740,53 +846,79 @@ function defaultVersionProbe(binaryPath) {
   return String(execFileSync(binaryPath, ["--version"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"],
-    timeout: 5000
+    timeout: SG_VERSION_PROBE_TIMEOUT_MS
   }));
 }
-function isAstGrepVersionOutput(output) {
-  return output.toLowerCase().includes("ast-grep");
-}
-function hasAstGrepVersion(binaryPath, runVersionProbeSync) {
+function probePasses(binaryPath, deps) {
   try {
-    return isAstGrepVersionOutput(runVersionProbeSync(binaryPath));
-  } catch (error) {
-    if (error instanceof Error)
-      return false;
+    return deps.runVersionProbeSync(binaryPath).toLowerCase().includes("ast-grep");
+  } catch {
     return false;
   }
 }
-function pathCommandCandidates() {
-  return ["ast-grep", "sg"];
+function acceptsCandidate(binaryPath, deps) {
+  return deps.fileExists(binaryPath) && probePasses(binaryPath, deps);
 }
-function findSgBinarySync(options = {}) {
-  const env = options.env ?? process.env;
-  const platform = options.platform ?? process.platform;
-  const fileExists = options.fileExists ?? defaultFileExists;
-  const runVersionProbeSync = options.runVersionProbeSync ?? defaultVersionProbe;
-  const which = options.which ?? bunWhich;
+function firstAccepted(candidates, deps) {
+  for (const candidate2 of candidates) {
+    if (acceptsCandidate(candidate2.path, deps))
+      return { found: true, path: candidate2.path, tier: candidate2.tier };
+  }
+  return null;
+}
+function pathCandidates(commands, deps) {
+  const resolved = [];
+  for (const commandName of commands) {
+    const found = deps.which(commandName);
+    if (found !== null)
+      resolved.push({ path: found, tier: "path" });
+  }
+  return resolved;
+}
+function notFound(platform) {
+  return {
+    error: { code: SG_BINARY_NOT_FOUND, hints: sgInstallHints(platform), message: sgBinaryNotFoundMessage(platform) },
+    found: false
+  };
+}
+function cacheIsStillValid(resolution, deps, revalidate) {
+  if (!resolution.found)
+    return false;
+  if (!deps.fileExists(resolution.path))
+    return false;
+  return !revalidate || probePasses(resolution.path, deps);
+}
+function resolverDeps(options) {
+  return {
+    fileExists: options.fileExists ?? defaultFileExists,
+    platform: options.platform ?? process.platform,
+    runVersionProbeSync: options.runVersionProbeSync ?? defaultVersionProbe,
+    which: options.which ?? bunWhich
+  };
+}
+function resolveSgBinarySync(options = {}) {
+  const deps = resolverDeps(options);
+  const useCache = options.cache ?? true;
   try {
-    const envOverride = nonEmptyValue(env[SG_PATH_ENV_KEY]);
-    if (envOverride !== null && fileExists(envOverride))
-      return envOverride;
-    if (options.runtimeDir !== undefined) {
-      const runtimeCandidate = join6(options.runtimeDir, sgBinaryName(platform));
-      if (fileExists(runtimeCandidate))
-        return runtimeCandidate;
-    }
-    for (const commandName of pathCommandCandidates()) {
-      const pathCandidate = which(commandName);
-      if (pathCandidate === null || !fileExists(pathCandidate))
-        continue;
-      if (commandName !== "sg" || hasAstGrepVersion(pathCandidate, runVersionProbeSync))
-        return pathCandidate;
+    const plan = planSgCandidates(options);
+    const fingerprint = cacheFingerprint(options, plan);
+    if (useCache && cacheEntry !== null && cacheEntry.fingerprint === fingerprint) {
+      if (cacheIsStillValid(cacheEntry.resolution, deps, options.revalidate ?? false))
+        return cacheEntry.resolution;
+      cacheEntry = null;
     }
-    return null;
-  } catch (error) {
-    if (error instanceof Error)
-      return null;
-    return null;
+    const resolution = firstAccepted(plan.beforePath, deps) ?? firstAccepted(pathCandidates(plan.pathCommands, deps), deps) ?? firstAccepted(plan.afterPath, deps) ?? notFound(deps.platform);
+    if (useCache && resolution.found)
+      cacheEntry = { fingerprint, resolution };
+    return resolution;
+  } catch {
+    return notFound(deps.platform);
   }
 }
+function findSgBinarySync(options = {}) {
+  const resolution = resolveSgBinarySync(options);
+  return resolution.found ? resolution.path : null;
+}
 
 // components/bootstrap/src/provision.ts
 var SG_PROVISION_COMPONENT = "ast_grep";
@@ -1161,8 +1293,8 @@ function findUnquotedCharacter(line, target, startIndex) {
   }
   return -1;
 }
-function tomlPathMatches(candidate, target) {
-  return candidate.length === target.length && candidate.every((part, index) => part === target[index]);
+function tomlPathMatches(candidate2, target) {
+  return candidate2.length === target.length && candidate2.every((part, index) => part === target[index]);
 }
 function replaceTomlAssignmentValue(line, assignmentIndex, value) {
   const newline = line.endsWith(`
@@ -1420,7 +1552,7 @@ var MANAGED_REASONING_DEFAULT_UPGRADES = new Map([
     "explorer",
     [
       {
-        previous: { model: "gpt-5.4-mini", effort: "low" },
+        previous: { model: "gpt-5.6-luna-fast", effort: "low" },
         current: { model: "gpt-5.6-terra", effort: "medium" }
       },
       {
@@ -1433,7 +1565,7 @@ var MANAGED_REASONING_DEFAULT_UPGRADES = new Map([
     "librarian",
     [
       {
-        previous: { model: "gpt-5.4-mini", effort: "low" },
+        previous: { model: "gpt-5.6-luna-fast", effort: "low" },
         current: { model: "gpt-5.6-terra", effort: "medium" }
       },
       {
@@ -2027,6 +2159,7 @@ var LEGACY_CODEX_COMPONENT_BINS = [
   { name: "codex-telemetry", component: "telemetry" },
   { name: "codex-ultrawork", component: "ultrawork" }
 ];
+var LEGACY_CODEX_COMPONENT_BIN_NAMES = LEGACY_CODEX_COMPONENT_BINS.map((entry) => entry.name);
 async function removeLegacyCodexComponentBins(binDir, platform) {
   for (const entry of LEGACY_CODEX_COMPONENT_BINS) {
     const linkPath = join12(binDir, platform === "win32" ? `${entry.name}.cmd` : entry.name);
@@ -2082,7 +2215,7 @@ function isNodeErrorWithCode2(error) {
 // ../src/install/codex-cache-runtime-wrapper.ts
 import { join as join13 } from "node:path";
 var RUNTIME_WRAPPER_MARKER = "OMO_GENERATED_RUNTIME_WRAPPER";
-function posixRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
+function posixRuntimeWrapper(binName, cliPath, codexHome, binDir, nodeCliPath) {
   const ulwLoopBin = toPosixPath(join13(binDir, "omo-ulw-loop"));
   const nodeCli = escapePosixDoubleQuoted(toPosixPath(nodeCliPath));
   const escapedCliPath = escapePosixDoubleQuoted(toPosixPath(cliPath));
@@ -2092,6 +2225,8 @@ function posixRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
     "#!/bin/sh",
     `# ${RUNTIME_WRAPPER_MARKER}`,
     `export CODEX_HOME="\${CODEX_HOME:-${escapedCodexHome}}"`,
+    `export OMO_INVOCATION_NAME=${binName}`,
+    "export OMO_EDITION=codex",
     'if [ "$1" = "ulw-loop" ] && [ -x "' + escapedUlwLoopBin + '" ]; then',
     "  shift",
     '  exec "' + escapedUlwLoopBin + '" ulw-loop "$@"',
@@ -2115,11 +2250,11 @@ function posixRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
     `  if [ -f "${nodeCli}" ] && command -v node >/dev/null 2>&1; then`,
     `    exec node "${nodeCli}" "$@"`,
     "  fi",
-    `  echo "omo: bun runtime not found (checked PATH, ~/.bun/bin, /opt/homebrew/bin, /usr/local/bin) and the node fallback CLI is missing at ${nodeCli}; install bun from https://bun.sh, or reinstall omo and force the fallback with OMO_RUNTIME=node" >&2`,
+    `  echo "${binName}: bun runtime not found (checked PATH, ~/.bun/bin, /opt/homebrew/bin, /usr/local/bin) and the node fallback CLI is missing at ${nodeCli}; install bun from https://bun.sh, or reinstall ${binName} and force the fallback with OMO_RUNTIME=node" >&2`,
     "  exit 127",
     "fi",
     `if [ ! -f "${escapedCliPath}" ]; then`,
-    `  echo "omo: runtime target missing at ${escapedCliPath}; reinstall with: npx --yes lazycodex-ai@latest install --no-tui" >&2`,
+    `  echo "${binName}: runtime target missing at ${escapedCliPath}; reinstall with: npx --yes lazycodex-ai@latest install --no-tui" >&2`,
     "  exit 1",
     "fi",
     `exec "$BUN_BINARY" "${escapedCliPath}" "$@"`,
@@ -2127,12 +2262,14 @@ function posixRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
   ].join(`
 `);
 }
-function windowsRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
+function windowsRuntimeWrapper(binName, cliPath, codexHome, binDir, nodeCliPath) {
   const ulwLoopBin = join13(binDir, "omo-ulw-loop.cmd");
   return [
     "@echo off",
     `rem ${RUNTIME_WRAPPER_MARKER}`,
     `if not defined CODEX_HOME set "CODEX_HOME=${codexHome}"`,
+    `set "OMO_INVOCATION_NAME=${binName}"`,
+    'set "OMO_EDITION=codex"',
     ...windowsNodeDiscoveryLines(),
     `if "%~1"=="ulw-loop" if exist "${ulwLoopBin}" (`,
     "  shift /1",
@@ -2150,11 +2287,11 @@ function windowsRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
     `    "%OMO_NODE_BINARY%" "${nodeCliPath}" %*`,
     "    exit /b %ERRORLEVEL%",
     "  )",
-    `  echo omo: bun runtime not found, no Node runtime was discovered from NODE_REPL_NODE_PATH or PATH, or the node fallback CLI is missing at ${nodeCliPath}; install bun from https://bun.sh or rerun LazyCodex install from Codex Desktop 1>&2`,
+    `  echo ${binName}: bun runtime not found, no Node runtime was discovered from NODE_REPL_NODE_PATH or PATH, or the node fallback CLI is missing at ${nodeCliPath}; install bun from https://bun.sh or rerun LazyCodex install from Codex Desktop 1>&2`,
     "  exit /b 127",
     ")",
     `if not exist "${cliPath}" (`,
-    `  echo omo: runtime target missing at ${cliPath}; reinstall with: npx --yes lazycodex-ai@latest install --no-tui 1>&2`,
+    `  echo ${binName}: runtime target missing at ${cliPath}; reinstall with: npx --yes lazycodex-ai@latest install --no-tui 1>&2`,
     "  exit /b 1",
     ")",
     `"%BUN_BINARY%" "${cliPath}" %*`,
@@ -2170,7 +2307,14 @@ function escapePosixDoubleQuoted(value) {
 }
 
 // ../src/install/codex-cache-bins.ts
-var RESERVED_NESTED_BIN_NAMES = new Set(["omo", "lazycodex", "lazycodex-ai", "oh-my-opencode", "oh-my-openagent"]);
+var RESERVED_NESTED_BIN_NAMES = new Set([
+  "omo",
+  "omo-agent-toolkit",
+  "lazycodex",
+  "lazycodex-ai",
+  "oh-my-opencode",
+  "oh-my-openagent"
+]);
 async function linkCachedPluginBins(input) {
   const binLinks = await discoverPackageBins(input.pluginRoot);
   const platform = input.platform ?? process.platform;
@@ -2186,20 +2330,26 @@ async function linkCachedPluginBins(input) {
 }
 async function linkRootRuntimeBin(input) {
   const cliPath = join14(input.repoRoot, "dist", "cli", "index.js");
-  if (!await isFile2(cliPath))
+  const platform = input.platform ?? process.platform;
+  const legacyPath = join14(input.binDir, platform === "win32" ? "omo.cmd" : "omo");
+  if (!await isFile2(cliPath)) {
+    await removeGeneratedRuntimeWrapper(legacyPath);
     return null;
+  }
+  const binName = "omo-agent-toolkit";
   const nodeCliPath = join14(input.repoRoot, "dist", "cli-node", "index.js");
-  const platform = input.platform ?? process.platform;
   await mkdir5(input.binDir, { recursive: true });
   if (platform === "win32") {
-    const linkPath2 = join14(input.binDir, "omo.cmd");
-    await replaceRuntimeWrapper(linkPath2, windowsRuntimeWrapper(cliPath, input.codexHome, input.binDir, nodeCliPath));
-    return { name: "omo", path: linkPath2, target: cliPath };
+    const linkPath2 = join14(input.binDir, `${binName}.cmd`);
+    await replaceRuntimeWrapper(linkPath2, windowsRuntimeWrapper(binName, cliPath, input.codexHome, input.binDir, nodeCliPath));
+    await removeGeneratedRuntimeWrapper(legacyPath);
+    return { name: binName, path: linkPath2, target: cliPath };
   }
-  const linkPath = join14(input.binDir, "omo");
-  await replaceRuntimeWrapper(linkPath, posixRuntimeWrapper(cliPath, input.codexHome, input.binDir, nodeCliPath));
+  const linkPath = join14(input.binDir, binName);
+  await replaceRuntimeWrapper(linkPath, posixRuntimeWrapper(binName, cliPath, input.codexHome, input.binDir, nodeCliPath));
   await chmod2(linkPath, 493);
-  return { name: "omo", path: linkPath, target: cliPath };
+  await removeGeneratedRuntimeWrapper(legacyPath);
+  return { name: binName, path: linkPath, target: cliPath };
 }
 async function linkCachedPluginBin(binDir, link, platform) {
   if (platform === "win32") {
@@ -2302,6 +2452,29 @@ async function replaceRuntimeWrapper(linkPath, content) {
   await rm9(linkPath, { force: true });
   await writeFile5(linkPath, content);
 }
+async function removeGeneratedRuntimeWrapper(path) {
+  try {
+    const entry = await lstat7(path);
+    if (!entry.isFile() && !entry.isSymbolicLink())
+      return;
+    const content = await readGeneratedWrapperContent(path);
+    if (content.includes(RUNTIME_WRAPPER_MARKER))
+      await rm9(path, { force: true });
+  } catch (error) {
+    if (isNodeErrorWithCode(error) && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+async function readGeneratedWrapperContent(path) {
+  try {
+    return await readFile8(path, "utf8");
+  } catch (error) {
+    if (isNodeErrorWithCode(error) && (error.code === "ENOENT" || error.code === "EISDIR"))
+      return "";
+    throw error;
+  }
+}
 async function existingNonRuntimeWrapper(path) {
   try {
     const stat5 = await lstat7(path);
@@ -2826,6 +2999,24 @@ function stripUnquotedInlineComment3(line) {
 
 // ../src/install/codex-config-reasoning.ts
 var MANAGED_KEYS = ["model", "model_context_window", "model_reasoning_effort", "plan_mode_reasoning_effort"];
+var CODEX_REASONING_BY_UNIFIED_LEVEL = {
+  off: "none",
+  none: "none",
+  minimal: "minimal",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh",
+  max: "max"
+};
+function applyReasoningOverride(catalog, reasoning) {
+  if (reasoning === undefined)
+    return catalog;
+  const wireEffort = CODEX_REASONING_BY_UNIFIED_LEVEL[reasoning.trim().toLowerCase()];
+  if (wireEffort === undefined)
+    return catalog;
+  return { ...catalog, current: { ...catalog.current, modelReasoningEffort: wireEffort } };
+}
 function ensureCodexReasoningConfig(config, catalog) {
   const current = readRootReasoningSettings(config);
   if (Object.keys(current).length > 0 && !matchesProfile(current, catalog.current) && !catalog.managedProfiles.some((profile) => matchesProfile(current, profile))) {
@@ -3166,7 +3357,7 @@ async function updateCodexConfig(input) {
   config = ensureFeatureEnabled(config, "plugin_hooks");
   config = ensureFeatureEnabled(config, "multi_agent");
   config = removeUnsupportedCodexMultiAgentModeConfig(config);
-  config = ensureCodexReasoningConfig(config, await readCodexModelCatalog(input.repoRoot));
+  config = ensureCodexReasoningConfig(config, applyReasoningOverride(await readCodexModelCatalog(input.repoRoot), input.reasoning));
   config = ensureCodexMultiAgentV2Config(config, {
     multiAgentVersion: resolveCodexMultiAgentVersion(config, input.configPath)
   });
@@ -3356,13 +3547,13 @@ async function exists4(path) {
 }
 
 // ../src/install/codex-installer-bin-dir.ts
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { join as join20, resolve as resolve6 } from "node:path";
 function resolveCodexInstallerBinDir(input) {
   const explicitBinDir = input.binDir ?? input.env?.CODEX_LOCAL_BIN_DIR;
   if (explicitBinDir !== undefined && explicitBinDir.trim().length > 0)
     return resolve6(explicitBinDir.trim());
-  const homeDir = input.homeDir ?? homedir3();
+  const homeDir = input.homeDir ?? homedir4();
   const defaultCodexHome = resolve6(homeDir, ".codex");
   const resolvedCodexHome = resolve6(input.codexHome);
   if (resolvedCodexHome !== defaultCodexHome)
@@ -3389,23 +3580,23 @@ function resolveGitBash(input) {
     }
     return missingGitBash(checkedPaths);
   }
-  for (const candidate of [
+  for (const candidate2 of [
     { path: PROGRAM_FILES_GIT_BASH, source: "program-files" },
     { path: PROGRAM_FILES_X86_GIT_BASH, source: "program-files-x86" }
   ]) {
-    checkedPaths.push(candidate.path);
-    if (input.exists(candidate.path))
-      return { found: true, path: candidate.path, source: candidate.source, checkedPaths };
+    checkedPaths.push(candidate2.path);
+    if (input.exists(candidate2.path))
+      return { found: true, path: candidate2.path, source: candidate2.source, checkedPaths };
   }
   for (const pathCandidate of input.where("bash")) {
-    const candidate = pathCandidate.trim();
-    if (candidate.length === 0)
+    const candidate2 = pathCandidate.trim();
+    if (candidate2.length === 0)
       continue;
-    checkedPaths.push(candidate);
-    if (isKnownNonGitBashLauncher(candidate))
+    checkedPaths.push(candidate2);
+    if (isKnownNonGitBashLauncher(candidate2))
       continue;
-    if (isBashExePath(candidate) && input.exists(candidate))
-      return { found: true, path: candidate, source: "path", checkedPaths };
+    if (isBashExePath(candidate2) && input.exists(candidate2))
+      return { found: true, path: candidate2, source: "path", checkedPaths };
   }
   return missingGitBash(checkedPaths);
 }
@@ -3644,18 +3835,18 @@ async function linkRuntimeWrapperStep(options, binDir, degraded) {
     if (linked !== null)
       return;
     degraded.push({
-      component: "omo-cli",
-      hint: "use npx lazycodex-ai for the omo CLI",
+      component: "omo-agent-toolkit",
+      hint: "use npx lazycodex-ai for the omo-agent-toolkit CLI",
       reason: "marketplace payload has no dist/cli"
     });
-    await appendBootstrapLog(options.pluginData, options.now ?? Date.now(), "omo-cli-degraded", {
-      warning: `Warning: skipped the omo runtime wrapper because ${cliPath} is missing; omo ulw-loop commands will be unavailable until a package shipping dist/cli is installed`
+    await appendBootstrapLog(options.pluginData, options.now ?? Date.now(), "omo-agent-toolkit-degraded", {
+      warning: `Warning: skipped the omo-agent-toolkit runtime wrapper because ${cliPath} is missing; omo-agent-toolkit ulw-loop commands will be unavailable until a package shipping dist/cli is installed`
     });
   } catch (error) {
     degraded.push({
-      component: "omo-cli",
+      component: "omo-agent-toolkit",
       hint: BOOTSTRAP_DOCTOR_HINT,
-      reason: `failed to link the omo runtime wrapper into ${binDir}: ${errorMessage(error)}`
+      reason: `failed to link the omo-agent-toolkit runtime wrapper into ${binDir}: ${errorMessage(error)}`
     });
   }
 }
@@ -3734,7 +3925,7 @@ function resolvePluginDataRoot(env) {
   const fromEnv = env["PLUGIN_DATA"]?.trim();
   if (fromEnv !== undefined && fromEnv.length > 0)
     return fromEnv;
-  return join22(homedir4(), ".local", "share", "lazycodex");
+  return join22(homedir5(), ".local", "share", "lazycodex");
 }
 async function readPluginVersion(pluginRoot) {
   try {
@@ -3783,6 +3974,9 @@ async function runBootstrapWorker(options = {}) {
   const platform = options.platform ?? process.platform;
   const flags = parseWorkerFlags(options.argv ?? []);
   const steps = options.steps ?? defaultWorkerSteps();
+  if (flags.only !== undefined && !steps.some((step) => step.name === flags.only)) {
+    throw new Error(`unknown --only flag value: ${flags.only}`);
+  }
   const pluginRoot = resolvePluginRoot(env);
   const pluginData = resolvePluginDataRoot(env);
   const statePath = resolveBootstrapStatePath(pluginData);
@@ -3858,10 +4052,10 @@ function parseDegradedEntries(raw) {
   if (!Array.isArray(raw))
     return;
   const entries = [];
-  for (const candidate of raw) {
-    if (typeof candidate !== "object" || candidate === null)
+  for (const candidate2 of raw) {
+    if (typeof candidate2 !== "object" || candidate2 === null)
       continue;
-    const record = candidate;
+    const record = candidate2;
     if (typeof record["component"] !== "string" || typeof record["reason"] !== "string")
       continue;
     entries.push({

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

@@ -8,7 +8,7 @@
 						"command": "node \"${PLUGIN_ROOT}/components/bootstrap/dist/cli.js\" hook session-start",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\bootstrap.ps1\"",
 						"timeout": 30,
-						"statusMessage": "(OmO 4.19.3) Checking Bootstrap Provisioning"
+						"statusMessage": "(OmO 5.0.0-beta.1) Checking Bootstrap Provisioning"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-bootstrap",
-	"version": "4.19.3",
+	"version": "5.0.0-beta.1",
 	"description": "Codex SessionStart bootstrap component that provisions LazyCodex runtime dependencies from a detached worker.",
 	"type": "module",
 	"private": true,