oh-my-opencode 4.12.1 → 4.13.0

package/dist/cli-node/index.js

@@ -2146,7 +2146,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "oh-my-opencode",
-    version: "4.12.1",
+    version: "4.13.0",
     description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
     main: "./dist/index.js",
     types: "dist/index.d.ts",
@@ -2227,7 +2227,8 @@ var init_package = __esm(() => {
       "build:cli-node": "bun run script/build-cli-node.ts",
       "build:codex-install": "bun run script/build-codex-install.ts",
       "build:codex-plugin": "npm --prefix packages/omo-codex/plugin ci && bun run --cwd packages/omo-codex/plugin build",
-      "build:shared-skills-assets": "rm -rf dist/skills && cp -R packages/shared-skills/skills dist/skills",
+      "build:materialize-frontend": "node packages/omo-codex/plugin/scripts/materialize-shared-upstreams.mjs --strict",
+      "build:shared-skills-assets": "bun run build:materialize-frontend && rm -rf dist/skills && cp -R packages/shared-skills/skills dist/skills",
       "build:lsp-tools-mcp": "npm --prefix packages/lsp-tools-mcp ci && npm --prefix packages/lsp-tools-mcp run build",
       "build:lsp-daemon": "npm --prefix packages/lsp-daemon ci && npm --prefix packages/lsp-daemon run build",
       "build:node-require-shim": "bun run script/patch-node-require-shim.ts",
@@ -2236,6 +2237,7 @@ var init_package = __esm(() => {
       "build:schema": "bun run script/build-schema.ts",
       "build:model-capabilities": "bun run script/build-model-capabilities.ts",
       clean: "rm -rf dist",
+      prepack: "bun run build:materialize-frontend",
       prepare: "bun run build",
       postinstall: "node postinstall.mjs",
       prepublishOnly: "bun run clean && bun run build:lsp-tools-mcp && bun run build:lsp-daemon && bun run build",
@@ -2316,18 +2318,18 @@ var init_package = __esm(() => {
       typescript: "^6.0.3"
     },
     optionalDependencies: {
-      "oh-my-opencode-darwin-arm64": "4.12.1",
-      "oh-my-opencode-darwin-x64": "4.12.1",
-      "oh-my-opencode-darwin-x64-baseline": "4.12.1",
-      "oh-my-opencode-linux-arm64": "4.12.1",
-      "oh-my-opencode-linux-arm64-musl": "4.12.1",
-      "oh-my-opencode-linux-x64": "4.12.1",
-      "oh-my-opencode-linux-x64-baseline": "4.12.1",
-      "oh-my-opencode-linux-x64-musl": "4.12.1",
-      "oh-my-opencode-linux-x64-musl-baseline": "4.12.1",
-      "oh-my-opencode-windows-arm64": "4.12.1",
-      "oh-my-opencode-windows-x64": "4.12.1",
-      "oh-my-opencode-windows-x64-baseline": "4.12.1"
+      "oh-my-opencode-darwin-arm64": "4.13.0",
+      "oh-my-opencode-darwin-x64": "4.13.0",
+      "oh-my-opencode-darwin-x64-baseline": "4.13.0",
+      "oh-my-opencode-linux-arm64": "4.13.0",
+      "oh-my-opencode-linux-arm64-musl": "4.13.0",
+      "oh-my-opencode-linux-x64": "4.13.0",
+      "oh-my-opencode-linux-x64-baseline": "4.13.0",
+      "oh-my-opencode-linux-x64-musl": "4.13.0",
+      "oh-my-opencode-linux-x64-musl-baseline": "4.13.0",
+      "oh-my-opencode-windows-arm64": "4.13.0",
+      "oh-my-opencode-windows-x64": "4.13.0",
+      "oh-my-opencode-windows-x64-baseline": "4.13.0"
     },
     overrides: {
       hono: "^4.12.18",
@@ -7379,6 +7381,28 @@ var init_workspace = () => {};
 var init_guidance = __esm(() => {
   init_workspace();
 });
+
+// packages/utils/src/codegraph/node-support.ts
+function evaluateCodegraphNodeSupport(options = {}) {
+  const nodeVersion = options.nodeVersion ?? process.versions.node;
+  const env = options.env ?? process.env;
+  const override = (env[CODEGRAPH_UNSAFE_NODE_ENV]?.trim().length ?? 0) > 0;
+  const major = parseNodeMajor(nodeVersion);
+  if (major >= CODEGRAPH_BLOCKED_NODE_MAJOR) {
+    return { major, override, reason: "too-new", supported: override };
+  }
+  if (major < CODEGRAPH_MIN_NODE_MAJOR) {
+    return { major, override, reason: "too-old", supported: override };
+  }
+  return { major, override, supported: true };
+}
+function parseNodeMajor(version) {
+  const normalized = version.startsWith("v") ? version.slice(1) : version;
+  const major = Number.parseInt(normalized.split(".")[0] ?? "", 10);
+  return Number.isNaN(major) ? 0 : major;
+}
+var CODEGRAPH_MIN_NODE_MAJOR = 20, CODEGRAPH_BLOCKED_NODE_MAJOR = 25, CODEGRAPH_UNSAFE_NODE_ENV = "CODEGRAPH_ALLOW_UNSAFE_NODE", CODEGRAPH_NODE_BIN_ENV = "CODEGRAPH_NODE_BIN";
+
 // packages/utils/src/codegraph/manifest.ts
 var init_manifest = () => {};
 
@@ -7392,10 +7416,85 @@ var init_provision = __esm(() => {
 });
 
 // packages/utils/src/codegraph/resolve.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { basename as basename2, dirname as dirname2, join as join7 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
-var requireFromHere;
+function defaultNodeVersion(nodePath) {
+  if (nodePath === process.execPath && isNodeExecutableName(nodePath))
+    return process.versions.node;
+  try {
+    const result = spawnSync(nodePath, ["--version"], {
+      encoding: "utf8",
+      timeout: 2000,
+      windowsHide: true
+    });
+    if (result.error !== undefined || result.status !== 0)
+      return null;
+    const version = `${result.stdout}
+${result.stderr}`.trim().split(/\s+/)[0];
+    return version === undefined || version.length === 0 ? null : version;
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+function isNodeExecutableName(filePath) {
+  const executable = basename2(filePath).toLowerCase();
+  return executable === "node" || executable === "node.exe" || /^node\d+(\.exe)?$/.test(executable);
+}
+function looksLikePath(command) {
+  return command.includes("/") || command.includes("\\") || /^[a-zA-Z]:/.test(command);
+}
+function resolveConfiguredNodeRuntime(configured, fileExists, which2) {
+  if (looksLikePath(configured))
+    return fileExists(configured) ? configured : null;
+  return which2(configured);
+}
+function supportsCodegraphNodeRuntime(nodePath, env, nodeVersion) {
+  const version = nodeVersion(nodePath);
+  if (version === null)
+    return false;
+  return evaluateCodegraphNodeSupport({ env, nodeVersion: version }).supported;
+}
+function defaultNodeRuntime(env, fileExists, which2, nodeVersion) {
+  const configured = env[CODEGRAPH_NODE_BIN_ENV]?.trim();
+  if (configured !== undefined && configured.length > 0) {
+    const resolved = resolveConfiguredNodeRuntime(configured, fileExists, which2);
+    return resolved !== null && supportsCodegraphNodeRuntime(resolved, env, nodeVersion) ? resolved : null;
+  }
+  const candidates = [
+    ...isNodeExecutableName(process.execPath) ? [process.execPath] : [],
+    ...CODEGRAPH_NODE_CANDIDATES.map((commandName) => which2(commandName)).filter((candidate) => candidate !== null)
+  ];
+  const seen = new Set;
+  for (const candidate of candidates) {
+    if (seen.has(candidate))
+      continue;
+    seen.add(candidate);
+    if (supportsCodegraphNodeRuntime(candidate, env, nodeVersion))
+      return candidate;
+  }
+  return null;
+}
+function resolveCodegraphNodeRuntime(options = {}) {
+  const env = options.env ?? process.env;
+  return defaultNodeRuntime(env, options.fileExists ?? existsSync7, options.which ?? bunWhich, options.nodeVersion ?? defaultNodeVersion);
+}
+function resolveCodegraphNodeSupport(options = {}) {
+  const env = options.env ?? process.env;
+  const nodeVersion = options.nodeVersion ?? defaultNodeVersion;
+  const runtime3 = resolveCodegraphNodeRuntime({ ...options, env, nodeVersion });
+  if (runtime3 === null) {
+    return evaluateCodegraphNodeSupport({ env, nodeVersion: "0.0.0" });
+  }
+  return evaluateCodegraphNodeSupport({ env, nodeVersion: nodeVersion(runtime3) ?? "0.0.0" });
+}
+var CODEGRAPH_NODE_CANDIDATES, requireFromHere;
 var init_resolve2 = __esm(() => {
   init_which();
+  CODEGRAPH_NODE_CANDIDATES = ["node24", "node22", "node20", "node"];
   requireFromHere = createRequire2(import.meta.url);
 });
 
@@ -9941,6 +10040,11 @@ var init_runtime_fallback_error_classifier = __esm(() => {
   init_runtime_fallback_error_shape();
 });
 
+// packages/model-core/src/provider-exhaustion-fallback-policy.ts
+var init_provider_exhaustion_fallback_policy = __esm(() => {
+  init_runtime_fallback_error_classifier();
+});
+
 // packages/model-core/src/runtime-fallback-model.ts
 var init_runtime_fallback_model = __esm(() => {
   init_model_string_parser();
@@ -10369,6 +10473,7 @@ var init_src2 = __esm(() => {
   init_runtime_fallback_auto_retry_signal();
   init_runtime_fallback_error_classifier();
   init_runtime_fallback_error_shape();
+  init_provider_exhaustion_fallback_policy();
   init_runtime_fallback_model();
   init_model_capabilities();
   init_context_limit_resolver();
@@ -10980,9 +11085,9 @@ var init_migration2 = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/opencode-config-dir.ts
-import { existsSync as existsSync8, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync9, realpathSync as realpathSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join8, posix, resolve as resolve4, win32 } from "node:path";
+import { join as join9, posix, resolve as resolve4, win32 } from "node:path";
 function isDevBuild(version) {
   if (!version)
     return false;
@@ -10992,15 +11097,15 @@ function getTauriConfigDir(identifier) {
   const platform = process.platform;
   switch (platform) {
     case "darwin":
-      return join8(homedir3(), "Library", "Application Support", identifier);
+      return join9(homedir3(), "Library", "Application Support", identifier);
     case "win32": {
-      const appData = process.env.APPDATA || join8(homedir3(), "AppData", "Roaming");
+      const appData = process.env.APPDATA || join9(homedir3(), "AppData", "Roaming");
       return win32.join(appData, identifier);
     }
     case "linux":
     default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join8(homedir3(), ".config");
-      return join8(xdgConfig, identifier);
+      const xdgConfig = process.env.XDG_CONFIG_HOME || join9(homedir3(), ".config");
+      return join9(xdgConfig, identifier);
     }
   }
 }
@@ -11009,7 +11114,7 @@ function resolveConfigPath(pathValue) {
     return posix.normalize(pathValue);
   }
   const resolvedPath = resolve4(pathValue);
-  if (!existsSync8(resolvedPath))
+  if (!existsSync9(resolvedPath))
     return resolvedPath;
   try {
     return realpathSync3(resolvedPath);
@@ -11043,8 +11148,8 @@ function getWslLinuxHomeDir(windowsConfigRoot) {
 function getCliDefaultConfigDir() {
   const envXdgConfig = process.env.XDG_CONFIG_HOME?.trim();
   const shouldIgnoreWindowsXdg = envXdgConfig !== undefined && envXdgConfig.length > 0 && isWslEnvironment() && isWindowsUserConfigRoot(envXdgConfig);
-  const xdgConfig = shouldIgnoreWindowsXdg ? posix.join(getWslLinuxHomeDir(envXdgConfig) ?? "/home", ".config") : envXdgConfig || join8(homedir3(), ".config");
-  const configDir = isWslEnvironment() ? posix.join(xdgConfig, "opencode") : join8(xdgConfig, "opencode");
+  const xdgConfig = shouldIgnoreWindowsXdg ? posix.join(getWslLinuxHomeDir(envXdgConfig) ?? "/home", ".config") : envXdgConfig || join9(homedir3(), ".config");
+  const configDir = isWslEnvironment() ? posix.join(xdgConfig, "opencode") : join9(xdgConfig, "opencode");
   return resolveConfigPath(configDir);
 }
 function getCliCustomConfigDir() {
@@ -11077,9 +11182,9 @@ function getOpenCodeConfigDir(options) {
   const tauriDir = process.platform === "win32" ? win32.isAbsolute(tauriDirBase) ? win32.normalize(tauriDirBase) : win32.resolve(tauriDirBase) : resolveConfigPath(tauriDirBase);
   if (checkExisting) {
     const legacyDir = getCliConfigDir();
-    const legacyConfig = join8(legacyDir, "opencode.json");
-    const legacyConfigC = join8(legacyDir, "opencode.jsonc");
-    if (existsSync8(legacyConfig) || existsSync8(legacyConfigC)) {
+    const legacyConfig = join9(legacyDir, "opencode.json");
+    const legacyConfigC = join9(legacyDir, "opencode.jsonc");
+    if (existsSync9(legacyConfig) || existsSync9(legacyConfigC)) {
       return legacyDir;
     }
   }
@@ -11089,10 +11194,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir(options);
   return {
     configDir,
-    configJson: join8(configDir, "opencode.json"),
-    configJsonc: join8(configDir, "opencode.jsonc"),
-    packageJson: join8(configDir, "package.json"),
-    omoConfig: join8(configDir, `${CONFIG_BASENAME}.json`)
+    configJson: join9(configDir, "opencode.json"),
+    configJsonc: join9(configDir, "opencode.jsonc"),
+    packageJson: join9(configDir, "package.json"),
+    omoConfig: join9(configDir, `${CONFIG_BASENAME}.json`)
   };
 }
 var TAURI_APP_IDENTIFIER = "ai.opencode.desktop", TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
@@ -11102,10 +11207,10 @@ var init_opencode_config_dir = __esm(() => {
 
 // packages/omo-opencode/src/shared/resolve-agent-definition-paths.ts
 import { homedir as homedir4 } from "os";
-import { isAbsolute as isAbsolute2, join as join9, resolve as resolve5 } from "path";
+import { isAbsolute as isAbsolute2, join as join10, resolve as resolve5 } from "path";
 function resolveAgentDefinitionPaths(paths, baseDir, containmentDir) {
   return paths.flatMap((p) => {
-    const expanded = p.startsWith("~/") ? join9(homedir4(), p.slice(2)) : p;
+    const expanded = p.startsWith("~/") ? join10(homedir4(), p.slice(2)) : p;
     const resolved = isAbsolute2(expanded) ? expanded : resolve5(baseDir, expanded);
     if (containmentDir !== null && !isWithinProject(resolved, containmentDir)) {
       log2(`agent_definitions path rejected (outside project boundary): ${p} -> ${resolved}`);
@@ -11121,8 +11226,8 @@ var init_resolve_agent_definition_paths = __esm(() => {
 
 // packages/omo-opencode/src/shared/opencode-version.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync4, realpathSync as realpathSync4 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync4, realpathSync as realpathSync4 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
 function parseVersion(version) {
   const cleaned = version.replace(/^v/, "").split("-")[0];
   return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
@@ -11163,7 +11268,7 @@ function parsePackageVersion(content) {
 function getPackageVersionFromBinary(binaryPath, deps) {
   try {
     const realBinaryPath = deps.realpath(binaryPath);
-    const packagePath = join10(dirname3(dirname3(realBinaryPath)), "package.json");
+    const packagePath = join11(dirname4(dirname4(realBinaryPath)), "package.json");
     if (!deps.exists(packagePath))
       return null;
     return parsePackageVersion(deps.readText(packagePath));
@@ -11223,15 +11328,15 @@ var init_opencode_version = __esm(() => {
         return envPath;
       return globalThis.Bun?.which("opencode") ?? null;
     },
-    exists: existsSync9,
+    exists: existsSync10,
     realpath: realpathSync4,
     readText: (filePath) => readFileSync4(filePath, "utf-8")
   };
 });
 
 // packages/omo-opencode/src/shared/opencode-storage-detection.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import { join as join12 } from "node:path";
 function isSqliteBackend() {
   if (cachedResult === true)
     return true;
@@ -11239,8 +11344,8 @@ function isSqliteBackend() {
     return false;
   const check = () => {
     const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION);
-    const dbPath = join11(getDataDir(), "opencode", "opencode.db");
-    return versionOk && existsSync10(dbPath);
+    const dbPath = join12(getDataDir(), "opencode", "opencode.db");
+    return versionOk && existsSync11(dbPath);
   };
   if (cachedResult === FALSE_PENDING_RETRY) {
     const result2 = check();
@@ -11309,11 +11414,11 @@ var init_bun_file_shim = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/binary-downloader.ts
-import { chmodSync, existsSync as existsSync11, mkdirSync as mkdirSync4, unlinkSync as unlinkSync3 } from "node:fs";
+import { chmodSync, existsSync as existsSync12, mkdirSync as mkdirSync4, unlinkSync as unlinkSync3 } from "node:fs";
 import * as path6 from "node:path";
 function getCachedBinaryPath(cacheDir, binaryName) {
   const binaryPath = path6.join(cacheDir, binaryName);
-  return existsSync11(binaryPath) ? binaryPath : null;
+  return existsSync12(binaryPath) ? binaryPath : null;
 }
 var init_binary_downloader = __esm(() => {
   init_bun_spawn_shim();
@@ -11481,8 +11586,8 @@ var init_agent_tool_restrictions = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/json-file-cache-store.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join14 } from "node:path";
 function toLogLabel(cacheLabel) {
   return cacheLabel.toLowerCase();
 }
@@ -11490,11 +11595,11 @@ function createJsonFileCacheStore(options) {
   let memoryValue;
   let writtenInCurrentProcess = false;
   function getCacheFilePath() {
-    return join13(options.getCacheDir(), options.filename);
+    return join14(options.getCacheDir(), options.filename);
   }
   function ensureCacheDir() {
     const cacheDir = options.getCacheDir();
-    if (!existsSync12(cacheDir)) {
+    if (!existsSync13(cacheDir)) {
       mkdirSync5(cacheDir, { recursive: true });
     }
   }
@@ -11503,7 +11608,7 @@ function createJsonFileCacheStore(options) {
       return memoryValue;
     }
     const cacheFile = getCacheFilePath();
-    if (!existsSync12(cacheFile)) {
+    if (!existsSync13(cacheFile)) {
       memoryValue = null;
       log2(`[${options.logPrefix}] ${options.cacheLabel} file not found`, { cacheFile });
       return null;
@@ -11529,7 +11634,7 @@ function createJsonFileCacheStore(options) {
     if (writtenInCurrentProcess) {
       return true;
     }
-    return existsSync12(getCacheFilePath());
+    return existsSync13(getCacheFilePath());
   }
   function write(value) {
     ensureCacheDir();
@@ -11772,14 +11877,14 @@ var init_model_resolution_pipeline2 = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/model-availability.ts
-import { existsSync as existsSync13, readFileSync as readFileSync6 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync6 } from "fs";
+import { join as join15 } from "path";
 function isModelCacheAvailable() {
   if (hasProviderModelsCache()) {
     return true;
   }
-  const cacheFile = join14(getOpenCodeCacheDir(), "models.json");
-  return existsSync13(cacheFile);
+  const cacheFile = join15(getOpenCodeCacheDir(), "models.json");
+  return existsSync14(cacheFile);
 }
 var init_model_availability = __esm(() => {
   init_logger2();
@@ -54203,19 +54308,19 @@ var init_fallback_model_availability = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/opencode-storage-paths.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 var OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE;
 var init_opencode_storage_paths = __esm(() => {
   init_data_path();
   OPENCODE_STORAGE = getOpenCodeStorageDir();
-  MESSAGE_STORAGE = join15(OPENCODE_STORAGE, "message");
-  PART_STORAGE = join15(OPENCODE_STORAGE, "part");
-  SESSION_STORAGE = join15(OPENCODE_STORAGE, "session");
+  MESSAGE_STORAGE = join16(OPENCODE_STORAGE, "message");
+  PART_STORAGE = join16(OPENCODE_STORAGE, "part");
+  SESSION_STORAGE = join16(OPENCODE_STORAGE, "session");
 });
 
 // packages/omo-opencode/src/shared/compaction-marker.ts
-import { existsSync as existsSync14, readdirSync, readFileSync as readFileSync7 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync15, readdirSync, readFileSync as readFileSync7 } from "node:fs";
+import { join as join17 } from "node:path";
 function isCompactionPart(part) {
   return typeof part === "object" && part !== null && part.type === "compaction";
 }
@@ -54229,20 +54334,20 @@ function isCompactionMessage(message) {
   return isCompactionAgent(message.info?.agent ?? message.agent) || hasCompactionPart(message.parts);
 }
 function getCompactionPartStorageDir(messageID) {
-  return join16(PART_STORAGE, messageID);
+  return join17(PART_STORAGE, messageID);
 }
 function hasCompactionPartInStorage(messageID) {
   if (!messageID) {
     return false;
   }
   const partDir = getCompactionPartStorageDir(messageID);
-  if (!existsSync14(partDir)) {
+  if (!existsSync15(partDir)) {
     return false;
   }
   try {
     return readdirSync(partDir).filter((fileName) => fileName.endsWith(".json")).some((fileName) => {
       try {
-        const content = readFileSync7(join16(partDir, fileName), "utf-8");
+        const content = readFileSync7(join17(partDir, fileName), "utf-8");
         return isCompactionPart(JSON.parse(content));
       } catch (error) {
         if (error instanceof Error) {
@@ -54342,23 +54447,23 @@ var init_hook_message_injector = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/opencode-message-dir.ts
-import { existsSync as existsSync15, readdirSync as readdirSync2 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync2 } from "node:fs";
+import { join as join18 } from "node:path";
 function getMessageDir(sessionID) {
   if (!sessionID.startsWith("ses_"))
     return null;
   if (/[/\\]|\.\./.test(sessionID))
     return null;
-  if (!existsSync15(MESSAGE_STORAGE))
+  if (!existsSync16(MESSAGE_STORAGE))
     return null;
-  const directPath = join17(MESSAGE_STORAGE, sessionID);
-  if (existsSync15(directPath)) {
+  const directPath = join18(MESSAGE_STORAGE, sessionID);
+  if (existsSync16(directPath)) {
     return directPath;
   }
   try {
     for (const dir of readdirSync2(MESSAGE_STORAGE)) {
-      const sessionPath = join17(MESSAGE_STORAGE, dir, sessionID);
-      if (existsSync15(sessionPath)) {
+      const sessionPath = join18(MESSAGE_STORAGE, dir, sessionID);
+      if (existsSync16(sessionPath)) {
         return sessionPath;
       }
     }
@@ -56492,7 +56597,7 @@ var require_cross_spawn = __commonJS((exports, module) => {
     enoent.hookChildProcess(spawned, parsed);
     return spawned;
   }
-  function spawnSync2(command, args, options) {
+  function spawnSync3(command, args, options) {
     const parsed = parse3(command, args, options);
     const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
     result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
@@ -56500,18 +56605,18 @@ var require_cross_spawn = __commonJS((exports, module) => {
   }
   module.exports = spawn4;
   module.exports.spawn = spawn4;
-  module.exports.sync = spawnSync2;
+  module.exports.sync = spawnSync3;
   module.exports._parse = parse3;
   module.exports._enoent = enoent;
 });
 
 // node_modules/.bun/@opencode-ai+sdk@1.15.13/node_modules/@opencode-ai/sdk/dist/process.js
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 function stop(proc) {
   if (proc.exitCode !== null || proc.signalCode !== null)
     return;
   if (process.platform === "win32" && proc.pid) {
-    const out = spawnSync2("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true });
+    const out = spawnSync3("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true });
     if (!out.error && out.status === 0)
       return;
   }
@@ -57018,11 +57123,11 @@ var init_opencode_command_dirs = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/project-discovery-dirs.ts
-import { existsSync as existsSync16, realpathSync as realpathSync5 } from "node:fs";
-import { dirname as dirname4, join as join18, resolve as resolve6, win32 as win322 } from "node:path";
+import { existsSync as existsSync17, realpathSync as realpathSync5 } from "node:fs";
+import { dirname as dirname5, join as join19, resolve as resolve6, win32 as win322 } from "node:path";
 function normalizePath(path7) {
   const resolvedPath = process.platform !== "win32" && win322.isAbsolute(path7) ? path7 : resolve6(path7);
-  if (!existsSync16(resolvedPath)) {
+  if (!existsSync17(resolvedPath)) {
     return resolvedPath;
   }
   try {
@@ -57052,8 +57157,8 @@ function findProjectOpencodePluginConfigFiles(startDirectory, stopDirectory) {
   const resolvedStopDirectory = stopDirectory ? normalizePath(stopDirectory) : undefined;
   const stopDirectoryKey = resolvedStopDirectory ? pathKey(resolvedStopDirectory) : undefined;
   while (true) {
-    const opencodeDirectory = join18(currentDirectory, ".opencode");
-    if (existsSync16(opencodeDirectory)) {
+    const opencodeDirectory = join19(currentDirectory, ".opencode");
+    if (existsSync17(opencodeDirectory)) {
       const detected = detectPluginConfigFile(opencodeDirectory, {
         basenames: [CONFIG_BASENAME],
         legacyBasenames: [LEGACY_CONFIG_BASENAME]
@@ -57069,7 +57174,7 @@ function findProjectOpencodePluginConfigFiles(startDirectory, stopDirectory) {
     if (stopDirectoryKey === pathKey(currentDirectory)) {
       return paths;
     }
-    const parentDirectory = dirname4(currentDirectory);
+    const parentDirectory = dirname5(currentDirectory);
     if (parentDirectory === currentDirectory) {
       return paths;
     }
@@ -57610,17 +57715,17 @@ var init_plugin_name_with_version = __esm(() => {
 });
 
 // packages/omo-opencode/src/cli/config-manager/backup-config.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync18, mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname as dirname6 } from "node:path";
 function backupConfigFile(configPath) {
-  if (!existsSync17(configPath)) {
+  if (!existsSync18(configPath)) {
     return { success: true };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const backupPath = `${configPath}.backup-${timestamp}`;
   try {
-    const dir = dirname5(backupPath);
-    if (!existsSync17(dir)) {
+    const dir = dirname6(backupPath);
+    if (!existsSync18(dir)) {
       mkdirSync6(dir, { recursive: true });
     }
     copyFileSync2(configPath, backupPath);
@@ -57635,10 +57740,10 @@ function backupConfigFile(configPath) {
 var init_backup_config = () => {};
 
 // packages/omo-opencode/src/cli/config-manager/ensure-config-directory-exists.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync7 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync7 } from "node:fs";
 function ensureConfigDirectoryExists() {
   const configDir = getConfigDir();
-  if (!existsSync18(configDir)) {
+  if (!existsSync19(configDir)) {
     mkdirSync7(configDir, { recursive: true });
   }
 }
@@ -57676,14 +57781,14 @@ function formatErrorWithSuggestion(err, context) {
 }
 
 // packages/omo-opencode/src/cli/config-manager/opencode-config-format.ts
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 function detectConfigFormat() {
   const configJsonc = getConfigJsonc();
   const configJson = getConfigJson();
-  if (existsSync19(configJsonc)) {
+  if (existsSync20(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync19(configJson)) {
+  if (existsSync20(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
@@ -57816,30 +57921,30 @@ function extractVersionFromPluginEntry(entry) {
 }
 
 // packages/omo-opencode/src/cli/config-manager/add-plugin-to-opencode-config.ts
-import { existsSync as existsSync20, readdirSync as readdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename as basename2, dirname as dirname6, join as join19 } from "node:path";
+import { existsSync as existsSync21, readdirSync as readdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
+import { basename as basename3, dirname as dirname7, join as join20 } from "node:path";
 function detectConfigFormatInDir(configDir) {
-  const configJsonc = join19(configDir, "opencode.jsonc");
-  const configJson = join19(configDir, "opencode.json");
-  if (existsSync20(configJsonc)) {
+  const configJsonc = join20(configDir, "opencode.jsonc");
+  const configJson = join20(configDir, "opencode.json");
+  if (existsSync21(configJsonc)) {
     return { format: "jsonc", path: configJsonc };
   }
-  if (existsSync20(configJson)) {
+  if (existsSync21(configJson)) {
     return { format: "json", path: configJson };
   }
   return { format: "none", path: configJson };
 }
 function getParentConfigDirForProfile(configDir) {
-  const parentDir = dirname6(configDir);
-  if (basename2(parentDir) !== "profiles")
+  const parentDir = dirname7(configDir);
+  if (basename3(parentDir) !== "profiles")
     return null;
-  return dirname6(parentDir);
+  return dirname7(parentDir);
 }
 function listProfileConfigDirs(rootConfigDir) {
-  const profilesDir = join19(rootConfigDir, "profiles");
-  if (!existsSync20(profilesDir))
+  const profilesDir = join20(rootConfigDir, "profiles");
+  if (!existsSync21(profilesDir))
     return [];
-  return readdirSync3(profilesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join19(profilesDir, entry.name)).filter((profileDir) => detectConfigFormatInDir(profileDir).format !== "none");
+  return readdirSync3(profilesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join20(profilesDir, entry.name)).filter((profileDir) => detectConfigFormatInDir(profileDir).format !== "none");
 }
 function getConfigTargets() {
   const primaryConfigDir = getConfigDir();
@@ -58339,12 +58444,12 @@ var init_migrations_sidecar2 = __esm(() => {
 });
 
 // packages/omo-opencode/src/shared/migrate-legacy-config-file.ts
-import { existsSync as existsSync21, readFileSync as readFileSync10, renameSync as renameSync4, rmSync } from "node:fs";
-import { join as join20, dirname as dirname7, basename as basename3 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync10, renameSync as renameSync4, rmSync } from "node:fs";
+import { join as join21, dirname as dirname8, basename as basename4 } from "node:path";
 function buildCanonicalPath(legacyPath) {
-  const dir = dirname7(legacyPath);
-  const ext = basename3(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
-  return join20(dir, `${CONFIG_BASENAME}${ext}`);
+  const dir = dirname8(legacyPath);
+  const ext = basename4(legacyPath).includes(".jsonc") ? ".jsonc" : ".json";
+  return join21(dir, `${CONFIG_BASENAME}${ext}`);
 }
 function archiveLegacyConfigFile(legacyPath) {
   const backupPath = `${legacyPath}.bak`;
@@ -58377,10 +58482,10 @@ function archiveLegacyConfigFile(legacyPath) {
 }
 function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   const legacySidecarPath = getSidecarPath(legacyPath);
-  if (!existsSync21(legacySidecarPath))
+  if (!existsSync22(legacySidecarPath))
     return true;
   const canonicalSidecarPath = getSidecarPath(canonicalPath);
-  if (existsSync21(canonicalSidecarPath))
+  if (existsSync22(canonicalSidecarPath))
     return true;
   try {
     const content = readFileSync10(legacySidecarPath, "utf-8");
@@ -58400,12 +58505,12 @@ function migrateLegacySidecarFile(legacyPath, canonicalPath) {
   }
 }
 function migrateLegacyConfigFile(legacyPath) {
-  if (!existsSync21(legacyPath))
+  if (!existsSync22(legacyPath))
     return false;
-  if (!basename3(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
+  if (!basename4(legacyPath).startsWith(LEGACY_CONFIG_BASENAME))
     return false;
   const canonicalPath = buildCanonicalPath(legacyPath);
-  if (existsSync21(canonicalPath))
+  if (existsSync22(canonicalPath))
     return false;
   try {
     const content = readFileSync10(legacyPath, "utf-8");
@@ -58449,8 +58554,8 @@ function deepMergeRecord(target, source) {
 }
 
 // packages/omo-opencode/src/cli/config-manager/write-omo-config.ts
-import { existsSync as existsSync22, readFileSync as readFileSync11, statSync as statSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename4, dirname as dirname8, extname, join as join21 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync11, statSync as statSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename as basename5, dirname as dirname9, extname, join as join22 } from "node:path";
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
@@ -58465,12 +58570,12 @@ function writeOmoConfig(installConfig) {
     };
   }
   const detectedConfigPath = getOmoConfigPath();
-  const canonicalConfigPath = join21(dirname8(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
-  const shouldMigrateLegacyPath = basename4(detectedConfigPath).startsWith(LEGACY_CONFIG_BASENAME);
-  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync22(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
+  const canonicalConfigPath = join22(dirname9(detectedConfigPath), `${CONFIG_BASENAME}${extname(detectedConfigPath) || ".json"}`);
+  const shouldMigrateLegacyPath = basename5(detectedConfigPath).startsWith(LEGACY_CONFIG_BASENAME);
+  const omoConfigPath = shouldMigrateLegacyPath ? migrateLegacyConfigFile(detectedConfigPath) || existsSync23(canonicalConfigPath) ? canonicalConfigPath : detectedConfigPath : detectedConfigPath;
   try {
     const newConfig = generateOmoConfig(installConfig);
-    if (existsSync22(omoConfigPath)) {
+    if (existsSync23(omoConfigPath)) {
       const backupResult = backupConfigFile(omoConfigPath);
       if (!backupResult.success) {
         return {
@@ -58687,10 +58792,10 @@ var init_opencode_binary = __esm(() => {
 });
 
 // packages/omo-opencode/src/cli/config-manager/detect-current-config.ts
-import { existsSync as existsSync23, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync24, readFileSync as readFileSync12 } from "node:fs";
 function detectProvidersFromOmoConfig() {
   const omoConfigPath = getOmoConfigPath();
-  if (!existsSync23(omoConfigPath)) {
+  if (!existsSync24(omoConfigPath)) {
     return {
       hasOpenAI: true,
       hasOpencodeZen: true,
@@ -58842,10 +58947,10 @@ var init_detect_current_config = __esm(() => {
 });
 
 // packages/omo-opencode/src/cli/config-manager/bun-install.ts
-import { existsSync as existsSync24 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import { join as join23 } from "node:path";
 function getDefaultWorkspaceDir() {
-  return join22(getOpenCodeCacheDir(), "packages");
+  return join23(getOpenCodeCacheDir(), "packages");
 }
 function readProcessOutput(stream) {
   if (!stream) {
@@ -58871,7 +58976,7 @@ async function runBunInstallWithDetails(options) {
   const outputMode = options?.outputMode ?? "pipe";
   const cacheDir = options?.workspaceDir ?? getDefaultWorkspaceDir();
   const packageJsonPath = `${cacheDir}/package.json`;
-  if (!existsSync24(packageJsonPath)) {
+  if (!existsSync25(packageJsonPath)) {
     return {
       success: false,
       error: `Workspace not initialized: ${packageJsonPath} not found. OpenCode should create this on first run.`
@@ -58952,21 +59057,21 @@ var init_config_manager = __esm(() => {
 });
 
 // packages/telemetry-core/src/activity-state.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync8, readFileSync as readFileSync13 } from "node:fs";
-import { basename as basename9, join as join48 } from "node:path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync8, readFileSync as readFileSync13 } from "node:fs";
+import { basename as basename10, join as join49 } 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 : join48(options.env.XDG_DATA_HOME, product.cacheDirName);
-  if (dataDir === xdgStateDir || xdgStateDir === undefined && basename9(dataDir) === product.cacheDirName) {
+  const xdgStateDir = options.env?.XDG_DATA_HOME === undefined ? undefined : join49(options.env.XDG_DATA_HOME, product.cacheDirName);
+  if (dataDir === xdgStateDir || xdgStateDir === undefined && basename10(dataDir) === product.cacheDirName) {
     return dataDir;
   }
-  return join48(dataDir, product.cacheDirName);
+  return join49(dataDir, product.cacheDirName);
 }
 function getTelemetryActivityStateFilePath(stateDir) {
-  return join48(stateDir, POSTHOG_ACTIVITY_STATE_FILE);
+  return join49(stateDir, POSTHOG_ACTIVITY_STATE_FILE);
 }
 function getDailyActiveCaptureState(input) {
   const state = readPostHogActivityState(input.stateDir, input.diagnostics);
@@ -58991,7 +59096,7 @@ function isPostHogActivityState(value) {
 }
 function readPostHogActivityState(stateDir, diagnostics) {
   const stateFilePath = getTelemetryActivityStateFilePath(stateDir);
-  if (!existsSync27(stateFilePath)) {
+  if (!existsSync28(stateFilePath)) {
     return {};
   }
   try {
@@ -59036,10 +59141,10 @@ var init_activity_state = __esm(() => {
 var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com", DEFAULT_POSTHOG_API_KEY = "phc_CFJhj5HyvA62QPhvyaUCtaq23aUfznnijg5VaaGkNk74";
 
 // packages/telemetry-core/src/diagnostics.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync28, mkdirSync as mkdirSync9, readFileSync as readFileSync14 } from "node:fs";
-import { join as join49 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync29, mkdirSync as mkdirSync9, readFileSync as readFileSync14 } from "node:fs";
+import { join as join50 } from "node:path";
 function getTelemetryDiagnosticsFilePath(diagnosticsDir) {
-  return join49(diagnosticsDir, DIAGNOSTICS_FILE_NAME);
+  return join50(diagnosticsDir, DIAGNOSTICS_FILE_NAME);
 }
 function writeTelemetryDiagnostic(input, options) {
   const now = options.now ?? new Date;
@@ -59057,7 +59162,7 @@ function writeTelemetryDiagnostic(input, options) {
 }
 function cleanupTelemetryDiagnostics(options) {
   const diagnosticsFilePath = getTelemetryDiagnosticsFilePath(options.diagnosticsDir);
-  if (!existsSync28(diagnosticsFilePath)) {
+  if (!existsSync29(diagnosticsFilePath)) {
     return;
   }
   try {
@@ -59205,7 +59310,7 @@ function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetr
 var init_machine_id = () => {};
 
 // node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname15, posix as posix2, sep as sep7 } from "path";
+import { dirname as dirname16, posix as posix2, sep as sep7 } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -59214,7 +59319,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname15(process.argv[1]) : process.cwd(), isWindows = sep7 === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname16(process.argv[1]) : process.cwd(), isWindows = sep7 === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -64764,7 +64869,7 @@ var package_default2;
 var init_package2 = __esm(() => {
   package_default2 = {
     name: "@oh-my-opencode/omo-codex",
-    version: "4.12.1",
+    version: "4.13.0",
     type: "module",
     private: true,
     description: "Codex harness adapter for oh-my-openagent. Vendored Codex plugin namespace (omo) + TypeScript installer + telemetry.",
@@ -64899,7 +65004,7 @@ function createPostHogClient(source, options = {}) {
     osProvider: options.osProvider ?? resolveOsProvider(),
     product: createCodexTelemetryProductConfig(),
     source,
-    transportFactory: options.transportFactory
+    transportFactory: options.transportFactory ?? transportFactoryOverride ?? undefined
   });
   if (!client3.enabled) {
     return NO_OP_POSTHOG;
@@ -64950,7 +65055,7 @@ function __setActivityStateProviderForTesting(provider) {
 function __resetActivityStateProviderForTesting() {
   activityStateProviderOverride = null;
 }
-var osProviderOverride2 = null, activityStateProviderOverride = null, NO_OP_POSTHOG;
+var osProviderOverride2 = null, activityStateProviderOverride = null, transportFactoryOverride = null, NO_OP_POSTHOG;
 var init_posthog = __esm(() => {
   init_src4();
   init_diagnostics2();
@@ -65733,20 +65838,20 @@ var init_update_toasts = __esm(() => {
 });
 
 // packages/omo-opencode/src/hooks/auto-update-checker/hook/background-update-check.ts
-import { existsSync as existsSync47 } from "node:fs";
-import { dirname as dirname23, join as join65 } from "node:path";
+import { existsSync as existsSync48 } from "node:fs";
+import { dirname as dirname25, join as join67 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function defaultGetModuleHostingWorkspace() {
   try {
-    const currentDir = dirname23(fileURLToPath4(import.meta.url));
+    const currentDir = dirname25(fileURLToPath4(import.meta.url));
     const pkgJsonPath = findPackageJsonUp(currentDir);
     if (!pkgJsonPath)
       return null;
-    const pkgDir = dirname23(pkgJsonPath);
-    const nodeModulesDir = dirname23(pkgDir);
+    const pkgDir = dirname25(pkgJsonPath);
+    const nodeModulesDir = dirname25(pkgDir);
     if (nodeModulesDir.split(/[\\/]/).pop() !== "node_modules")
       return null;
-    return dirname23(nodeModulesDir);
+    return dirname25(nodeModulesDir);
   } catch (error51) {
     if (error51 instanceof Error) {
       return null;
@@ -65887,8 +65992,8 @@ var init_background_update_check = __esm(() => {
   init_package_json_locator();
   init_update_toasts();
   defaultDeps4 = {
-    existsSync: existsSync47,
-    join: join65,
+    existsSync: existsSync48,
+    join: join67,
     runBunInstallWithDetails,
     log: log2,
     getOpenCodeCacheDir,
@@ -66051,7 +66156,7 @@ async function showSpinnerToast(ctx, version3, message) {
         duration: frameInterval + 50
       }
     }).catch(ignoreToastError);
-    await new Promise((resolve17) => setTimeout(resolve17, frameInterval));
+    await new Promise((resolve18) => setTimeout(resolve18, frameInterval));
   }
 }
 var SISYPHUS_SPINNER;
@@ -66490,13 +66595,13 @@ function getUnsupportedOpenCodeVersionMessage(openCodeVersion) {
 }
 
 // packages/omo-codex/src/install/install-codex.ts
-import { join as join50, resolve as resolve14 } from "node:path";
-import { existsSync as existsSync29 } from "node:fs";
+import { join as join51, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync30 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 
 // packages/omo-codex/src/install/codex-cache-bins.ts
 import { chmod, lstat as lstat3, mkdir, readFile as readFile2, readdir, readlink as readlink2, rm as rm2, stat, symlink, writeFile } from "node:fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute3, join as join25, relative as relative2, resolve as resolve7, sep } from "node:path";
+import { basename as basename6, isAbsolute as isAbsolute3, join as join26, relative as relative2, resolve as resolve7, sep } from "node:path";
 
 // packages/omo-codex/src/install/codex-cache-command-shim.ts
 var COMMAND_SHIM_MARKER = ":: generated by oh-my-openagent Codex installer";
@@ -66522,7 +66627,7 @@ function isNodeErrorWithCode(error) {
 
 // packages/omo-codex/src/install/codex-cache-legacy-bins.ts
 import { lstat as lstat2, readFile, readlink, rm } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 var LEGACY_CODEX_COMPONENT_BINS = [
   { name: "omo", component: "ulw-loop" },
   { name: "codex-comment-checker", component: "comment-checker" },
@@ -66534,7 +66639,7 @@ var LEGACY_CODEX_COMPONENT_BINS = [
 ];
 async function removeLegacyCodexComponentBins(binDir, platform) {
   for (const entry of LEGACY_CODEX_COMPONENT_BINS) {
-    const linkPath = join23(binDir, platform === "win32" ? `${entry.name}.cmd` : entry.name);
+    const linkPath = join24(binDir, platform === "win32" ? `${entry.name}.cmd` : entry.name);
     await removeLegacyCodexComponentBin(linkPath, entry.component, platform);
   }
 }
@@ -66585,10 +66690,10 @@ function isNodeErrorWithCode2(error) {
 }
 
 // packages/omo-codex/src/install/codex-cache-runtime-wrapper.ts
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 var RUNTIME_WRAPPER_MARKER = "OMO_GENERATED_RUNTIME_WRAPPER";
 function posixRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
-  const ulwLoopBin = toPosixPath(join24(binDir, "omo-ulw-loop"));
+  const ulwLoopBin = toPosixPath(join25(binDir, "omo-ulw-loop"));
   const nodeCli = escapePosixDoubleQuoted(toPosixPath(nodeCliPath));
   const escapedCliPath = escapePosixDoubleQuoted(toPosixPath(cliPath));
   const escapedCodexHome = escapePosixDoubleQuoted(toPosixPath(codexHome));
@@ -66634,7 +66739,7 @@ function posixRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
 `);
 }
 function windowsRuntimeWrapper(cliPath, codexHome, binDir, nodeCliPath) {
-  const ulwLoopBin = join24(binDir, "omo-ulw-loop.cmd");
+  const ulwLoopBin = join25(binDir, "omo-ulw-loop.cmd");
   return [
     "@echo off",
     `rem ${RUNTIME_WRAPPER_MARKER}`,
@@ -66690,29 +66795,29 @@ async function linkCachedPluginBins(input) {
   return linked;
 }
 async function linkRootRuntimeBin(input) {
-  const cliPath = join25(input.repoRoot, "dist", "cli", "index.js");
+  const cliPath = join26(input.repoRoot, "dist", "cli", "index.js");
   if (!await isFile(cliPath))
     return null;
-  const nodeCliPath = join25(input.repoRoot, "dist", "cli-node", "index.js");
+  const nodeCliPath = join26(input.repoRoot, "dist", "cli-node", "index.js");
   const platform = input.platform ?? process.platform;
   await mkdir(input.binDir, { recursive: true });
   if (platform === "win32") {
-    const linkPath2 = join25(input.binDir, "omo.cmd");
+    const linkPath2 = join26(input.binDir, "omo.cmd");
     await replaceRuntimeWrapper(linkPath2, windowsRuntimeWrapper(cliPath, input.codexHome, input.binDir, nodeCliPath));
     return { name: "omo", path: linkPath2, target: cliPath };
   }
-  const linkPath = join25(input.binDir, "omo");
+  const linkPath = join26(input.binDir, "omo");
   await replaceRuntimeWrapper(linkPath, posixRuntimeWrapper(cliPath, input.codexHome, input.binDir, nodeCliPath));
   await chmod(linkPath, 493);
   return { name: "omo", path: linkPath, target: cliPath };
 }
 async function linkCachedPluginBin(binDir, link, platform) {
   if (platform === "win32") {
-    const linkPath2 = join25(binDir, `${link.name}.cmd`);
+    const linkPath2 = join26(binDir, `${link.name}.cmd`);
     await replaceCommandShim(linkPath2, link.target);
     return linkPath2;
   }
-  const linkPath = join25(binDir, link.name);
+  const linkPath = join26(binDir, link.name);
   await replaceSymlink(linkPath, link.target);
   return linkPath;
 }
@@ -66733,14 +66838,14 @@ async function discoverPackageBins(root) {
 async function collectPackageBins(directory, root, links) {
   const entries = await readdir(directory, { withFileTypes: true });
   if (entries.some((entry) => entry.isFile() && entry.name === "package.json")) {
-    await appendPackageBinLinks(join25(directory, "package.json"), directory, root, links);
+    await appendPackageBinLinks(join26(directory, "package.json"), directory, root, links);
   }
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist")
       continue;
-    const childPath = join25(directory, entry.name);
+    const childPath = join26(directory, entry.name);
     if (!childPath.startsWith(root))
       continue;
     await collectPackageBins(childPath, root, links);
@@ -66753,7 +66858,7 @@ async function appendPackageBinLinks(packageJsonPath, packageRoot, root, links)
   const packageName = packageJson.name;
   const packageBin = packageJson.bin;
   if (typeof packageBin === "string" && typeof packageName === "string") {
-    const name = assertSafeCommandName(basename5(packageName));
+    const name = assertSafeCommandName(basename6(packageName));
     if (!isReservedNestedBinName(name, packageRoot, root)) {
       links.push({ name, target: resolvePackageBinTarget(packageRoot, packageBin) });
     }
@@ -66855,11 +66960,11 @@ async function existingNonSymlink(path7) {
 }
 // packages/omo-codex/src/install/codex-cache-install.ts
 import { cp as cp2, mkdir as mkdir3, readFile as readFile7, rename, rm as rm3 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname11, join as join31, sep as sep5 } from "node:path";
+import { basename as basename7, dirname as dirname12, join as join32, sep as sep5 } from "node:path";
 
 // packages/omo-codex/src/install/codex-cache-bundled-mcps.ts
 import { cp, mkdir as mkdir2, readFile as readFile3, stat as stat2 } from "node:fs/promises";
-import { dirname as dirname9, join as join26, resolve as resolve8 } from "node:path";
+import { dirname as dirname10, join as join27, resolve as resolve8 } from "node:path";
 var BUNDLED_MCP_RUNTIMES = [
   {
     label: "Git Bash MCP",
@@ -66877,7 +66982,7 @@ var BUNDLED_MCP_RUNTIMES = [
   }
 ];
 async function copyBundledMcpRuntimeDists(input) {
-  const sourceArgs = await readSourceMcpArgs(join26(input.sourceRoot, ".mcp.json"));
+  const sourceArgs = await readSourceMcpArgs(join27(input.sourceRoot, ".mcp.json"));
   for (const runtime4 of BUNDLED_MCP_RUNTIMES) {
     if (!sourceArgs.has(runtime4.sourceArg))
       continue;
@@ -66886,15 +66991,15 @@ async function copyBundledMcpRuntimeDists(input) {
 }
 function resolveBundledMcpRuntimeArg(pluginRoot, arg) {
   const runtime4 = BUNDLED_MCP_RUNTIMES.find((candidate) => candidate.sourceArg === arg);
-  return runtime4 ? join26(pluginRoot, runtime4.destinationArg) : null;
+  return runtime4 ? join27(pluginRoot, runtime4.destinationArg) : null;
 }
 async function copyBundledMcpRuntimeDist(pluginRoot, sourceRoot, runtime4) {
   const sourcePath = resolve8(sourceRoot, runtime4.sourceDistFromPlugin);
   if (!await isDirectory(sourcePath)) {
     throw new Error(`missing built ${runtime4.label} dist at ${sourcePath}`);
   }
-  const destinationPath = join26(pluginRoot, runtime4.destinationDistFromPlugin);
-  await mkdir2(dirname9(destinationPath), { recursive: true });
+  const destinationPath = join27(pluginRoot, runtime4.destinationDistFromPlugin);
+  await mkdir2(dirname10(destinationPath), { recursive: true });
   await cp(sourcePath, destinationPath, { recursive: true });
 }
 async function readSourceMcpArgs(path7) {
@@ -66932,37 +67037,37 @@ async function isDirectory(path7) {
 // packages/omo-codex/src/install/codex-cache-local-dependencies.ts
 import { realpathSync as realpathSync6 } from "node:fs";
 import { readFile as readFile4, readdir as readdir2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname10, isAbsolute as isAbsolute5, join as join28, relative as relative4, resolve as resolve10, sep as sep2 } from "node:path";
+import { dirname as dirname11, isAbsolute as isAbsolute5, join as join29, relative as relative4, resolve as resolve10, sep as sep2 } from "node:path";
 
 // packages/omo-codex/src/install/codex-cache-paths.ts
-import { existsSync as existsSync25, readdirSync as readdirSync4 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join27, relative as relative3, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync26, readdirSync as readdirSync4 } from "node:fs";
+import { isAbsolute as isAbsolute4, join as join28, relative as relative3, resolve as resolve9 } from "node:path";
 var DEFAULT_CODEX_MARKETPLACE_NAME = "sisyphuslabs";
 var DEFAULT_CODEX_PLUGIN_NAME = "omo";
 function resolveDefaultCodexHome(homeDir) {
-  return join27(homeDir, ".codex");
+  return join28(homeDir, ".codex");
 }
 function resolveCodexPluginCacheRoot(codexHome, input = {}) {
-  return join27(codexHome, "plugins", "cache", input.marketplaceName ?? DEFAULT_CODEX_MARKETPLACE_NAME, input.pluginName ?? DEFAULT_CODEX_PLUGIN_NAME);
+  return join28(codexHome, "plugins", "cache", input.marketplaceName ?? DEFAULT_CODEX_MARKETPLACE_NAME, input.pluginName ?? DEFAULT_CODEX_PLUGIN_NAME);
 }
 function resolveCachedCodexComponentCliPath(pluginRoot, componentName) {
-  return join27(pluginRoot, "components", componentName, "dist", "cli.js");
+  return join28(pluginRoot, "components", componentName, "dist", "cli.js");
 }
 function resolveCodexComponentBinCandidates(input) {
   return [
-    input.env.CODEX_LOCAL_BIN_DIR ? join27(input.env.CODEX_LOCAL_BIN_DIR, input.executableName) : undefined,
-    join27(input.homeDir, ".local", "bin", input.executableName),
-    join27(resolveDefaultCodexHome(input.homeDir), "bin", input.executableName)
+    input.env.CODEX_LOCAL_BIN_DIR ? join28(input.env.CODEX_LOCAL_BIN_DIR, input.executableName) : undefined,
+    join28(input.homeDir, ".local", "bin", input.executableName),
+    join28(resolveDefaultCodexHome(input.homeDir), "bin", input.executableName)
   ].filter((value) => typeof value === "string");
 }
 function findNewestCachedCodexComponentCli(input) {
   const versionsRoot = resolveCodexPluginCacheRoot(input.codexHome, input);
-  if (!existsSync25(versionsRoot))
+  if (!existsSync26(versionsRoot))
     return null;
   const versions = readdirSync4(versionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareVersionNames).reverse();
   for (const version of versions) {
-    const candidate = resolveCachedCodexComponentCliPath(join27(versionsRoot, version), input.componentName);
-    if (existsSync25(candidate))
+    const candidate = resolveCachedCodexComponentCliPath(join28(versionsRoot, version), input.componentName);
+    if (existsSync26(candidate))
       return candidate;
   }
   return null;
@@ -67000,8 +67105,8 @@ async function rewriteCachedPackageLocalFileDependencies(pluginRoot, sourceRoot)
     const parsed = JSON.parse(raw);
     if (!isPlainRecord3(parsed))
       continue;
-    const packageDir = dirname10(packageJsonPath);
-    const sourcePackageDir = join28(sourceRoot, relative4(pluginRoot, packageDir));
+    const packageDir = dirname11(packageJsonPath);
+    const sourcePackageDir = join29(sourceRoot, relative4(pluginRoot, packageDir));
     let changed = false;
     for (const field of ["dependencies", "optionalDependencies", "peerDependencies"]) {
       const dependencies = parsed[field];
@@ -67039,7 +67144,7 @@ async function rewriteCachedPackageLocalFileDependencies(pluginRoot, sourceRoot)
 `);
 }
 async function readPackageLock(pluginRoot) {
-  const path7 = join28(pluginRoot, "package-lock.json");
+  const path7 = join29(pluginRoot, "package-lock.json");
   try {
     const parsed = JSON.parse(await readFile4(path7, "utf8"));
     return { path: path7, value: isPlainRecord3(parsed) ? parsed : null, changed: false };
@@ -67100,14 +67205,14 @@ function canonicalizeExistingPath(path7) {
 async function collectPackageJsonPaths(directory, root, paths) {
   const entries = await readdir2(directory, { withFileTypes: true });
   if (entries.some((entry) => entry.isFile() && entry.name === "package.json")) {
-    paths.push(join28(directory, "package.json"));
+    paths.push(join29(directory, "package.json"));
   }
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
     if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist")
       continue;
-    const childPath = join28(directory, entry.name);
+    const childPath = join29(directory, entry.name);
     if (!isPathInside(childPath, root))
       continue;
     await collectPackageJsonPaths(childPath, root, paths);
@@ -67116,10 +67221,10 @@ async function collectPackageJsonPaths(directory, root, paths) {
 
 // packages/omo-codex/src/install/codex-cache-mcp-manifest.ts
 import { readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join29, sep as sep3 } from "node:path";
+import { join as join30, sep as sep3 } from "node:path";
 var CODEGRAPH_RELATIVE_ARGS = new Set(["components/codegraph/dist/serve.js", "./components/codegraph/dist/serve.js"]);
 async function rewriteCachedMcpManifest(pluginRoot, sourceRoot = pluginRoot) {
-  const manifestPath = join29(pluginRoot, ".mcp.json");
+  const manifestPath = join30(pluginRoot, ".mcp.json");
   if (!await fileExistsStrict(manifestPath))
     return;
   const raw = await readFile5(manifestPath, "utf8");
@@ -67144,7 +67249,7 @@ async function rewriteCachedMcpManifest(pluginRoot, sourceRoot = pluginRoot) {
       if (bundledMcpRuntimeArg !== null)
         return bundledMcpRuntimeArg;
       if (CODEGRAPH_RELATIVE_ARGS.has(arg))
-        return join29(pluginRoot, "components", "codegraph", "dist", "serve.js");
+        return join30(pluginRoot, "components", "codegraph", "dist", "serve.js");
       if (arg.startsWith("./") || arg.startsWith("../"))
         return resolveCachedRuntimePath(pluginRoot, sourceRoot, arg);
       return arg;
@@ -67159,7 +67264,7 @@ async function rewriteCachedMcpManifest(pluginRoot, sourceRoot = pluginRoot) {
 `);
 }
 async function rewriteCachedManifestRoot(pluginRoot, fromRoot, toRoot) {
-  const manifestPath = join29(pluginRoot, ".mcp.json");
+  const manifestPath = join30(pluginRoot, ".mcp.json");
   if (!await fileExistsStrict(manifestPath))
     return;
   const raw = await readFile5(manifestPath, "utf8");
@@ -67195,7 +67300,7 @@ async function rewriteCachedManifestRoot(pluginRoot, fromRoot, toRoot) {
 
 // packages/omo-codex/src/install/codex-hook-targets.ts
 import { readFile as readFile6 } from "node:fs/promises";
-import { join as join30, sep as sep4 } from "node:path";
+import { join as join31, sep as sep4 } from "node:path";
 var PLUGIN_ROOT_TARGET_PATTERN = /\$\{PLUGIN_ROOT\}[\\/]+([^"']+)/g;
 async function findMissingHookCommandTargets(pluginRoot) {
   const commands = [];
@@ -67212,7 +67317,7 @@ async function findMissingHookCommandTargets(pluginRoot) {
       const targetSuffix = match[1];
       if (targetSuffix === undefined)
         continue;
-      const target = join30(pluginRoot, ...targetSuffix.split(/[\\/]+/));
+      const target = join31(pluginRoot, ...targetSuffix.split(/[\\/]+/));
       if (seen.has(target))
         continue;
       seen.add(target);
@@ -67223,17 +67328,17 @@ async function findMissingHookCommandTargets(pluginRoot) {
   return missing;
 }
 async function hookManifestPaths(pluginRoot) {
-  const pluginManifestPath = join30(pluginRoot, ".codex-plugin", "plugin.json");
+  const pluginManifestPath = join31(pluginRoot, ".codex-plugin", "plugin.json");
   if (!await fileExistsStrict(pluginManifestPath))
-    return [join30(pluginRoot, "hooks", "hooks.json")];
+    return [join31(pluginRoot, "hooks", "hooks.json")];
   const parsed = JSON.parse(await readFile6(pluginManifestPath, "utf8"));
   if (!isPlainRecord3(parsed))
     return [];
   if (typeof parsed.hooks === "string" && parsed.hooks.trim() !== "") {
-    return [join30(pluginRoot, stripDotSlash(parsed.hooks))];
+    return [join31(pluginRoot, stripDotSlash(parsed.hooks))];
   }
   if (Array.isArray(parsed.hooks)) {
-    return parsed.hooks.filter((hookPath) => typeof hookPath === "string" && hookPath.trim() !== "").map((hookPath) => join30(pluginRoot, stripDotSlash(hookPath)));
+    return parsed.hooks.filter((hookPath) => typeof hookPath === "string" && hookPath.trim() !== "").map((hookPath) => join31(pluginRoot, stripDotSlash(hookPath)));
   }
   return [];
 }
@@ -67269,7 +67374,7 @@ async function installCachedPlugin(input) {
     await maybeRunNpmInstall(input.sourcePath, input.runCommand);
     await maybeRunNpmBuild(input.sourcePath, input.runCommand);
   }
-  const targetPath = join31(input.codexHome, "plugins", "cache", input.marketplaceName, input.name, input.version);
+  const targetPath = join32(input.codexHome, "plugins", "cache", input.marketplaceName, input.name, input.version);
   const tempPath = createTempSiblingPath(targetPath);
   await rm3(tempPath, { recursive: true, force: true });
   try {
@@ -67290,14 +67395,14 @@ async function installCachedPlugin(input) {
   return { name: input.name, version: input.version, path: targetPath };
 }
 async function maybeRunNpmInstall(cwd, runCommand, args = ["install"]) {
-  if (!await fileExistsStrict(join31(cwd, "package.json")))
+  if (!await fileExistsStrict(join32(cwd, "package.json")))
     return;
   await runCommand("npm", args, { cwd });
 }
 async function maybeRunNpmBuild(cwd, runCommand) {
-  if (!await fileExistsStrict(join31(cwd, "package.json")))
+  if (!await fileExistsStrict(join32(cwd, "package.json")))
     return;
-  const packageJson = JSON.parse(await readFile7(join31(cwd, "package.json"), "utf8"));
+  const packageJson = JSON.parse(await readFile7(join32(cwd, "package.json"), "utf8"));
   if (!isPlainRecord3(packageJson))
     return;
   const scripts = packageJson.scripts;
@@ -67306,9 +67411,9 @@ async function maybeRunNpmBuild(cwd, runCommand) {
   await runCommand("npm", ["run", "build"], { cwd });
 }
 async function maybeRunNpmSyncSkills(cwd, runCommand) {
-  if (!await fileExistsStrict(join31(cwd, "package.json")))
+  if (!await fileExistsStrict(join32(cwd, "package.json")))
     return;
-  const packageJson = JSON.parse(await readFile7(join31(cwd, "package.json"), "utf8"));
+  const packageJson = JSON.parse(await readFile7(join32(cwd, "package.json"), "utf8"));
   if (!isPlainRecord3(packageJson))
     return;
   const scripts = packageJson.scripts;
@@ -67317,13 +67422,13 @@ async function maybeRunNpmSyncSkills(cwd, runCommand) {
   await runCommand("npm", ["run", "sync:skills"], { cwd });
 }
 function createTempSiblingPath(targetPath) {
-  return join31(dirname11(targetPath), `.tmp-${basename6(targetPath)}-${process.pid}-${Date.now()}`);
+  return join32(dirname12(targetPath), `.tmp-${basename7(targetPath)}-${process.pid}-${Date.now()}`);
 }
 function createBackupSiblingPath(targetPath) {
-  return join31(dirname11(targetPath), `.backup-${basename6(targetPath)}-${process.pid}-${Date.now()}`);
+  return join32(dirname12(targetPath), `.backup-${basename7(targetPath)}-${process.pid}-${Date.now()}`);
 }
 async function copyDirectory(sourcePath, targetPath) {
-  await mkdir3(dirname11(targetPath), { recursive: true });
+  await mkdir3(dirname12(targetPath), { recursive: true });
   await cp2(sourcePath, targetPath, { recursive: true, filter: (source) => shouldCopyPluginPath(source, sourcePath) });
 }
 async function promoteDirectory(tempPath, targetPath, renameDirectory) {
@@ -67359,9 +67464,9 @@ function shouldCopyPluginPath(path7, root) {
 }
 // packages/omo-codex/src/install/codex-cache-prune.ts
 import { lstat as lstat4, readdir as readdir3, rm as rm4, stat as stat3 } from "node:fs/promises";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 async function pruneMarketplaceCache(input) {
-  const cacheRoot = join32(input.codexHome, "plugins", "cache", input.marketplaceName);
+  const cacheRoot = join33(input.codexHome, "plugins", "cache", input.marketplaceName);
   if (!await fileExistsStrict(cacheRoot))
     return;
   const keep = new Set(input.keepPluginNames);
@@ -67369,15 +67474,15 @@ async function pruneMarketplaceCache(input) {
   for (const entry of entries) {
     if (!entry.isDirectory() || keep.has(entry.name))
       continue;
-    await rm4(join32(cacheRoot, entry.name), { recursive: true, force: true });
+    await rm4(join33(cacheRoot, entry.name), { recursive: true, force: true });
   }
 }
 async function pruneMarketplacePluginCaches(input) {
-  const cacheRoot = join32(input.codexHome, "plugins", "cache", input.marketplaceName);
+  const cacheRoot = join33(input.codexHome, "plugins", "cache", input.marketplaceName);
   if (!await fileExistsStrict(cacheRoot))
     return;
   for (const pluginName of input.pluginNames) {
-    await rm4(join32(cacheRoot, pluginName), { recursive: true, force: true });
+    await rm4(join33(cacheRoot, pluginName), { recursive: true, force: true });
   }
   const remainingEntries = await readCacheEntryNames(cacheRoot);
   if (remainingEntries.length === 0) {
@@ -67424,11 +67529,11 @@ async function isBrokenCacheSymlink(path7) {
 }
 // packages/omo-codex/src/install/codex-cached-marketplace-manifest.ts
 import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 async function writeCachedMarketplaceManifest(input) {
-  const marketplaceDir = join33(input.marketplaceRoot, ".agents", "plugins");
+  const marketplaceDir = join34(input.marketplaceRoot, ".agents", "plugins");
   await mkdir4(marketplaceDir, { recursive: true });
-  await writeFile4(join33(marketplaceDir, "marketplace.json"), `${JSON.stringify({
+  await writeFile4(join34(marketplaceDir, "marketplace.json"), `${JSON.stringify({
     name: input.marketplaceName,
     plugins: input.plugins.map((plugin) => ({
       name: plugin.name,
@@ -67439,9 +67544,9 @@ async function writeCachedMarketplaceManifest(input) {
 }
 
 // packages/omo-codex/src/install/codex-package-layout.ts
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { readFile as readFile8 } from "node:fs/promises";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 var PACKAGED_CODEX_INSTALLER_NAMES = new Set([
   "@code-yeongyu/lazycodex",
   "@code-yeongyu/lazycodex-ai",
@@ -67451,10 +67556,10 @@ var PACKAGED_CODEX_INSTALLER_NAMES = new Set([
   "oh-my-openagent"
 ]);
 async function shouldBuildSourcePackages(repoRoot) {
-  if (existsSync26(join34(repoRoot, "packages", "omo-opencode", "src", "index.ts")))
+  if (existsSync27(join35(repoRoot, "packages", "omo-opencode", "src", "index.ts")))
     return true;
-  const packageJsonPath = join34(repoRoot, "package.json");
-  if (!existsSync26(packageJsonPath))
+  const packageJsonPath = join35(repoRoot, "package.json");
+  if (!existsSync27(packageJsonPath))
     return true;
   const packageJson = JSON.parse(await readFile8(packageJsonPath, "utf8"));
   if (!isPlainRecord3(packageJson) || typeof packageJson.name !== "string")
@@ -67464,11 +67569,12 @@ async function shouldBuildSourcePackages(repoRoot) {
 
 // packages/omo-codex/src/install/codex-config-toml.ts
 import { mkdir as mkdir5, readFile as readFile10 } from "node:fs/promises";
-import { dirname as dirname13 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 
 // packages/omo-codex/src/install/toml-section-editor.ts
 function findTomlSection(config, header) {
   const headerLine = `[${header}]`;
+  const targetHeaderPath = parseTomlDottedKey(header);
   const lines = config.match(/[^\n]*\n?|$/g) ?? [];
   let offset = 0;
   let start = -1;
@@ -67477,7 +67583,7 @@ function findTomlSection(config, header) {
       break;
     const trimmed = line.trim();
     if (start === -1) {
-      if (trimmed === headerLine)
+      if (tomlTableHeaderMatches(trimmed, headerLine, targetHeaderPath))
         start = offset;
     } else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
       return { start, end: offset, text: config.slice(start, offset) };
@@ -67533,6 +67639,127 @@ function insertSetting(sectionText, key, value) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function tomlTableHeaderMatches(line, headerLine, targetHeaderPath) {
+  if (line === headerLine)
+    return true;
+  if (!targetHeaderPath)
+    return false;
+  const candidateHeaderPath = parseTomlTableHeader(line);
+  if (!candidateHeaderPath || candidateHeaderPath.length !== targetHeaderPath.length)
+    return false;
+  return candidateHeaderPath.every((part, index) => part === targetHeaderPath[index]);
+}
+function parseTomlTableHeader(line) {
+  if (!line.startsWith("[") || !line.endsWith("]") || line.startsWith("[["))
+    return null;
+  return parseTomlDottedKey(line.slice(1, -1).trim());
+}
+function parseTomlDottedKey(input) {
+  const parts = [];
+  let index = 0;
+  while (index < input.length) {
+    index = skipWhitespace(input, index);
+    const parsedKey = parseTomlKeyPart(input, index);
+    if (!parsedKey)
+      return null;
+    parts.push(parsedKey.value);
+    index = skipWhitespace(input, parsedKey.nextIndex);
+    if (index === input.length)
+      return parts;
+    if (input[index] !== ".")
+      return null;
+    index += 1;
+  }
+  return parts.length > 0 ? parts : null;
+}
+function parseTomlKeyPart(input, startIndex) {
+  const quote = input[startIndex];
+  if (quote === "'")
+    return parseLiteralTomlString(input, startIndex);
+  if (quote === '"')
+    return parseBasicTomlString(input, startIndex);
+  return parseBareTomlKey(input, startIndex);
+}
+function parseLiteralTomlString(input, startIndex) {
+  let index = startIndex + 1;
+  let value = "";
+  while (index < input.length) {
+    const char = input[index];
+    if (char === "'")
+      return { value, nextIndex: index + 1 };
+    value += char;
+    index += 1;
+  }
+  return null;
+}
+function parseBasicTomlString(input, startIndex) {
+  let index = startIndex + 1;
+  let value = "";
+  while (index < input.length) {
+    const char = input[index];
+    if (char === '"')
+      return { value, nextIndex: index + 1 };
+    if (char !== "\\") {
+      value += char;
+      index += 1;
+      continue;
+    }
+    const escaped = parseBasicTomlEscape(input, index);
+    if (!escaped)
+      return null;
+    value += escaped.value;
+    index = escaped.nextIndex;
+  }
+  return null;
+}
+function parseBasicTomlEscape(input, backslashIndex) {
+  const escape = input[backslashIndex + 1];
+  if (escape === undefined)
+    return null;
+  if (escape === "b")
+    return { value: "\b", nextIndex: backslashIndex + 2 };
+  if (escape === "t")
+    return { value: "\t", nextIndex: backslashIndex + 2 };
+  if (escape === "n")
+    return { value: `
+`, nextIndex: backslashIndex + 2 };
+  if (escape === "f")
+    return { value: "\f", nextIndex: backslashIndex + 2 };
+  if (escape === "r")
+    return { value: "\r", nextIndex: backslashIndex + 2 };
+  if (escape === '"')
+    return { value: '"', nextIndex: backslashIndex + 2 };
+  if (escape === "\\")
+    return { value: "\\", nextIndex: backslashIndex + 2 };
+  if (escape === "u")
+    return parseUnicodeEscape(input, backslashIndex + 2, 4);
+  if (escape === "U")
+    return parseUnicodeEscape(input, backslashIndex + 2, 8);
+  return null;
+}
+function parseUnicodeEscape(input, digitsStart, digitCount) {
+  const digits = input.slice(digitsStart, digitsStart + digitCount);
+  if (digits.length !== digitCount || !/^[0-9A-Fa-f]+$/.test(digits))
+    return null;
+  const codePoint = Number.parseInt(digits, 16);
+  if (codePoint > 1114111)
+    return null;
+  return { value: String.fromCodePoint(codePoint), nextIndex: digitsStart + digitCount };
+}
+function parseBareTomlKey(input, startIndex) {
+  let index = startIndex;
+  while (index < input.length && /[A-Za-z0-9_-]/.test(input[index]))
+    index += 1;
+  if (index === startIndex)
+    return null;
+  return { value: input.slice(startIndex, index), nextIndex: index };
+}
+function skipWhitespace(input, startIndex) {
+  let index = startIndex;
+  while (index < input.length && /\s/.test(input[index]))
+    index += 1;
+  return index;
+}
 
 // packages/omo-codex/src/install/codex-config-toml-sections.ts
 function removeTomlSections(config, shouldRemove) {
@@ -67561,27 +67788,18 @@ function splitTomlSections(config) {
   return sections;
 }
 function parsePluginHeaderKey(header) {
-  const prefix = "plugins.";
-  if (!header.startsWith(prefix))
-    return null;
-  return parseLeadingJsonString(header.slice(prefix.length));
+  const path7 = parseTomlDottedKey(header);
+  return path7?.[0] === "plugins" ? path7[1] ?? null : null;
 }
 function parseAgentHeaderName(header) {
-  const prefix = "agents.";
-  if (!header.startsWith(prefix))
-    return null;
-  const key = header.slice(prefix.length);
-  return key.startsWith('"') ? parseLeadingJsonString(key) : key;
+  const path7 = parseTomlDottedKey(header);
+  return path7?.[0] === "agents" ? path7[1] ?? null : null;
 }
-function parseJsonString(value) {
-  try {
-    const parsed = JSON.parse(value);
-    return typeof parsed === "string" ? parsed : null;
-  } catch (error) {
-    if (error instanceof Error)
-      return null;
+function parseHookStateHeaderKey(header) {
+  const path7 = parseTomlDottedKey(header);
+  if (path7?.[0] !== "hooks" || path7[1] !== "state")
     return null;
-  }
+  return path7[2] ?? null;
 }
 function parseTomlHeader(line) {
   const trimmed = line.trim();
@@ -67589,25 +67807,6 @@ function parseTomlHeader(line) {
     return null;
   return trimmed.slice(1, -1);
 }
-function parseLeadingJsonString(value) {
-  if (!value.startsWith('"'))
-    return parseJsonString(value);
-  let escaped = false;
-  for (let index = 1;index < value.length; index += 1) {
-    const char = value[index];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (char === '"')
-      return parseJsonString(value.slice(0, index + 1));
-  }
-  return null;
-}
 
 // packages/omo-codex/src/install/codex-config-agents.ts
 var LEGACY_MANAGED_CODEX_AGENT_NAMES_TO_PURGE = ["codex-ultrawork-reviewer"];
@@ -67651,12 +67850,12 @@ function tomlKeySegment(value) {
 
 // packages/omo-codex/src/install/codex-config-atomic-write.ts
 import { lstat as lstat5, readlink as readlink3, realpath, rename as rename2, unlink, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename7, dirname as dirname12, isAbsolute as isAbsolute6, join as join35, resolve as resolve11 } from "node:path";
+import { basename as basename8, dirname as dirname13, isAbsolute as isAbsolute6, join as join36, resolve as resolve11 } from "node:path";
 var RENAME_RETRY_DELAYS_MS = [10, 25, 50];
 var RETRIABLE_RENAME_CODES = new Set(["EPERM", "EBUSY"]);
 async function writeFileAtomic(targetPath, data) {
   const writeTarget = await resolveSymlinkTarget(targetPath);
-  const temporaryPath = join35(dirname12(writeTarget), `.tmp-${basename7(writeTarget)}-${process.pid}-${Date.now()}`);
+  const temporaryPath = join36(dirname13(writeTarget), `.tmp-${basename8(writeTarget)}-${process.pid}-${Date.now()}`);
   await writeFile5(temporaryPath, data);
   try {
     await renameWithRetry(temporaryPath, writeTarget);
@@ -67685,7 +67884,7 @@ async function resolveSymlinkTarget(targetPath) {
     if (!(error instanceof Error))
       throw error;
     const linkValue = await readlink3(targetPath);
-    return isAbsolute6(linkValue) ? linkValue : resolve11(dirname12(targetPath), linkValue);
+    return isAbsolute6(linkValue) ? linkValue : resolve11(dirname13(targetPath), linkValue);
   }
 }
 async function renameWithRetry(fromPath, toPath) {
@@ -67744,10 +67943,7 @@ function removeStaleMarketplacePluginBlocks(config, marketplaceName, keepPluginN
 }
 function removeStaleMarketplaceHookStateBlocks(config, marketplaceName, keepPluginNames) {
   return removeTomlSections(config, (header) => {
-    const prefix = "hooks.state.";
-    if (!header.startsWith(prefix))
-      return false;
-    const hookKey = parseJsonString(header.slice(prefix.length));
+    const hookKey = parseHookStateHeaderKey(header);
     if (hookKey === null)
       return false;
     const separator = hookKey.indexOf(":");
@@ -67832,9 +68028,10 @@ enabled = true
 function ensureOmoBuiltinMcpPolicies(config, input) {
   if (input.marketplaceName !== "sisyphuslabs" || !input.pluginNames.includes("omo"))
     return config;
+  const codegraphEnabled = input.codegraphMcpEnabled ?? true;
   const gitBashEnabled = (input.platform ?? process.platform) === "win32" && input.gitBashEnabled === true;
   let nextConfig = ensurePluginMcpEnabled(config, "omo@sisyphuslabs", "context7", true);
-  nextConfig = ensurePluginMcpEnabled(nextConfig, "omo@sisyphuslabs", "codegraph", true);
+  nextConfig = ensurePluginMcpEnabled(nextConfig, "omo@sisyphuslabs", "codegraph", codegraphEnabled);
   nextConfig = ensurePluginMcpEnabled(nextConfig, "omo@sisyphuslabs", "git_bash", gitBashEnabled);
   return nextConfig;
 }
@@ -67927,7 +68124,7 @@ function isRootSetting(line, key) {
 
 // packages/omo-codex/src/install/codex-model-catalog.ts
 import { readFile as readFile9 } from "node:fs/promises";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 var FALLBACK_CODEX_MODEL_CATALOG = {
   current: {
     model: "gpt-5.5",
@@ -67946,7 +68143,7 @@ var FALLBACK_CODEX_MODEL_CATALOG = {
   ]
 };
 async function readCodexModelCatalog(codexPackageRoot) {
-  const catalogPath = join36(codexPackageRoot, "plugin", "model-catalog.json");
+  const catalogPath = join37(codexPackageRoot, "plugin", "model-catalog.json");
   try {
     const parsed = JSON.parse(await readFile9(catalogPath, "utf8"));
     return parseCodexModelCatalog(parsed) ?? FALLBACK_CODEX_MODEL_CATALOG;
@@ -68026,7 +68223,7 @@ function removeLegacyAgentsMaxThreadsSetting(config) {
 
 // packages/omo-codex/src/install/codex-config-toml.ts
 async function updateCodexConfig(input) {
-  await mkdir5(dirname13(input.configPath), { recursive: true });
+  await mkdir5(dirname14(input.configPath), { recursive: true });
   let config = "";
   if (await exists(input.configPath))
     config = await readFile10(input.configPath, "utf8");
@@ -68077,7 +68274,7 @@ async function exists(path7) {
 // packages/omo-codex/src/install/codex-hook-trust.ts
 import { createHash as createHash2 } from "node:crypto";
 import { readFile as readFile11 } from "node:fs/promises";
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 var EVENT_LABELS = new Map([
   ["PreToolUse", "pre_tool_use"],
   ["PermissionRequest", "permission_request"],
@@ -68091,7 +68288,7 @@ var EVENT_LABELS = new Map([
   ["Stop", "stop"]
 ]);
 async function trustedHookStatesForPlugin(input) {
-  const manifestPath = join37(input.pluginRoot, ".codex-plugin", "plugin.json");
+  const manifestPath = join38(input.pluginRoot, ".codex-plugin", "plugin.json");
   if (!await exists2(manifestPath))
     return [];
   const manifest = JSON.parse(await readFile11(manifestPath, "utf8"));
@@ -68099,7 +68296,7 @@ async function trustedHookStatesForPlugin(input) {
     return [];
   const states = [];
   for (const hookPath of hookManifestPaths2(manifest.hooks)) {
-    const hooksPath = join37(input.pluginRoot, hookPath);
+    const hooksPath = join38(input.pluginRoot, hookPath);
     if (!await exists2(hooksPath))
       continue;
     const parsed = JSON.parse(await readFile11(hooksPath, "utf8"));
@@ -68229,11 +68426,11 @@ function toCodexResolution(resolution) {
 
 // packages/omo-codex/src/install/link-cached-plugin-agents.ts
 import { copyFile, lstat as lstat7, mkdir as mkdir6, readFile as readFile13, readdir as readdir4, rm as rm6, writeFile as writeFile6 } from "node:fs/promises";
-import { basename as basename8, join as join39 } from "node:path";
+import { basename as basename9, join as join40 } from "node:path";
 
 // packages/omo-codex/src/install/retired-managed-agent-purge.ts
 import { lstat as lstat6, readFile as readFile12, rm as rm5 } from "node:fs/promises";
-import { join as join38 } from "node:path";
+import { join as join39 } from "node:path";
 var RETIRED_MANAGED_AGENT_FILES = [
   {
     fileName: "codex-ultrawork-reviewer.toml",
@@ -68245,11 +68442,11 @@ var RETIRED_MANAGED_AGENT_FILES = [
   }
 ];
 async function purgeRetiredManagedAgentFiles(input) {
-  const agentsDir = join38(input.codexHome, "agents");
+  const agentsDir = join39(input.codexHome, "agents");
   if (!await exists3(agentsDir))
     return;
   for (const retiredAgent of RETIRED_MANAGED_AGENT_FILES) {
-    const agentPath = join38(agentsDir, retiredAgent.fileName);
+    const agentPath = join39(agentsDir, retiredAgent.fileName);
     if (!await exists3(agentPath))
       continue;
     const agentStat = await lstat6(agentPath);
@@ -68292,7 +68489,7 @@ function nodeErrorCode(error) {
 // packages/omo-codex/src/install/link-cached-plugin-agents.ts
 var MANIFEST_FILE = ".installed-agents.json";
 async function capturePreservedAgentReasoning(input) {
-  const agentsDir = join39(input.codexHome, "agents");
+  const agentsDir = join40(input.codexHome, "agents");
   if (!await exists4(agentsDir))
     return new Map;
   const preserved = new Map;
@@ -68300,7 +68497,7 @@ async function capturePreservedAgentReasoning(input) {
   for (const entry of agentEntries) {
     if (!entry.name.endsWith(".toml"))
       continue;
-    const content = await readTextIfExists2(join39(agentsDir, entry.name));
+    const content = await readTextIfExists2(join40(agentsDir, entry.name));
     if (content === null)
       continue;
     const effort = extractReasoningEffort(content);
@@ -68310,7 +68507,7 @@ async function capturePreservedAgentReasoning(input) {
   return preserved;
 }
 async function capturePreservedAgentServiceTier(input) {
-  const agentsDir = join39(input.codexHome, "agents");
+  const agentsDir = join40(input.codexHome, "agents");
   if (!await exists4(agentsDir))
     return new Map;
   const preserved = new Map;
@@ -68318,7 +68515,7 @@ async function capturePreservedAgentServiceTier(input) {
   for (const entry of agentEntries) {
     if (!entry.name.endsWith(".toml"))
       continue;
-    const content = await readTextIfExists2(join39(agentsDir, entry.name));
+    const content = await readTextIfExists2(join40(agentsDir, entry.name));
     if (content === null)
       continue;
     preserved.set(agentNameFromToml(entry.name), extractServiceTier(content));
@@ -68332,13 +68529,13 @@ async function linkCachedPluginAgents(input) {
     await writeManifest(input.pluginRoot, []);
     return [];
   }
-  const agentsDir = join39(input.codexHome, "agents");
+  const agentsDir = join40(input.codexHome, "agents");
   await mkdir6(agentsDir, { recursive: true });
   const linked = [];
   for (const agentPath of bundledAgents) {
-    const agentFileName = basename8(agentPath);
+    const agentFileName = basename9(agentPath);
     const agentName = agentNameFromToml(agentFileName);
-    const linkPath = join39(agentsDir, agentFileName);
+    const linkPath = join40(agentsDir, agentFileName);
     await replaceWithCopy(linkPath, agentPath);
     await restorePreservedReasoning({
       agentName,
@@ -68368,7 +68565,7 @@ async function restorePreservedServiceTier(input) {
   await writeFile6(input.linkPath, replacement.content);
 }
 async function discoverBundledAgents(pluginRoot) {
-  const componentsRoot = join39(pluginRoot, "components");
+  const componentsRoot = join40(pluginRoot, "components");
   if (!await exists4(componentsRoot))
     return [];
   const componentEntries = await readdir4(componentsRoot, { withFileTypes: true });
@@ -68376,14 +68573,14 @@ async function discoverBundledAgents(pluginRoot) {
   for (const entry of componentEntries) {
     if (!entry.isDirectory())
       continue;
-    const agentsRoot = join39(componentsRoot, entry.name, "agents");
+    const agentsRoot = join40(componentsRoot, entry.name, "agents");
     if (!await exists4(agentsRoot))
       continue;
     const agentEntries = await readdir4(agentsRoot, { withFileTypes: true });
     for (const file2 of agentEntries) {
       if (!file2.isFile() || !file2.name.endsWith(".toml"))
         continue;
-      agents.push(join39(agentsRoot, file2.name));
+      agents.push(join40(agentsRoot, file2.name));
     }
   }
   agents.sort();
@@ -68403,7 +68600,7 @@ async function prepareReplacement(linkPath) {
   await rm6(linkPath, { force: true });
 }
 async function writeManifest(pluginRoot, agentPaths) {
-  const manifestPath = join39(pluginRoot, MANIFEST_FILE);
+  const manifestPath = join40(pluginRoot, MANIFEST_FILE);
   const payload = { agents: [...agentPaths].sort() };
   await writeFile6(manifestPath, `${JSON.stringify(payload, null, "\t")}
 `);
@@ -68442,7 +68639,7 @@ function extractTopLevelStringSetting(content, key) {
     const rawValue = topLevelStringSettingRawValue(line, key);
     if (rawValue === undefined)
       continue;
-    const parsed = parseJsonString2(rawValue);
+    const parsed = parseJsonString(rawValue);
     if (parsed !== null)
       return parsed;
   }
@@ -68503,7 +68700,7 @@ function isSectionHeader2(line) {
 function agentNameFromToml(fileName) {
   return fileName.endsWith(".toml") ? fileName.slice(0, -".toml".length) : fileName;
 }
-function parseJsonString2(value) {
+function parseJsonString(value) {
   try {
     const parsed = JSON.parse(value);
     return typeof parsed === "string" ? parsed : null;
@@ -68531,10 +68728,10 @@ function nodeErrorCode2(error) {
 
 // packages/omo-codex/src/install/codex-marketplace.ts
 import { readFile as readFile14 } from "node:fs/promises";
-import { join as join40 } from "node:path";
+import { join as join41 } from "node:path";
 var DEFAULT_MARKETPLACE_PATH = "packages/omo-codex/marketplace.json";
 async function readMarketplace(repoRoot, options) {
-  const marketplacePath = options?.marketplacePath ?? join40(repoRoot, DEFAULT_MARKETPLACE_PATH);
+  const marketplacePath = options?.marketplacePath ?? join41(repoRoot, DEFAULT_MARKETPLACE_PATH);
   const raw = await readFile14(marketplacePath, "utf8");
   const parsed = JSON.parse(raw);
   if (!isPlainRecord3(parsed))
@@ -68553,10 +68750,10 @@ async function readMarketplace(repoRoot, options) {
 function resolvePluginSource(repoRoot, plugin, options) {
   const sourcePath = localSourcePath(options?.pathOverride ?? plugin.source);
   const relativePath = sourcePath.slice(2);
-  return join40(repoRoot, ...relativePath.split(/[\\/]/));
+  return join41(repoRoot, ...relativePath.split(/[\\/]/));
 }
 async function readPluginManifest(pluginRoot) {
-  const raw = await readFile14(join40(pluginRoot, ".codex-plugin", "plugin.json"), "utf8");
+  const raw = await readFile14(join41(pluginRoot, ".codex-plugin", "plugin.json"), "utf8");
   const parsed = JSON.parse(raw);
   if (!isPlainRecord3(parsed))
     throw new Error(`${pluginRoot} plugin.json must be an object`);
@@ -68638,7 +68835,7 @@ function validateLocalSourcePath(path7) {
 
 // packages/omo-codex/src/install/codex-marketplace-snapshot.ts
 import { cp as cp3, mkdir as mkdir7, rename as rename3, rm as rm7, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join41, sep as sep6 } from "node:path";
+import { join as join42, sep as sep6 } from "node:path";
 var INSTALLED_MARKETPLACES_DIR = ".tmp/marketplaces";
 async function writeInstalledMarketplaceSnapshot(input) {
   const marketplaceRoot = installedMarketplaceRoot(input.codexHome, input.marketplace.name);
@@ -68651,21 +68848,21 @@ async function writeInstalledMarketplaceSnapshot(input) {
   return snapshotPlugins;
 }
 function installedMarketplaceRoot(codexHome, marketplaceName) {
-  return join41(codexHome, INSTALLED_MARKETPLACES_DIR, marketplaceName);
+  return join42(codexHome, INSTALLED_MARKETPLACES_DIR, marketplaceName);
 }
 async function writeMarketplaceManifest(marketplaceRoot, marketplace) {
-  const manifestDir = join41(marketplaceRoot, ".agents", "plugins");
+  const manifestDir = join42(marketplaceRoot, ".agents", "plugins");
   await mkdir7(manifestDir, { recursive: true });
-  const tempPath = join41(manifestDir, `.marketplace-${process.pid}-${Date.now()}.json.tmp`);
+  const tempPath = join42(manifestDir, `.marketplace-${process.pid}-${Date.now()}.json.tmp`);
   await writeFile7(tempPath, `${JSON.stringify(marketplace, null, "\t")}
 `);
-  await rename3(tempPath, join41(manifestDir, "marketplace.json"));
+  await rename3(tempPath, join42(manifestDir, "marketplace.json"));
 }
 async function writeSnapshotPlugin(marketplaceRoot, plugin) {
-  const pluginsDir = join41(marketplaceRoot, "plugins");
+  const pluginsDir = join42(marketplaceRoot, "plugins");
   await mkdir7(pluginsDir, { recursive: true });
-  const targetPath = join41(pluginsDir, plugin.name);
-  const tempPath = join41(pluginsDir, `.tmp-${plugin.name}-${process.pid}-${Date.now()}`);
+  const targetPath = join42(pluginsDir, plugin.name);
+  const tempPath = join42(pluginsDir, `.tmp-${plugin.name}-${process.pid}-${Date.now()}`);
   await rm7(tempPath, { recursive: true, force: true });
   await cp3(plugin.sourcePath, tempPath, {
     recursive: true,
@@ -68687,10 +68884,10 @@ function shouldCopyMarketplaceSourcePath(path7, root) {
 
 // packages/omo-codex/src/install/lazycodex-version-stamp.ts
 import { readdir as readdir5, readFile as readFile15, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 async function readDistributionManifest(repoRoot) {
   try {
-    const parsed = JSON.parse(await readFile15(join42(repoRoot, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile15(join43(repoRoot, "package.json"), "utf8"));
     if (!isPlainRecord3(parsed) || typeof parsed.version !== "string" || parsed.version.trim().length === 0)
       return;
     return {
@@ -68710,19 +68907,19 @@ function resolveLazyCodexPluginVersion(input) {
   return input.manifestVersion ?? "local";
 }
 async function stampLazyCodexPluginVersion(input) {
-  const manifestPath = join42(input.pluginRoot, ".codex-plugin", "plugin.json");
+  const manifestPath = join43(input.pluginRoot, ".codex-plugin", "plugin.json");
   const hookPaths = await readPluginHookPaths(manifestPath);
   await stampJsonVersion(manifestPath, input.version);
-  await stampJsonVersion(join42(input.pluginRoot, "package.json"), input.version);
+  await stampJsonVersion(join43(input.pluginRoot, "package.json"), input.version);
   for (const hookPath of hookPaths) {
-    await stampHookStatusMessages(join42(input.pluginRoot, hookPath), input.version);
+    await stampHookStatusMessages(join43(input.pluginRoot, hookPath), input.version);
   }
   await stampComponentVersions(input);
 }
 async function writeLazyCodexInstallSnapshot(input) {
   if (input.distributionManifest === undefined)
     return;
-  await writeFile8(join42(input.pluginRoot, "lazycodex-install.json"), `${JSON.stringify({
+  await writeFile8(join43(input.pluginRoot, "lazycodex-install.json"), `${JSON.stringify({
     packageName: input.distributionManifest.name,
     version: input.distributionManifest.version
   }, null, "\t")}
@@ -68779,16 +68976,16 @@ async function stampHookStatusMessages(path7, version) {
 async function stampComponentVersions(input) {
   let entries;
   try {
-    entries = await readdir5(join42(input.pluginRoot, "components"));
+    entries = await readdir5(join43(input.pluginRoot, "components"));
   } catch (error) {
     if (error instanceof Error)
       return;
     throw error;
   }
   for (const entry of entries) {
-    const componentRoot = join42(input.pluginRoot, "components", entry);
-    await stampJsonVersion(join42(componentRoot, "package.json"), input.version);
-    await stampHookStatusMessages(join42(componentRoot, "hooks", "hooks.json"), input.version);
+    const componentRoot = join43(input.pluginRoot, "components", entry);
+    await stampJsonVersion(join43(componentRoot, "package.json"), input.version);
+    await stampHookStatusMessages(join43(componentRoot, "hooks", "hooks.json"), input.version);
   }
 }
 function stampHookGroups(hooks, version) {
@@ -68842,7 +69039,7 @@ var defaultRunCommand = async (command, args, options) => {
 
 // packages/omo-codex/src/install/codex-project-local-cleanup.ts
 import { copyFile as copyFile2, lstat as lstat8, readFile as readFile16, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname14, join as join43, resolve as resolve12 } from "node:path";
+import { dirname as dirname15, join as join44, resolve as resolve12 } from "node:path";
 var LEGACY_AGENT_CONFLICT_KEYS = ["max_threads"];
 var PROJECT_LOCAL_ARTIFACT_PATHS = [
   ".codex/hooks.json",
@@ -68945,37 +69142,37 @@ async function findProjectLocalCodexConfigs(startDirectory, codexHome) {
   if (startDirectoryStat !== null && !startDirectoryStat.isDirectory()) {
     throw new ProjectLocalCleanupStartDirectoryError(startDirectory);
   }
-  const codexHomeConfigPath = codexHome === undefined ? null : join43(resolve12(codexHome), "config.toml");
+  const codexHomeConfigPath = codexHome === undefined ? null : join44(resolve12(codexHome), "config.toml");
   let current = resolve12(startDirectory);
   const configPathsFromCwd = [];
   while (true) {
-    const configPath = join43(current, ".codex", "config.toml");
+    const configPath = join44(current, ".codex", "config.toml");
     if (await isRegularProjectLocalConfig(current, configPath)) {
       if (codexHomeConfigPath === null || resolve12(configPath) !== codexHomeConfigPath) {
         configPathsFromCwd.push(configPath);
       }
     }
-    if (await exists5(join43(current, ".git"))) {
+    if (await exists5(join44(current, ".git"))) {
       return configPathsFromCwd.length === 0 ? null : {
         projectRoot: current,
         configPaths: [...configPathsFromCwd].reverse(),
         artifactRoots: artifactRootsForConfigPaths(configPathsFromCwd)
       };
     }
-    const parent = dirname14(current);
+    const parent = dirname15(current);
     if (parent === current) {
       const nearestConfigPath = configPathsFromCwd[0];
       return nearestConfigPath === undefined ? null : {
-        projectRoot: dirname14(dirname14(nearestConfigPath)),
+        projectRoot: dirname15(dirname15(nearestConfigPath)),
         configPaths: [nearestConfigPath],
-        artifactRoots: [dirname14(dirname14(nearestConfigPath))]
+        artifactRoots: [dirname15(dirname15(nearestConfigPath))]
       };
     }
     current = parent;
   }
 }
 async function isRegularProjectLocalConfig(directory, configPath) {
-  const codexDirStat = await maybeLstat(join43(directory, ".codex"));
+  const codexDirStat = await maybeLstat(join44(directory, ".codex"));
   if (codexDirStat === null || !codexDirStat.isDirectory() || codexDirStat.isSymbolicLink())
     return false;
   const configStat = await maybeLstat(configPath);
@@ -68984,7 +69181,7 @@ async function isRegularProjectLocalConfig(directory, configPath) {
 function artifactRootsForConfigPaths(configPaths) {
   const roots = [];
   for (const configPath of configPaths) {
-    const root = dirname14(dirname14(configPath));
+    const root = dirname15(dirname15(configPath));
     if (!roots.includes(root))
       roots.push(root);
   }
@@ -68995,7 +69192,7 @@ async function collectProjectLocalArtifacts(projectRoots) {
   const seenPaths = new Set;
   for (const projectRoot of projectRoots) {
     for (const relativePath of PROJECT_LOCAL_ARTIFACT_PATHS) {
-      const artifactPath = join43(projectRoot, relativePath);
+      const artifactPath = join44(projectRoot, relativePath);
       if (seenPaths.has(artifactPath))
         continue;
       const entryStat = await maybeLstat(artifactPath);
@@ -69072,11 +69269,11 @@ function formatUnknownError(error) {
 // packages/omo-codex/src/install/lsp-daemon-reaper.ts
 import { readFile as readFile17, readdir as readdir6, rm as rm8 } from "node:fs/promises";
 import { connect } from "node:net";
-import { join as join44 } from "node:path";
+import { join as join45 } from "node:path";
 async function reapLspDaemons(codexHome, deps = {}) {
   const killProcess = deps.killProcess ?? sendSigterm;
   const isDaemonLive = deps.isDaemonLive ?? probeSocketLive;
-  const daemonRoot = join44(codexHome, "codex-lsp", "daemon");
+  const daemonRoot = join45(codexHome, "codex-lsp", "daemon");
   const reaped = [];
   let entries;
   try {
@@ -69085,9 +69282,9 @@ async function reapLspDaemons(codexHome, deps = {}) {
     return reaped;
   }
   for (const entry of entries) {
-    const versionDir = join44(daemonRoot, entry);
-    const pid = await readPidFile(join44(versionDir, "daemon.pid"));
-    const socketPath = await readEndpointFile(join44(versionDir, "daemon.endpoint"));
+    const versionDir = join45(daemonRoot, entry);
+    const pid = await readPidFile(join45(versionDir, "daemon.pid"));
+    const socketPath = await readEndpointFile(join45(versionDir, "daemon.endpoint"));
     if (pid !== null && socketPath !== null && await isDaemonLive(socketPath) && killProcess(pid)) {
       reaped.push(pid);
     }
@@ -69141,7 +69338,7 @@ function sendSigterm(pid) {
 
 // packages/omo-codex/src/install/codex-installer-bin-dir.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join45, resolve as resolve13 } from "node:path";
+import { join as join46, resolve as resolve13 } from "node:path";
 function resolveCodexInstallerBinDir(input) {
   const explicitBinDir = input.binDir ?? input.env?.CODEX_LOCAL_BIN_DIR;
   if (explicitBinDir !== undefined && explicitBinDir.trim().length > 0)
@@ -69150,15 +69347,15 @@ function resolveCodexInstallerBinDir(input) {
   const defaultCodexHome = resolve13(homeDir, ".codex");
   const resolvedCodexHome = resolve13(input.codexHome);
   if (resolvedCodexHome !== defaultCodexHome)
-    return join45(resolvedCodexHome, "bin");
+    return join46(resolvedCodexHome, "bin");
   return resolve13(homeDir, ".local", "bin");
 }
 
 // packages/omo-codex/src/install/omo-sot-migration.ts
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 async function seedAndMigrateOmoSot(input) {
   const commandEnv = { ...input.env };
-  const scriptPath = join46(input.repoRoot, "packages", "omo-codex", "plugin", "scripts", "migrate-omo-sot.mjs");
+  const scriptPath = join47(input.repoRoot, "packages", "omo-codex", "plugin", "scripts", "migrate-omo-sot.mjs");
   try {
     await input.runCommand(process.execPath, [scriptPath, "--seed"], {
       cwd: input.repoRoot,
@@ -69173,7 +69370,7 @@ async function seedAndMigrateOmoSot(input) {
 
 // packages/omo-codex/src/install/install-ast-grep-sg.ts
 init_src();
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 function describeResult(result) {
   if (result.kind === "succeeded")
     return null;
@@ -69187,7 +69384,7 @@ async function installAstGrepForCodex(options) {
     return;
   const platform = options.platform ?? process.platform;
   const targetDir = astGrepRuntimeDir(options.codexHome, platform, options.arch ?? process.arch);
-  const skillDir = join47(plugin.path, "skills", "ast-grep");
+  const skillDir = join48(plugin.path, "skills", "ast-grep");
   const installer = options.installer ?? runAstGrepSkillInstall;
   try {
     const result = await installer({ platform, skillDir, targetDir });
@@ -69215,12 +69412,13 @@ async function trackCodexInstallTelemetry() {
 }
 
 // packages/omo-codex/src/install/install-codex.ts
+init_src();
 var SISYPHUS_LEGACY_CACHE_MARKETPLACES = ["lazycodex", "code-yeongyu-codex-plugins"];
 async function runCodexInstaller(options = {}) {
   const env3 = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
   const repoRoot = resolve14(options.repoRoot ?? findRepoRoot({ importerDir: import.meta.dir, env: env3 }));
-  const codexHome = resolve14(options.codexHome ?? env3.CODEX_HOME ?? join50(homedir6(), ".codex"));
+  const codexHome = resolve14(options.codexHome ?? env3.CODEX_HOME ?? join51(homedir6(), ".codex"));
   const projectDirectory = resolve14(options.projectDirectory ?? env3.OMO_CODEX_PROJECT ?? process.cwd());
   const binDir = resolveCodexInstallerBinDir({ binDir: options.binDir, codexHome, env: env3 });
   const runCommand = options.runCommand ?? defaultRunCommand;
@@ -69238,9 +69436,9 @@ async function runCodexInstaller(options = {}) {
   if (!gitBashResolution.found) {
     throw new Error(gitBashResolution.installHint);
   }
-  const codexPackageRoot = join50(repoRoot, "packages", "omo-codex");
+  const codexPackageRoot = join51(repoRoot, "packages", "omo-codex");
   const marketplace = await readMarketplace(repoRoot, {
-    marketplacePath: join50(codexPackageRoot, "marketplace.json")
+    marketplacePath: join51(codexPackageRoot, "marketplace.json")
   });
   const distributionManifest = await readDistributionManifest(repoRoot);
   const installed = [];
@@ -69282,7 +69480,7 @@ async function runCodexInstaller(options = {}) {
       if (runtimeLink !== null)
         log4(`Linked ${runtimeLink.name} -> ${runtimeLink.target}`);
       else
-        log4(`Warning: skipped the omo runtime wrapper because ${join50(repoRoot, "dist", "cli", "index.js")} is missing; omo sparkshell/ulw-loop commands will be unavailable until a package shipping dist/cli is installed`);
+        log4(`Warning: skipped the omo runtime wrapper because ${join51(repoRoot, "dist", "cli", "index.js")} is missing; omo sparkshell/ulw-loop commands will be unavailable until a package shipping dist/cli is installed`);
     }
     pluginSources.push({ name: entry.name, sourcePath });
     installed.push(plugin);
@@ -69335,13 +69533,13 @@ async function runCodexInstaller(options = {}) {
     });
   }
   await reapLspDaemons(codexHome).catch(() => []);
-  const marketplaceRoot = join50(codexHome, "plugins", "cache", marketplace.name);
+  const marketplaceRoot = join51(codexHome, "plugins", "cache", marketplace.name);
   await writeCachedMarketplaceManifest({
     marketplaceName: marketplace.name,
     marketplaceRoot,
     plugins: installed
   });
-  const configPath = join50(codexHome, "config.toml");
+  const configPath = join51(codexHome, "config.toml");
   await updateCodexConfig({
     configPath,
     repoRoot: codexPackageRoot,
@@ -69349,6 +69547,7 @@ async function runCodexInstaller(options = {}) {
     marketplaceSource: codexMarketplaceSource(marketplaceRoot),
     pluginNames: marketplace.plugins.map((plugin) => plugin.name),
     platform,
+    codegraphMcpEnabled: options.codegraphMcpEnabled ?? resolveCodegraphNodeSupport({ env: env3 }).supported,
     gitBashEnabled: platform === "win32" && gitBashResolution.found,
     trustedHookStates,
     agentConfigs: [...agentConfigs.values()].sort((left, right) => left.name.localeCompare(right.name)),
@@ -69400,7 +69599,7 @@ function findRepoRootFromImporter(importerDir) {
   for (let depth = 0;depth <= 7; depth += 1) {
     if (isRepoRootWithCodexPlugin(current))
       return current;
-    for (const wrapperPackageRoot of [join50(current, "node_modules", "oh-my-openagent"), join50(current, "oh-my-openagent")]) {
+    for (const wrapperPackageRoot of [join51(current, "node_modules", "oh-my-openagent"), join51(current, "oh-my-openagent")]) {
       if (isRepoRootWithCodexPlugin(wrapperPackageRoot))
         return wrapperPackageRoot;
     }
@@ -69418,7 +69617,7 @@ function findRepoRoot(input) {
   return findRepoRootFromImporter(input.importerDir);
 }
 function isRepoRootWithCodexPlugin(repoRoot) {
-  return existsSync29(join50(repoRoot, "packages", "omo-codex", "plugin", ".codex-plugin", "plugin.json"));
+  return existsSync30(join51(repoRoot, "packages", "omo-codex", "plugin", ".codex-plugin", "plugin.json"));
 }
 function codexMarketplaceSource(marketplaceRoot) {
   return { sourceType: "local", source: marketplaceRoot };
@@ -69426,7 +69625,7 @@ function codexMarketplaceSource(marketplaceRoot) {
 // packages/omo-codex/src/install/codex-installation-detection.ts
 init_bun_which_shim();
 import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync31 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { posix as posix3, win32 as win323 } from "node:path";
 var CODEX_PATH_CHECK_LABEL = "codex (PATH)";
@@ -69439,7 +69638,7 @@ async function detectCodexInstallation(input = {}) {
   const platform = input.platform ?? process.platform;
   const env3 = input.env ?? process.env;
   const homeDir = input.homeDir ?? homedir7();
-  const exists6 = input.exists ?? existsSync30;
+  const exists6 = input.exists ?? existsSync31;
   const which2 = input.which ?? bunWhich;
   const checkedPaths = [CODEX_PATH_CHECK_LABEL];
   const cliPath = nonEmptyValue2(which2("codex"));
@@ -69555,11 +69754,11 @@ function defaultRunCommand2(command, args) {
 // packages/omo-codex/src/install/codex-cleanup.ts
 import { lstat as lstat10, readFile as readFile19, readdir as readdir7, rm as rm9, rmdir } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { isAbsolute as isAbsolute8, join as join51, relative as relative6, resolve as resolve15 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join53, relative as relative7, resolve as resolve16 } from "node:path";
 
 // packages/omo-codex/src/install/codex-cleanup-config.ts
 import { lstat as lstat9, mkdir as mkdir8, readFile as readFile18, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname16 } from "node:path";
+import { dirname as dirname17 } from "node:path";
 var MANAGED_MARKETPLACES = ["sisyphuslabs", "lazycodex", "code-yeongyu-codex-plugins"];
 var LEGACY_MANAGED_CODEX_AGENT_NAMES_TO_PURGE2 = ["codex-ultrawork-reviewer"];
 var CURRENT_MANAGED_CODEX_AGENT_NAMES2 = [
@@ -69593,7 +69792,7 @@ async function cleanupCodexConfig(configPath, now) {
   if (next === original)
     return { changed: false };
   const backupPath = `${configPath}.backup-${formatBackupTimestamp2(now?.() ?? new Date)}`;
-  await mkdir8(dirname16(configPath), { recursive: true });
+  await mkdir8(dirname17(configPath), { recursive: true });
   await writeFile10(backupPath, original);
   await writeFile10(configPath, `${next.trimEnd()}
 `);
@@ -69604,21 +69803,18 @@ function removeManagedAgentBlocks(config) {
   return splitTomlSections2(config).filter((section) => {
     if (section.header === null)
       return true;
-    const agentName = parseAgentHeaderName2(section.header);
+    const agentName = parseAgentHeaderName(section.header);
     if (agentName === null || !managedAgentNames.has(agentName))
       return true;
     return !section.text.includes(`config_file = ${JSON.stringify(`./agents/${agentName}.toml`)}`);
   }).map((section) => section.text).join("");
 }
 function isManagedPluginHeader(header, marketplace) {
-  const pluginKey = parsePluginHeaderKey2(header);
+  const pluginKey = parsePluginHeaderKey(header);
   return pluginKey !== null && pluginKey.endsWith(`@${marketplace}`);
 }
 function isManagedHookStateHeader(header, marketplace) {
-  const prefix = "hooks.state.";
-  if (!header.startsWith(prefix))
-    return false;
-  const hookKey = parseJsonString3(header.slice(prefix.length));
+  const hookKey = parseHookStateHeaderKey(header);
   if (hookKey === null)
     return false;
   const separator = hookKey.indexOf(":");
@@ -69655,48 +69851,6 @@ function parseTomlHeader2(line) {
     return null;
   return trimmed.slice(1, -1);
 }
-function parsePluginHeaderKey2(header) {
-  const prefix = "plugins.";
-  if (!header.startsWith(prefix))
-    return null;
-  return parseLeadingJsonString2(header.slice(prefix.length));
-}
-function parseAgentHeaderName2(header) {
-  const prefix = "agents.";
-  if (!header.startsWith(prefix))
-    return null;
-  const key = header.slice(prefix.length);
-  return key.startsWith('"') ? parseLeadingJsonString2(key) : key;
-}
-function parseLeadingJsonString2(value) {
-  if (!value.startsWith('"'))
-    return parseJsonString3(value);
-  let escaped = false;
-  for (let index = 1;index < value.length; index += 1) {
-    const char = value[index];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (char === '"')
-      return parseJsonString3(value.slice(0, index + 1));
-  }
-  return null;
-}
-function parseJsonString3(value) {
-  try {
-    const parsed = JSON.parse(value);
-    return typeof parsed === "string" ? parsed : null;
-  } catch (error) {
-    if (error instanceof Error)
-      return null;
-    return null;
-  }
-}
 function formatBackupTimestamp2(date) {
   return date.toISOString().replace(/[:.]/g, "-");
 }
@@ -69716,23 +69870,69 @@ function nodeErrorCode4(error) {
   return typeof error.code === "string" ? error.code : null;
 }
 
+// packages/omo-codex/src/install/codex-cleanup-safety.ts
+import { dirname as dirname18, isAbsolute as isAbsolute8, join as join52, relative as relative6, resolve as resolve15 } from "node:path";
+function validateManagedCleanupTarget(input) {
+  if (!isAbsolute8(input.path))
+    return skipped(input.path, "outside managed Codex cleanup scope");
+  const codexHome = resolve15(input.codexHome);
+  if (dirname18(codexHome) === codexHome)
+    return skipped(input.path, "Codex home resolves to a filesystem root");
+  const target = resolve15(input.path);
+  if (!isWithinDirectory(codexHome, target))
+    return skipped(input.path, "outside managed Codex cleanup scope");
+  if (target === codexHome)
+    return skipped(input.path, "outside managed Codex cleanup scope");
+  const exactManagedRoots = new Set([
+    resolve15(join52(codexHome, "plugins", "cache", "sisyphuslabs")),
+    resolve15(join52(codexHome, ".tmp", "marketplaces", "sisyphuslabs")),
+    resolve15(join52(codexHome, "runtime", "ast-grep")),
+    resolve15(join52(codexHome, "runtime", "node")),
+    resolve15(join52(codexHome, "plugins", "data", "omo-sisyphuslabs", "bootstrap"))
+  ]);
+  if (exactManagedRoots.has(target))
+    return null;
+  if (isManagedBootstrapDriftPath(codexHome, target))
+    return null;
+  return skipped(input.path, "outside managed Codex cleanup scope");
+}
+function isWithinDirectory(parent, child) {
+  const relativePath = relative6(parent, child);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute8(relativePath);
+}
+function isManagedBootstrapDriftPath(codexHome, target) {
+  const relativePath = relative6(codexHome, target);
+  const segments = relativePath.split(/[\\/]/);
+  if (segments[0] !== "plugins")
+    return false;
+  if (segments[segments.length - 1] !== "bootstrap")
+    return false;
+  const ownerName = segments[segments.length - 2];
+  return ownerName !== undefined && ownerName.startsWith("omo") && ownerName.slice("omo".length).includes("sisyphuslabs");
+}
+function skipped(path7, reason) {
+  return { path: path7, reason };
+}
+
 // packages/omo-codex/src/install/codex-cleanup.ts
 var INSTALLED_AGENTS_MANIFEST = ".installed-agents.json";
 async function cleanupCodexLight(input = {}) {
   const env3 = input.env ?? process.env;
-  const codexHome = resolve15(input.codexHome ?? env3.CODEX_HOME ?? join51(homedir8(), ".codex"));
-  const configPath = join51(codexHome, "config.toml");
+  const codexHome = resolve16(input.codexHome ?? env3.CODEX_HOME ?? join53(homedir8(), ".codex"));
+  const configPath = join53(codexHome, "config.toml");
   const agentPaths = await collectInstalledAgentPaths(codexHome, configPath);
   const configCleanup = await cleanupCodexConfig(configPath, input.now);
   const agentCleanup = await removeManifestListedAgentLinks(codexHome, agentPaths);
   const removedPaths = [];
+  const skippedPaths = [];
   const managedStatePaths = new Set([
     ...managedGlobalStatePaths(codexHome),
     ...await collectBootstrapDataDirsByGlob(codexHome)
   ]);
   for (const path7 of managedStatePaths) {
-    if (await removeManagedPathBestEffort(path7))
+    if (await removeManagedPathBestEffort(path7, { codexHome, onSkip: (skip) => skippedPaths.push(skip) })) {
       removedPaths.push(path7);
+    }
   }
   await pruneEmptyRuntimeDirBestEffort(codexHome);
   const projectDirectory = input.projectDirectory ?? env3.OMO_CODEX_PROJECT ?? process.cwd();
@@ -69750,6 +69950,7 @@ async function cleanupCodexLight(input = {}) {
     configChanged: configCleanup.changed,
     configBackupPath: configCleanup.backupPath,
     removedPaths,
+    skippedPaths,
     removedAgentLinks: agentCleanup.removed,
     skippedAgentLinks: agentCleanup.skipped,
     projectCleanup
@@ -69757,17 +69958,17 @@ async function cleanupCodexLight(input = {}) {
 }
 function managedGlobalStatePaths(codexHome) {
   return [
-    join51(codexHome, "plugins", "cache", "sisyphuslabs"),
-    join51(codexHome, ".tmp", "marketplaces", "sisyphuslabs"),
-    join51(codexHome, "runtime", "ast-grep"),
-    join51(codexHome, "runtime", "node"),
-    join51(codexHome, "plugins", "data", "omo-sisyphuslabs", "bootstrap")
+    join53(codexHome, "plugins", "cache", "sisyphuslabs"),
+    join53(codexHome, ".tmp", "marketplaces", "sisyphuslabs"),
+    join53(codexHome, "runtime", "ast-grep"),
+    join53(codexHome, "runtime", "node"),
+    join53(codexHome, "plugins", "data", "omo-sisyphuslabs", "bootstrap")
   ];
 }
 var BOOTSTRAP_DATA_GLOB_MAX_DEPTH = 5;
 async function collectBootstrapDataDirsByGlob(codexHome) {
   const results = [];
-  await walkForManagedBootstrapDirs(join51(codexHome, "plugins"), 0, results);
+  await walkForManagedBootstrapDirs(join53(codexHome, "plugins"), 0, results);
   return results;
 }
 async function walkForManagedBootstrapDirs(directory, depth, results) {
@@ -69779,9 +69980,9 @@ async function walkForManagedBootstrapDirs(directory, depth, results) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const childPath = join51(directory, entry.name);
+    const childPath = join53(directory, entry.name);
     if (isManagedBootstrapOwnerName(entry.name)) {
-      const bootstrapDir = join51(childPath, "bootstrap");
+      const bootstrapDir = join53(childPath, "bootstrap");
       if (await exists6(bootstrapDir))
         results.push(bootstrapDir);
       continue;
@@ -69792,7 +69993,12 @@ async function walkForManagedBootstrapDirs(directory, depth, results) {
 function isManagedBootstrapOwnerName(name) {
   return name.startsWith("omo") && name.slice("omo".length).includes("sisyphuslabs");
 }
-async function removeManagedPathBestEffort(path7, seams = {}) {
+async function removeManagedPathBestEffort(path7, seams) {
+  const skip = validateManagedCleanupTarget({ codexHome: seams.codexHome, path: path7 });
+  if (skip !== null) {
+    seams.onSkip?.(skip);
+    return false;
+  }
   const removedOnFirstAttempt = await attemptRemove(path7);
   await seams.afterFirstAttempt?.();
   const removedOnRetry = await attemptRemove(path7);
@@ -69810,19 +70016,26 @@ async function attemptRemove(path7) {
 }
 async function pruneEmptyRuntimeDirBestEffort(codexHome) {
   try {
-    await rmdir(join51(codexHome, "runtime"));
-  } catch {}
+    await rmdir(join53(codexHome, "runtime"));
+  } catch (error) {
+    if (isExpectedRuntimePruneFailure(error))
+      return;
+    throw error;
+  }
+}
+function isExpectedRuntimePruneFailure(error) {
+  return ["ENOENT", "ENOTEMPTY", "EEXIST", "EPERM", "EBUSY", "ENOTDIR"].includes(nodeErrorCode5(error) ?? "");
 }
 async function collectInstalledAgentPaths(codexHome, configPath) {
   const manifestPaths = [
-    join51(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo", INSTALLED_AGENTS_MANIFEST)
+    join53(codexHome, ".tmp", "marketplaces", "sisyphuslabs", "plugins", "omo", INSTALLED_AGENTS_MANIFEST)
   ];
-  const versionRoot = join51(codexHome, "plugins", "cache", "sisyphuslabs", "omo");
+  const versionRoot = join53(codexHome, "plugins", "cache", "sisyphuslabs", "omo");
   if (await exists6(versionRoot)) {
     const entries = await readdir7(versionRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory())
-        manifestPaths.push(join51(versionRoot, entry.name, INSTALLED_AGENTS_MANIFEST));
+        manifestPaths.push(join53(versionRoot, entry.name, INSTALLED_AGENTS_MANIFEST));
     }
   }
   const paths = new Set;
@@ -69840,7 +70053,7 @@ async function readManagedAgentPathsFromConfig(codexHome, configPath) {
   if (!await exists6(configPath))
     return [];
   const config = await readFile19(configPath, "utf8");
-  return MANAGED_CODEX_AGENT_NAMES2.filter((agentName) => config.includes(`config_file = ${JSON.stringify(`./agents/${agentName}.toml`)}`)).map((agentName) => join51(codexHome, "agents", `${agentName}.toml`));
+  return MANAGED_CODEX_AGENT_NAMES2.filter((agentName) => config.includes(`config_file = ${JSON.stringify(`./agents/${agentName}.toml`)}`)).map((agentName) => join53(codexHome, "agents", `${agentName}.toml`));
 }
 async function readInstalledAgentManifest(manifestPath) {
   if (!await exists6(manifestPath))
@@ -69851,31 +70064,31 @@ async function readInstalledAgentManifest(manifestPath) {
   return parsed.agents.filter((path7) => typeof path7 === "string");
 }
 async function removeManifestListedAgentLinks(codexHome, paths) {
-  const agentsDir = join51(codexHome, "agents");
+  const agentsDir = join53(codexHome, "agents");
   const removed = [];
-  const skipped = [];
+  const skipped2 = [];
   for (const path7 of paths) {
     if (!isSafeManagedAgentPath(agentsDir, path7)) {
-      skipped.push(path7);
+      skipped2.push(path7);
       continue;
     }
     const entryStat = await maybeLstat2(path7);
     if (entryStat === null)
       continue;
     if (entryStat.isDirectory() && !entryStat.isSymbolicLink()) {
-      skipped.push(path7);
+      skipped2.push(path7);
       continue;
     }
     await rm9(path7, { force: true });
     removed.push(path7);
   }
-  return { removed, skipped };
+  return { removed, skipped: skipped2 };
 }
 function isSafeManagedAgentPath(agentsDir, path7) {
-  if (!isAbsolute8(path7))
+  if (!isAbsolute9(path7))
     return false;
-  const relativePath = relative6(agentsDir, path7);
-  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute8(relativePath))
+  const relativePath = relative7(agentsDir, path7);
+  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute9(relativePath))
     return false;
   const fileName = relativePath.split(/[\\/]/).pop();
   if (fileName === undefined)
@@ -69934,23 +70147,23 @@ async function starGitHubRepositories(platform = "both", runCommand = runGitHubS
 init_provider_availability();
 
 // packages/omo-opencode/src/cli/config-manager/add-tui-plugin-to-tui-config.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync10, readFileSync as readFileSync16 } from "node:fs";
-import { join as join53 } from "node:path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync10, readFileSync as readFileSync16 } from "node:fs";
+import { join as join55 } from "node:path";
 
 // packages/omo-opencode/src/cli/doctor/checks/tui-plugin-config.ts
 init_shared();
-import { existsSync as existsSync31, readFileSync as readFileSync15 } from "node:fs";
-import { join as join52 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync15 } from "node:fs";
+import { join as join54 } from "node:path";
 var TUI_SUBPATH = "tui";
 var TUI_EXPORT_SUBPATH = `./${TUI_SUBPATH}`;
 function fileEntryPackageJsonPath(entry) {
   let path7 = entry.slice("file:".length);
   if (path7.startsWith("//"))
     path7 = path7.slice(2);
-  return join52(path7, "package.json");
+  return join54(path7, "package.json");
 }
 function packageJsonExportsTui(pkgJsonPath) {
-  if (!existsSync31(pkgJsonPath))
+  if (!existsSync32(pkgJsonPath))
     return null;
   try {
     const parsed = JSON.parse(readFileSync15(pkgJsonPath, "utf-8"));
@@ -69985,14 +70198,14 @@ function packageExportsTuiForServerEntry(entry) {
   const packageName = packageNameFromServerEntry(entry);
   if (packageName === null)
     return null;
-  return packageJsonExportsTui(join52(getOpenCodeConfigDir({ binary: "opencode" }), "node_modules", packageName, "package.json"));
+  return packageJsonExportsTui(join54(getOpenCodeConfigDir({ binary: "opencode" }), "node_modules", packageName, "package.json"));
 }
 function isOurFilePluginEntry(entry) {
   if (!entry.startsWith("file:"))
     return false;
   try {
     const pkgJsonPath = fileEntryPackageJsonPath(entry);
-    if (!existsSync31(pkgJsonPath))
+    if (!existsSync32(pkgJsonPath))
       return false;
     const parsed = JSON.parse(readFileSync15(pkgJsonPath, "utf-8"));
     return typeof parsed.name === "string" && ACCEPTED_PACKAGE_NAMES.includes(parsed.name);
@@ -70035,7 +70248,7 @@ function isCanonicalNamedTuiPluginEntry(entry) {
 }
 function detectServerPluginRegistration() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  const configPath = existsSync31(paths.configJsonc) ? paths.configJsonc : existsSync31(paths.configJson) ? paths.configJson : null;
+  const configPath = existsSync32(paths.configJsonc) ? paths.configJsonc : existsSync32(paths.configJson) ? paths.configJson : null;
   if (!configPath) {
     return { registered: false, configPath: null, entry: null, packageExportsTui: null };
   }
@@ -70058,8 +70271,8 @@ function detectServerPluginRegistration() {
   }
 }
 function detectTuiPluginRegistration() {
-  const tuiJsonPath = join52(getOpenCodeConfigDir({ binary: "opencode" }), "tui.json");
-  if (!existsSync31(tuiJsonPath)) {
+  const tuiJsonPath = join54(getOpenCodeConfigDir({ binary: "opencode" }), "tui.json");
+  if (!existsSync32(tuiJsonPath)) {
     return {
       registered: false,
       configPath: tuiJsonPath,
@@ -70214,11 +70427,11 @@ function readConfig(path7) {
   return null;
 }
 function readServerConfig(configDir) {
-  const jsoncPath = join53(configDir, "opencode.jsonc");
-  if (existsSync32(jsoncPath))
+  const jsoncPath = join55(configDir, "opencode.jsonc");
+  if (existsSync33(jsoncPath))
     return readConfig(jsoncPath);
-  const jsonPath = join53(configDir, "opencode.json");
-  if (existsSync32(jsonPath))
+  const jsonPath = join55(configDir, "opencode.json");
+  if (existsSync33(jsonPath))
     return readConfig(jsonPath);
   return null;
 }
@@ -70238,7 +70451,7 @@ function desiredTuiEntry(serverEntry) {
   return null;
 }
 function readTuiConfig(tuiJsonPath) {
-  if (!existsSync32(tuiJsonPath)) {
+  if (!existsSync33(tuiJsonPath)) {
     return { config: {}, malformed: false };
   }
   const config = readConfig(tuiJsonPath);
@@ -70259,7 +70472,7 @@ function ensureTuiPluginEntry(opts = {}) {
   if (!desiredEntry) {
     return { changed: false, reason: "no-server-entry" };
   }
-  const tuiJsonPath = join53(configDir, "tui.json");
+  const tuiJsonPath = join55(configDir, "tui.json");
   const { config, malformed } = readTuiConfig(tuiJsonPath);
   if (malformed) {
     return { changed: false, reason: "malformed" };
@@ -70275,7 +70488,7 @@ function ensureTuiPluginEntry(opts = {}) {
 
 // packages/omo-opencode/src/cli/install-ast-grep-sg.ts
 import { homedir as homedir9 } from "node:os";
-import { join as join54 } from "node:path";
+import { join as join56 } from "node:path";
 
 // packages/shared-skills/index.mjs
 import { fileURLToPath } from "node:url";
@@ -70294,9 +70507,9 @@ function describeResult2(result) {
 }
 async function installAstGrepForOpenCode(options = {}) {
   const platform = options.platform ?? process.platform;
-  const baseDir = join54(options.homeDir ?? homedir9(), ".omo");
+  const baseDir = join56(options.homeDir ?? homedir9(), ".omo");
   const targetDir = astGrepRuntimeDir(baseDir, platform, options.arch ?? process.arch);
-  const skillDir = join54(options.sharedSkillsRoot ?? sharedSkillsRootPath(), "ast-grep");
+  const skillDir = join56(options.sharedSkillsRoot ?? sharedSkillsRootPath(), "ast-grep");
   const installer = options.installer ?? runAstGrepSkillInstall;
   try {
     const result = await installer({ platform, skillDir, targetDir });
@@ -72175,6 +72388,9 @@ async function cleanup(options) {
   for (const path7 of result.removedPaths) {
     console.log(`- Removed ${path7}`);
   }
+  for (const skippedPath of result.skippedPaths) {
+    console.log(`- Skipped cleanup target ${skippedPath.path}: ${skippedPath.reason}`);
+  }
   for (const path7 of result.removedAgentLinks) {
     console.log(`- Removed managed agent link ${path7}`);
   }
@@ -87438,6 +87654,7 @@ var ClaudeCodeConfigSchema = exports_external.object({
 });
 // packages/omo-opencode/src/config/schema/codegraph.ts
 var CodegraphConfigSchema = exports_external.object({
+  auto_init: exports_external.boolean().default(true),
   auto_provision: exports_external.boolean().default(true),
   enabled: exports_external.boolean().default(true),
   install_dir: exports_external.string().optional(),
@@ -87677,7 +87894,8 @@ var RuntimeFallbackConfigSchema = exports_external.object({
   max_fallback_attempts: exports_external.number().min(1).max(20).optional(),
   cooldown_seconds: exports_external.number().min(0).optional(),
   timeout_seconds: exports_external.number().min(0).optional(),
-  notify_on_fallback: exports_external.boolean().optional()
+  notify_on_fallback: exports_external.boolean().optional(),
+  restore_primary_after_cooldown: exports_external.boolean().optional()
 });
 
 // packages/team-core/src/config.ts
@@ -88239,7 +88457,7 @@ var import_picocolors11 = __toESM(require_picocolors(), 1);
 // packages/omo-opencode/src/cli/run/opencode-binary-resolver.ts
 init_bun_which_shim();
 init_spawn_with_windows_hide();
-import { delimiter as delimiter2, dirname as dirname18, posix as posix4, win32 as win324 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname20, posix as posix4, win32 as win324 } from "node:path";
 var OPENCODE_COMMANDS = ["opencode", "opencode-desktop"];
 var WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"];
 function getCommandCandidates(platform) {
@@ -88297,7 +88515,7 @@ async function findWorkingOpencodeBinary(pathEnv = process.env.PATH, probe2 = ca
   return null;
 }
 function buildPathWithBinaryFirst(pathEnv, binaryPath) {
-  const preferredDir = dirname18(binaryPath);
+  const preferredDir = dirname20(binaryPath);
   const existing = (pathEnv ?? "").split(delimiter2).filter((entry) => entry.length > 0 && entry !== preferredDir);
   return [preferredDir, ...existing].join(delimiter2);
 }
@@ -88465,7 +88683,7 @@ async function resolveSession(options) {
       if (attempt < SESSION_CREATE_MAX_RETRIES) {
         const delay2 = SESSION_CREATE_RETRY_DELAY_MS * attempt;
         console.log(import_picocolors12.default.dim(`  Retrying in ${delay2}ms...`));
-        await new Promise((resolve16) => setTimeout(resolve16, delay2));
+        await new Promise((resolve17) => setTimeout(resolve17, delay2));
       }
       continue;
     }
@@ -88476,7 +88694,7 @@ async function resolveSession(options) {
     if (attempt < SESSION_CREATE_MAX_RETRIES) {
       const delay2 = SESSION_CREATE_RETRY_DELAY_MS * attempt;
       console.log(import_picocolors12.default.dim(`  Retrying in ${delay2}ms...`));
-      await new Promise((resolve16) => setTimeout(resolve16, delay2));
+      await new Promise((resolve17) => setTimeout(resolve17, delay2));
     }
   }
   throw new Error("Failed to create session after all retries");
@@ -88689,7 +88907,7 @@ var BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`;
 var NOTEPAD_DIR = "notepads";
 var NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`;
 // packages/boulder-state/src/top-level-task.ts
-import { existsSync as existsSync35, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync36, readFileSync as readFileSync18 } from "node:fs";
 var TODO_HEADING_PATTERN = /^##\s+TODOs\b/i;
 var FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i;
 var SECOND_LEVEL_HEADING_PATTERN = /^##\s+/;
@@ -88712,7 +88930,7 @@ function buildTaskRef(section, taskLabel) {
   };
 }
 function readCurrentTopLevelTask(planPath) {
-  if (!existsSync35(planPath)) {
+  if (!existsSync36(planPath)) {
     return null;
   }
   try {
@@ -88741,13 +88959,13 @@ function readCurrentTopLevelTask(planPath) {
   }
 }
 // packages/boulder-state/src/storage/path.ts
-import { existsSync as existsSync36 } from "node:fs";
-import { isAbsolute as isAbsolute9, join as join56, relative as relative7, resolve as resolve16 } from "node:path";
+import { existsSync as existsSync37 } from "node:fs";
+import { isAbsolute as isAbsolute10, join as join58, relative as relative8, resolve as resolve17 } from "node:path";
 function getBoulderFilePath(directory) {
-  return join56(directory, BOULDER_DIR, BOULDER_FILE);
+  return join58(directory, BOULDER_DIR, BOULDER_FILE);
 }
 function resolveTrackedPath(baseDirectory, trackedPath) {
-  return isAbsolute9(trackedPath) ? resolve16(trackedPath) : resolve16(baseDirectory, trackedPath);
+  return isAbsolute10(trackedPath) ? resolve17(trackedPath) : resolve17(baseDirectory, trackedPath);
 }
 function resolveBoulderPlanPath(directory, state) {
   const absolutePlanPath = resolveTrackedPath(directory, state.active_plan);
@@ -88755,20 +88973,20 @@ function resolveBoulderPlanPath(directory, state) {
   if (!worktreePath) {
     return absolutePlanPath;
   }
-  const absoluteDirectory = resolve16(directory);
-  const relativePlanPath = relative7(absoluteDirectory, absolutePlanPath);
-  if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute9(relativePlanPath)) {
+  const absoluteDirectory = resolve17(directory);
+  const relativePlanPath = relative8(absoluteDirectory, absolutePlanPath);
+  if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute10(relativePlanPath)) {
     return absolutePlanPath;
   }
   const absoluteWorktreePath = resolveTrackedPath(directory, worktreePath);
-  const worktreePlanPath = resolve16(absoluteWorktreePath, relativePlanPath);
-  return existsSync36(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
+  const worktreePlanPath = resolve17(absoluteWorktreePath, relativePlanPath);
+  return existsSync37(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
 }
 function resolveBoulderPlanPathForWork(directory, work) {
   return resolveBoulderPlanPath(directory, work);
 }
 // packages/boulder-state/src/storage/plan-progress.ts
-import { existsSync as existsSync37, readFileSync as readFileSync19, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync38, readFileSync as readFileSync19, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
 var TODO_HEADING_PATTERN2 = /^##\s+TODOs\b/i;
 var FINAL_VERIFICATION_HEADING_PATTERN2 = /^##\s+Final Verification Wave\b/i;
 var SECOND_LEVEL_HEADING_PATTERN2 = /^##\s+/;
@@ -88777,7 +88995,7 @@ var CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/;
 var TODO_TASK_PATTERN2 = /^\d+\.\s+/;
 var FINAL_WAVE_TASK_PATTERN2 = /^F\d+\.\s+/i;
 function getPlanProgress(planPath) {
-  if (!existsSync37(planPath)) {
+  if (!existsSync38(planPath)) {
     return { total: 0, completed: 0, isComplete: false };
   }
   try {
@@ -88897,10 +89115,10 @@ function selectMirrorWork(state) {
   return sorted[0] ?? null;
 }
 // packages/boulder-state/src/storage/read-state.ts
-import { existsSync as existsSync38, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync39, readFileSync as readFileSync20 } from "node:fs";
 function readBoulderState(directory) {
   const filePath = getBoulderFilePath(directory);
-  if (!existsSync38(filePath)) {
+  if (!existsSync39(filePath)) {
     return null;
   }
   try {
@@ -88972,14 +89190,14 @@ init_state();
 // packages/omo-opencode/src/features/run-continuation-state/constants.ts
 var CONTINUATION_MARKER_DIR = ".omo/run-continuation";
 // packages/omo-opencode/src/features/run-continuation-state/storage.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync11, readFileSync as readFileSync21, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join57 } from "node:path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync11, readFileSync as readFileSync21, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join59 } from "node:path";
 function getMarkerPath(directory, sessionID) {
-  return join57(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
+  return join59(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`);
 }
 function readContinuationMarker(directory, sessionID) {
   const markerPath = getMarkerPath(directory, sessionID);
-  if (!existsSync39(markerPath))
+  if (!existsSync40(markerPath))
     return null;
   try {
     const raw = readFileSync21(markerPath, "utf-8");
@@ -89048,7 +89266,7 @@ async function isSessionInBoulderLineage(input) {
 init_shared();
 init_compaction_marker();
 import { readFileSync as readFileSync22, readdirSync as readdirSync6 } from "node:fs";
-import { join as join58 } from "node:path";
+import { join as join60 } from "node:path";
 var defaultSessionLastAgentDeps = {
   getMessageDir,
   isSqliteBackend,
@@ -89108,7 +89326,7 @@ async function getLastAgentFromSession(sessionID, client3, deps = {}) {
   try {
     const messages = readdirSync6(messageDir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => {
       try {
-        const content = readFileSync22(join58(messageDir, fileName), "utf-8");
+        const content = readFileSync22(join60(messageDir, fileName), "utf-8");
         const parsed = JSON.parse(content);
         return {
           fileName,
@@ -89151,8 +89369,8 @@ init_agent_display_names();
 
 // packages/omo-opencode/src/hooks/ralph-loop/storage.ts
 init_frontmatter2();
-import { existsSync as existsSync40, readFileSync as readFileSync23, writeFileSync as writeFileSync7, unlinkSync as unlinkSync5, mkdirSync as mkdirSync12 } from "node:fs";
-import { dirname as dirname19, join as join59 } from "node:path";
+import { existsSync as existsSync41, readFileSync as readFileSync23, writeFileSync as writeFileSync7, unlinkSync as unlinkSync5, mkdirSync as mkdirSync12 } from "node:fs";
+import { dirname as dirname21, join as join61 } from "node:path";
 
 // packages/omo-opencode/src/hooks/ralph-loop/constants.ts
 var DEFAULT_STATE_FILE = ".omo/ralph-loop.local.md";
@@ -89161,11 +89379,11 @@ var DEFAULT_COMPLETION_PROMISE = "DONE";
 
 // packages/omo-opencode/src/hooks/ralph-loop/storage.ts
 function getStateFilePath(directory, customPath) {
-  return customPath ? join59(directory, customPath) : join59(directory, DEFAULT_STATE_FILE);
+  return customPath ? join61(directory, customPath) : join61(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync40(filePath)) {
+  if (!existsSync41(filePath)) {
     return null;
   }
   try {
@@ -89400,7 +89618,7 @@ async function pollForCompletion(ctx, eventState, abortController, options = {})
   let secondaryTimeoutChecked = false;
   const pollStartTimestamp = Date.now();
   while (!abortController.signal.aborted) {
-    await new Promise((resolve17) => setTimeout(resolve17, pollIntervalMs));
+    await new Promise((resolve18) => setTimeout(resolve18, pollIntervalMs));
     if (abortController.signal.aborted) {
       return 130;
     }
@@ -89558,7 +89776,7 @@ function createAbortError() {
   return error51;
 }
 function sleep(delayMs) {
-  return new Promise((resolve17) => setTimeout(resolve17, delayMs));
+  return new Promise((resolve18) => setTimeout(resolve18, delayMs));
 }
 function hasPromptStartEvidence(eventState) {
   return eventState.mainSessionStarted || eventState.hasReceivedMeaningfulWork || eventState.messageCount > 0 || eventState.currentTool !== null;
@@ -89779,7 +89997,7 @@ function getPostHogActivityCaptureState2(now = new Date) {
 // packages/omo-opencode/src/shared/posthog.ts
 var activityStateProviderOverride2 = null;
 var osProviderOverride3 = null;
-var transportFactoryOverride = null;
+var transportFactoryOverride2 = null;
 function resolveActivityState() {
   return (activityStateProviderOverride2 ?? getPostHogActivityCaptureState2)();
 }
@@ -89787,7 +90005,7 @@ function resolveOsProvider2() {
   return osProviderOverride3 ?? os5;
 }
 function resolveTransportFactory() {
-  return transportFactoryOverride ?? createDefaultPostHogTransport;
+  return transportFactoryOverride2 ?? createDefaultPostHogTransport;
 }
 var NO_OP_POSTHOG2 = {
   trackActive: () => {
@@ -89964,7 +90182,7 @@ var EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2000;
 async function waitForEventProcessorShutdown(eventProcessor, timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS) {
   const completed = await Promise.race([
     eventProcessor.then(() => true),
-    new Promise((resolve17) => setTimeout(() => resolve17(false), timeoutMs))
+    new Promise((resolve18) => setTimeout(() => resolve18(false), timeoutMs))
   ]);
 }
 async function run(options) {
@@ -90267,14 +90485,14 @@ async function getLocalVersion(options = {}) {
   }
 }
 // packages/omo-opencode/src/cli/doctor/checks/system.ts
-import { existsSync as existsSync51, readFileSync as readFileSync33 } from "node:fs";
+import { existsSync as existsSync52, readFileSync as readFileSync33 } from "node:fs";
 
 // packages/omo-opencode/src/cli/doctor/checks/system-binary.ts
 init_extract_semver();
 init_bun_which_shim();
-import { existsSync as existsSync48, accessSync as accessSync4, constants as constants9 } from "node:fs";
+import { existsSync as existsSync49, accessSync as accessSync4, constants as constants9 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { join as join66 } from "node:path";
+import { join as join68 } from "node:path";
 
 // packages/omo-opencode/src/cli/doctor/framework/spawn-with-timeout.ts
 init_spawn_with_windows_hide();
@@ -90313,8 +90531,8 @@ async function spawnWithTimeout(command, options, timeoutMs = DEFAULT_SPAWN_TIME
   const stdoutPromise = readSpawnStream(proc.stdout);
   const stderrPromise = readSpawnStream(proc.stderr);
   let timer;
-  const timeoutPromise = new Promise((resolve17) => {
-    timer = setTimeout(() => resolve17("timeout"), timeoutMs);
+  const timeoutPromise = new Promise((resolve18) => {
+    timer = setTimeout(() => resolve18("timeout"), timeoutMs);
   });
   const processPromise = (async () => {
     await proc.exited;
@@ -90366,17 +90584,17 @@ function getDesktopAppPaths(platform) {
     case "darwin":
       return [
         "/Applications/OpenCode.app/Contents/MacOS/OpenCode",
-        join66(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
+        join68(home, "Applications", "OpenCode.app", "Contents", "MacOS", "OpenCode")
       ];
     case "win32": {
       const programFiles = process.env.ProgramFiles;
       const localAppData = process.env.LOCALAPPDATA;
       const paths = [];
       if (programFiles) {
-        paths.push(join66(programFiles, "OpenCode", "OpenCode.exe"));
+        paths.push(join68(programFiles, "OpenCode", "OpenCode.exe"));
       }
       if (localAppData) {
-        paths.push(join66(localAppData, "OpenCode", "OpenCode.exe"));
+        paths.push(join68(localAppData, "OpenCode", "OpenCode.exe"));
       }
       return paths;
     }
@@ -90384,8 +90602,8 @@ function getDesktopAppPaths(platform) {
       return [
         "/usr/bin/opencode",
         "/usr/lib/opencode/opencode",
-        join66(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
-        join66(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
+        join68(home, "Applications", "opencode-desktop-linux-x86_64.AppImage"),
+        join68(home, "Applications", "opencode-desktop-linux-aarch64.AppImage")
       ];
     default:
       return [];
@@ -90397,7 +90615,7 @@ function buildVersionCommand(binaryPath, platform) {
   }
   return [binaryPath, "--version"];
 }
-function findDesktopBinary(platform = process.platform, checkExists = existsSync48) {
+function findDesktopBinary(platform = process.platform, checkExists = existsSync49) {
   for (const desktopPath of getDesktopAppPaths(platform)) {
     if (checkExists(desktopPath)) {
       return { binary: "opencode", path: desktopPath };
@@ -90405,7 +90623,7 @@ function findDesktopBinary(platform = process.platform, checkExists = existsSync
   }
   return null;
 }
-async function findOpenCodeBinary(platform = process.platform, checkExists = existsSync48) {
+async function findOpenCodeBinary(platform = process.platform, checkExists = existsSync49) {
   for (const binary of OPENCODE_BINARIES2) {
     const path14 = bunWhich(binary);
     if (path14 && checkExists(path14)) {
@@ -90417,7 +90635,7 @@ async function findOpenCodeBinary(platform = process.platform, checkExists = exi
   const candidates = getCommandCandidates2(platform);
   for (const entry of pathEnv.split(delimiter3).filter(Boolean)) {
     for (const command of candidates) {
-      const fullPath = join66(entry, command);
+      const fullPath = join68(entry, command);
       if (checkExists(fullPath) && isExecutable2(fullPath)) {
         return { binary: command, path: fullPath };
       }
@@ -90463,12 +90681,12 @@ function compareVersions3(current, minimum) {
 
 // packages/omo-opencode/src/cli/doctor/checks/system-plugin.ts
 init_shared();
-import { existsSync as existsSync49, readFileSync as readFileSync31 } from "node:fs";
+import { existsSync as existsSync50, readFileSync as readFileSync31 } from "node:fs";
 function detectConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-  if (existsSync49(paths.configJsonc))
+  if (existsSync50(paths.configJsonc))
     return paths.configJsonc;
-  if (existsSync49(paths.configJson))
+  if (existsSync50(paths.configJson))
     return paths.configJson;
   return null;
 }
@@ -90556,36 +90774,36 @@ init_file_utils2();
 init_checker();
 init_auto_update_checker();
 init_package_json_locator();
-import { existsSync as existsSync50, readFileSync as readFileSync32, readdirSync as readdirSync8 } from "node:fs";
+import { existsSync as existsSync51, readFileSync as readFileSync32, readdirSync as readdirSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir14 } from "node:os";
-import { join as join67 } from "node:path";
+import { join as join69 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 init_shared();
 function getPlatformDefaultCacheDir(platform = process.platform) {
   if (platform === "darwin")
-    return join67(homedir14(), "Library", "Caches");
+    return join69(homedir14(), "Library", "Caches");
   if (platform === "win32")
-    return process.env.LOCALAPPDATA ?? join67(homedir14(), "AppData", "Local");
-  return join67(homedir14(), ".cache");
+    return process.env.LOCALAPPDATA ?? join69(homedir14(), "AppData", "Local");
+  return join69(homedir14(), ".cache");
 }
 function resolveOpenCodeCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME;
   if (xdgCacheHome)
-    return join67(xdgCacheHome, "opencode");
+    return join69(xdgCacheHome, "opencode");
   const fromShared = getOpenCodeCacheDir();
-  const platformDefault = join67(getPlatformDefaultCacheDir(), "opencode");
-  if (existsSync50(fromShared) || !existsSync50(platformDefault))
+  const platformDefault = join69(getPlatformDefaultCacheDir(), "opencode");
+  if (existsSync51(fromShared) || !existsSync51(platformDefault))
     return fromShared;
   return platformDefault;
 }
 function resolveExistingDir(dirPath) {
-  if (!existsSync50(dirPath))
+  if (!existsSync51(dirPath))
     return dirPath;
   return resolveSymlink(dirPath);
 }
 function readPackageJson(filePath) {
-  if (!existsSync50(filePath))
+  if (!existsSync51(filePath))
     return null;
   try {
     const content = readFileSync32(filePath, "utf-8");
@@ -90606,26 +90824,26 @@ function normalizeVersion(value) {
 function createPackageCandidates(rootDir) {
   return ACCEPTED_PACKAGE_NAMES.map((packageName) => ({
     packageName,
-    installedPackagePath: join67(rootDir, "node_modules", packageName, "package.json")
+    installedPackagePath: join69(rootDir, "node_modules", packageName, "package.json")
   }));
 }
 function createTaggedInstallCandidates(rootDir) {
-  const packagesDir = join67(rootDir, "packages");
-  if (!existsSync50(packagesDir))
+  const packagesDir = join69(rootDir, "packages");
+  if (!existsSync51(packagesDir))
     return [];
   const candidates = [];
   for (const entryName of readdirSync8(packagesDir).sort()) {
     const packageName = ACCEPTED_PACKAGE_NAMES.find((name) => entryName.startsWith(`${name}@`));
     if (packageName === undefined)
       continue;
-    const installDir = join67(packagesDir, entryName);
+    const installDir = join69(packagesDir, entryName);
     candidates.push({
       cacheDir: installDir,
-      cachePackagePath: join67(installDir, "package.json"),
+      cachePackagePath: join69(installDir, "package.json"),
       packageCandidates: [
         {
           packageName,
-          installedPackagePath: join67(installDir, "node_modules", packageName, "package.json")
+          installedPackagePath: join69(installDir, "node_modules", packageName, "package.json")
         }
       ]
     });
@@ -90633,7 +90851,7 @@ function createTaggedInstallCandidates(rootDir) {
   return candidates;
 }
 function selectInstalledPackage(candidate) {
-  return candidate.packageCandidates.find((packageCandidate) => existsSync50(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
+  return candidate.packageCandidates.find((packageCandidate) => existsSync51(packageCandidate.installedPackagePath)) ?? candidate.packageCandidates[0];
 }
 function getExpectedVersion(cachePackage, packageName) {
   return normalizeVersion(cachePackage?.dependencies?.[packageName]) ?? normalizeVersion(cachePackage?.dependencies?.[PACKAGE_NAME]);
@@ -90644,7 +90862,7 @@ function resolveInstalledPackageJsonPath() {
     for (const packageName of ACCEPTED_PACKAGE_NAMES) {
       try {
         const packageJsonPath = require2.resolve(`${packageName}/package.json`);
-        if (existsSync50(packageJsonPath)) {
+        if (existsSync51(packageJsonPath)) {
           return { packageName, packageJsonPath };
         }
       } catch {
@@ -90670,22 +90888,22 @@ function getLoadedPluginVersion() {
   const candidates = [
     {
       cacheDir: configDir,
-      cachePackagePath: join67(configDir, "package.json"),
+      cachePackagePath: join69(configDir, "package.json"),
       packageCandidates: createPackageCandidates(configDir)
     },
     ...createTaggedInstallCandidates(configDir),
     {
       cacheDir,
-      cachePackagePath: join67(cacheDir, "package.json"),
+      cachePackagePath: join69(cacheDir, "package.json"),
       packageCandidates: createPackageCandidates(cacheDir)
     },
     ...createTaggedInstallCandidates(cacheDir)
   ];
-  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync50(packageCandidate.installedPackagePath))) ?? candidates[0];
+  const selectedCandidate = candidates.find((candidate) => candidate.packageCandidates.some((packageCandidate) => existsSync51(packageCandidate.installedPackagePath))) ?? candidates[0];
   const { cacheDir: selectedDir, cachePackagePath } = selectedCandidate;
   const selectedPackage = selectInstalledPackage(selectedCandidate);
   const candidateInstalledPath = selectedPackage.installedPackagePath;
-  const candidateExists = existsSync50(candidateInstalledPath);
+  const candidateExists = existsSync51(candidateInstalledPath);
   const resolvedFallback = candidateExists ? null : resolveInstalledPackageJsonPath();
   const installedPackagePath = resolvedFallback?.packageJsonPath ?? candidateInstalledPath;
   const resolvedPackageName = resolvedFallback?.packageName ?? selectedPackage.packageName;
@@ -90721,7 +90939,7 @@ var defaultDeps6 = {
   getLoadedPluginVersion,
   getLatestPluginVersion,
   getSuggestedInstallTag,
-  configExists: existsSync51,
+  configExists: existsSync52,
   readConfigFile: (path14) => readFileSync33(path14, "utf-8"),
   parseConfigContent: (content) => parseJsonc(content)
 };
@@ -90865,7 +91083,7 @@ async function checkSystem(deps = defaultDeps6) {
 init_src();
 import { readFileSync as readFileSync34 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import { dirname as dirname24, relative as relative8 } from "node:path";
+import { dirname as dirname26, relative as relative9 } from "node:path";
 init_shared();
 init_plugin_identity();
 function resolveHomeDirectory2() {
@@ -90889,11 +91107,11 @@ function discoverProjectLayersNearestFirst(directory) {
   const stopDirectory = containsPath(homeDirectory, directory) ? homeDirectory : directory;
   return findProjectOpencodePluginConfigFiles(directory, stopDirectory).map((configPath) => ({
     path: configPath,
-    configDir: dirname24(configPath)
+    configDir: dirname26(configPath)
   }));
 }
 function shortPath(configPath) {
-  const candidate = relative8(process.cwd(), configPath);
+  const candidate = relative9(process.cwd(), configPath);
   return candidate.length > 0 ? candidate : configPath;
 }
 function formatIssuePath(path14) {
@@ -90913,7 +91131,7 @@ function parseLayerConfig(configPath) {
     if (!isPlainRecord(rawConfig)) {
       return {
         path: configPath,
-        configDir: dirname24(configPath),
+        configDir: dirname26(configPath),
         config: null,
         messages: [`${shortPath(configPath)}: <root>: Expected object`]
       };
@@ -90921,7 +91139,7 @@ function parseLayerConfig(configPath) {
     const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
     return {
       path: configPath,
-      configDir: dirname24(configPath),
+      configDir: dirname26(configPath),
       config: result.success ? result.data : parseConfigPartially(rawConfig),
       messages: schemaMessages(configPath, rawConfig)
     };
@@ -90931,7 +91149,7 @@ function parseLayerConfig(configPath) {
     }
     return {
       path: configPath,
-      configDir: dirname24(configPath),
+      configDir: dirname26(configPath),
       config: null,
       messages: [`${shortPath(configPath)}: ${error51.message}`]
     };
@@ -90977,23 +91195,23 @@ function validatePluginConfig(directory) {
 
 // packages/omo-opencode/src/cli/doctor/checks/model-resolution-cache.ts
 init_shared();
-import { existsSync as existsSync52, readFileSync as readFileSync35 } from "node:fs";
+import { existsSync as existsSync53, readFileSync as readFileSync35 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
-import { join as join68 } from "node:path";
+import { join as join70 } from "node:path";
 function getUserConfigDir2() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig)
-    return join68(xdgConfig, "opencode");
-  return join68(homedir16(), ".config", "opencode");
+    return join70(xdgConfig, "opencode");
+  return join70(homedir16(), ".config", "opencode");
 }
 function loadCustomProviderNames() {
   const configDir = getUserConfigDir2();
   const candidatePaths = [
-    join68(configDir, "opencode.json"),
-    join68(configDir, "opencode.jsonc")
+    join70(configDir, "opencode.json"),
+    join70(configDir, "opencode.jsonc")
   ];
   for (const configPath of candidatePaths) {
-    if (!existsSync52(configPath))
+    if (!existsSync53(configPath))
       continue;
     try {
       const content = readFileSync35(configPath, "utf-8");
@@ -91011,9 +91229,9 @@ function loadCustomProviderNames() {
   return [];
 }
 function loadAvailableModelsFromCache() {
-  const cacheFile = join68(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join70(getOpenCodeCacheDir(), "models.json");
   const customProviders = loadCustomProviderNames();
-  if (!existsSync52(cacheFile)) {
+  if (!existsSync53(cacheFile)) {
     if (customProviders.length > 0) {
       return { providers: customProviders, modelCount: 0, cacheExists: true };
     }
@@ -91048,8 +91266,8 @@ init_model_capabilities2();
 init_shared();
 init_plugin_identity();
 import { readFileSync as readFileSync36 } from "node:fs";
-import { join as join69 } from "node:path";
-var PROJECT_CONFIG_DIR = join69(process.cwd(), ".opencode");
+import { join as join71 } from "node:path";
+var PROJECT_CONFIG_DIR = join71(process.cwd(), ".opencode");
 function loadOmoConfig() {
   const projectDetected = detectPluginConfigFile(PROJECT_CONFIG_DIR, {
     basenames: [CONFIG_BASENAME],
@@ -91087,7 +91305,7 @@ function loadOmoConfig() {
 
 // packages/omo-opencode/src/cli/doctor/checks/model-resolution-details.ts
 init_shared();
-import { join as join70 } from "node:path";
+import { join as join72 } from "node:path";
 
 // packages/omo-opencode/src/cli/doctor/checks/model-resolution-variant.ts
 function formatModelWithVariant(model, variant) {
@@ -91129,7 +91347,7 @@ function formatCapabilityResolutionLabel(mode) {
 }
 function buildModelResolutionDetails(options) {
   const details = [];
-  const cacheFile = join70(getOpenCodeCacheDir(), "models.json");
+  const cacheFile = join72(getOpenCodeCacheDir(), "models.json");
   details.push("═══ Available Models (from cache) ═══");
   details.push("");
   if (options.available.cacheExists) {
@@ -91405,28 +91623,28 @@ async function checkConfig() {
 
 // packages/omo-opencode/src/cli/doctor/checks/dependencies.ts
 init_src();
-import { existsSync as existsSync53 } from "node:fs";
+import { existsSync as existsSync54 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname25, join as join72 } from "node:path";
+import { dirname as dirname27, join as join74 } from "node:path";
 
 // packages/omo-opencode/src/hooks/comment-checker/downloader.ts
-import { join as join71 } from "path";
+import { join as join73 } from "path";
 import { homedir as homedir17, tmpdir as tmpdir3 } from "os";
 init_binary_downloader();
 init_logger2();
 init_plugin_identity();
 var DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1";
-var DEBUG_FILE = join71(tmpdir3(), "comment-checker-debug.log");
+var DEBUG_FILE = join73(tmpdir3(), "comment-checker-debug.log");
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join71(homedir17(), "AppData", "Local");
-    return join71(base2, CACHE_DIR_NAME, "bin");
+    const base2 = localAppData || join73(homedir17(), "AppData", "Local");
+    return join73(base2, CACHE_DIR_NAME, "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join71(homedir17(), ".cache");
-  return join71(base, CACHE_DIR_NAME, "bin");
+  const base = xdgCache || join73(homedir17(), ".cache");
+  return join73(base, CACHE_DIR_NAME, "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
@@ -91476,7 +91694,7 @@ async function getBinaryVersion(binary) {
   }
 }
 async function checkAstGrepCli() {
-  const runtimeDir = astGrepRuntimeDir(join72(homedir18(), ".omo"));
+  const runtimeDir = astGrepRuntimeDir(join74(homedir18(), ".omo"));
   const sgPath = findSgBinarySync({ runtimeDir });
   if (sgPath === null) {
     return {
@@ -91505,12 +91723,12 @@ function findCommentCheckerPackageBinary(baseDirOverride, resolvePackageJsonPath
   const binaryName = process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
   const platformKey = `${process.platform}-${process.arch === "x64" ? "x64" : process.arch}`;
   try {
-    const packageDir = baseDirOverride ?? dirname25(resolvePackageJsonPath());
-    const vendorPath = join72(packageDir, "vendor", platformKey, binaryName);
-    if (existsSync53(vendorPath))
+    const packageDir = baseDirOverride ?? dirname27(resolvePackageJsonPath());
+    const vendorPath = join74(packageDir, "vendor", platformKey, binaryName);
+    if (existsSync54(vendorPath))
       return vendorPath;
-    const binPath = join72(packageDir, "bin", binaryName);
-    if (existsSync53(binPath))
+    const binPath = join74(packageDir, "bin", binaryName);
+    if (existsSync54(binPath))
       return binPath;
   } catch (error51) {
     if (!(error51 instanceof Error) && !isModuleResolutionFailure(error51))
@@ -91655,11 +91873,11 @@ async function getGhCliInfo(dependencies = {}) {
 
 // packages/omo-opencode/src/cli/doctor/checks/tools-lsp.ts
 import { readFileSync as readFileSync37 } from "node:fs";
-import { join as join73 } from "node:path";
+import { join as join75 } from "node:path";
 
 // packages/omo-opencode/src/mcp/lsp.ts
-import { existsSync as existsSync54 } from "node:fs";
-import { delimiter as delimiter3, dirname as dirname26, resolve as resolve18 } from "node:path";
+import { existsSync as existsSync55 } from "node:fs";
+import { delimiter as delimiter3, dirname as dirname28, resolve as resolve19 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // packages/omo-opencode/src/mcp/cli-suffix.ts
@@ -91672,7 +91890,7 @@ function hasCliSuffix(candidatePath, suffix) {
 
 // packages/omo-opencode/src/mcp/runtime-executable.ts
 init_bun_which_shim();
-import { basename as basename11 } from "node:path";
+import { basename as basename12 } from "node:path";
 var NODE_EXECUTABLE_NAMES = new Set(["node", "node.exe"]);
 function isUnsafeCommandName2(commandName) {
   if (commandName.length === 0)
@@ -91688,7 +91906,7 @@ function isUnsafeCommandName2(commandName) {
   return false;
 }
 function isNodeExecPath(execPath) {
-  return NODE_EXECUTABLE_NAMES.has(basename11(execPath).toLowerCase());
+  return NODE_EXECUTABLE_NAMES.has(basename12(execPath).toLowerCase());
 }
 function resolveRuntimeExecutable(commandName, options = {}) {
   if (isUnsafeCommandName2(commandName)) {
@@ -91706,7 +91924,7 @@ function resolveRuntimeExecutable(commandName, options = {}) {
 }
 
 // packages/omo-opencode/src/mcp/shared/ancestor-cli-resolver.ts
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 function resolveJavaScriptRuntime(resolveExecutable) {
   const node = resolveExecutable("node");
   return node.available ? node : resolveExecutable("bun");
@@ -91714,9 +91932,9 @@ function resolveJavaScriptRuntime(resolveExecutable) {
 function createAncestorCliCandidates(options) {
   const candidates = [];
   const seenPaths = new Set;
-  let currentDirectory = resolve17(options.startDirectory);
+  let currentDirectory = resolve18(options.startDirectory);
   while (true) {
-    const distCliPath = resolve17(currentDirectory, options.packageRel, options.distCliRel);
+    const distCliPath = resolve18(currentDirectory, options.packageRel, options.distCliRel);
     if (!seenPaths.has(distCliPath)) {
       const runtime5 = resolveJavaScriptRuntime(options.resolveExecutable);
       seenPaths.add(distCliPath);
@@ -91728,7 +91946,7 @@ function createAncestorCliCandidates(options) {
         runtimeAvailable: runtime5.available
       });
     }
-    const sourceCliPath = resolve17(currentDirectory, options.packageRel, options.sourceCliRel);
+    const sourceCliPath = resolve18(currentDirectory, options.packageRel, options.sourceCliRel);
     if (!seenPaths.has(sourceCliPath)) {
       const runtime5 = options.resolveExecutable("bun");
       const sourceCandidateAvailable = options.isSourceCandidateAvailable?.({
@@ -91745,7 +91963,7 @@ function createAncestorCliCandidates(options) {
         runtimeAvailable: runtime5.available
       });
     }
-    const parentDirectory = resolve17(currentDirectory, "..");
+    const parentDirectory = resolve18(currentDirectory, "..");
     if (parentDirectory === currentDirectory)
       return candidates;
     currentDirectory = parentDirectory;
@@ -91781,7 +91999,7 @@ var LSP_BOOTSTRAP_SCRIPT = [
 ].join(";");
 function getModuleDirectory(moduleUrl) {
   try {
-    return dirname26(fileURLToPath6(moduleUrl));
+    return dirname28(fileURLToPath6(moduleUrl));
   } catch (error51) {
     if (!(error51 instanceof Error))
       throw error51;
@@ -91789,23 +92007,23 @@ function getModuleDirectory(moduleUrl) {
   }
 }
 function findBootstrapRoot(candidates, pathExists) {
-  return candidates.find((candidate) => pathExists(resolve18(candidate.root, "package.json")))?.root ?? process.cwd();
+  return candidates.find((candidate) => pathExists(resolve19(candidate.root, "package.json")))?.root ?? process.cwd();
 }
 function createBootstrapCandidate(root, pathExists, resolveExecutable) {
   const runtime5 = resolveJavaScriptRuntime(resolveExecutable);
   const bun = resolveExecutable("bun");
   const npm = resolveExecutable("npm");
-  const packageManifestPath = resolve18(root, PACKAGE_REL, "package.json");
+  const packageManifestPath = resolve19(root, PACKAGE_REL, "package.json");
   return {
     command: [runtime5.command, "-e", LSP_BOOTSTRAP_SCRIPT, root, npm.command, bun.command],
     root,
-    path: resolve18(root, PACKAGE_REL, DIST_CLI_REL),
+    path: resolve19(root, PACKAGE_REL, DIST_CLI_REL),
     exists: runtime5.available && npm.available && pathExists(packageManifestPath),
     runtimeAvailable: runtime5.available
   };
 }
 function resolveLspCommand(options = {}) {
-  const pathExists = options.exists ?? existsSync54;
+  const pathExists = options.exists ?? existsSync55;
   const resolveExecutable = options.resolveExecutable ?? resolveRuntimeExecutable;
   const moduleDirectory = getModuleDirectory(options.moduleUrl ?? import.meta.url);
   const candidates = moduleDirectory ? createAncestorCliCandidates({
@@ -91815,7 +92033,7 @@ function resolveLspCommand(options = {}) {
     sourceCliRel: SOURCE_CLI_REL,
     pathExists,
     resolveExecutable,
-    isSourceCandidateAvailable: ({ root }) => pathExists(resolve18(root, LSP_TOOLS_PACKAGE_REL, DIST_CLI_REL))
+    isSourceCandidateAvailable: ({ root }) => pathExists(resolve19(root, LSP_TOOLS_PACKAGE_REL, DIST_CLI_REL))
   }) : [];
   const distCandidate = candidates.find((candidate) => hasCliSuffix(candidate.path, DIST_CLI_REL) && candidate.exists);
   if (distCandidate) {
@@ -91862,7 +92080,7 @@ function readOmoConfig(configDirectory) {
 }
 function isLspMcpDisabled(options) {
   const userConfigDirectory = options.configDirectory ?? getOpenCodeConfigDir({ binary: "opencode" });
-  const projectConfigDirectory = join73(options.cwd ?? process.cwd(), ".opencode");
+  const projectConfigDirectory = join75(options.cwd ?? process.cwd(), ".opencode");
   const userConfig = readOmoConfig(userConfigDirectory);
   const projectConfig = readOmoConfig(projectConfigDirectory);
   const disabledMcps = new Set([
@@ -91881,21 +92099,21 @@ function getInstalledLspServers(options = {}) {
 
 // packages/omo-opencode/src/cli/doctor/checks/tools-mcp.ts
 init_shared();
-import { existsSync as existsSync55, readFileSync as readFileSync38 } from "node:fs";
+import { existsSync as existsSync56, readFileSync as readFileSync38 } from "node:fs";
 import { homedir as homedir19 } from "node:os";
-import { join as join74 } from "node:path";
+import { join as join76 } from "node:path";
 var BUILTIN_MCP_SERVERS = ["websearch", "context7", "grep_app", "lsp"];
 function getMcpConfigPaths() {
   return [
-    join74(homedir19(), ".claude", ".mcp.json"),
-    join74(process.cwd(), ".mcp.json"),
-    join74(process.cwd(), ".claude", ".mcp.json")
+    join76(homedir19(), ".claude", ".mcp.json"),
+    join76(process.cwd(), ".mcp.json"),
+    join76(process.cwd(), ".claude", ".mcp.json")
   ];
 }
 function loadUserMcpConfig() {
   const servers = {};
   for (const configPath of getMcpConfigPaths()) {
-    if (!existsSync55(configPath))
+    if (!existsSync56(configPath))
       continue;
     try {
       const content = readFileSync38(configPath, "utf-8");
@@ -92058,7 +92276,16 @@ async function probeBinary(cmd, args, spawnImpl) {
 import { homedir as homedir20 } from "node:os";
 import path14 from "node:path";
 function resolveBaseDir(config3) {
-  return config3.base_dir ?? path14.join(homedir20(), ".omo");
+  return expandHomeDirectory(config3.base_dir ?? path14.join(homedir20(), ".omo"));
+}
+function expandHomeDirectory(directoryPath) {
+  if (directoryPath === "~") {
+    return homedir20();
+  }
+  if (directoryPath.startsWith("~/") || directoryPath.startsWith("~\\")) {
+    return path14.join(homedir20(), directoryPath.slice(2));
+  }
+  return directoryPath;
 }
 // packages/omo-opencode/src/cli/doctor/checks/team-mode.ts
 init_shared();
@@ -92133,10 +92360,10 @@ async function pathExists(dir) {
 
 // packages/omo-opencode/src/cli/doctor/checks/codex.ts
 init_src();
-import { existsSync as existsSync56 } from "node:fs";
+import { existsSync as existsSync57 } from "node:fs";
 import { lstat as lstat11, readdir as readdir8, readFile as readFile20 } from "node:fs/promises";
 import { homedir as homedir21 } from "node:os";
-import { basename as basename12, join as join75, resolve as resolve19 } from "node:path";
+import { basename as basename13, join as join77, resolve as resolve20 } from "node:path";
 // packages/omo-opencode/package.json
 var package_default3 = {
   name: "@oh-my-opencode/omo-opencode",
@@ -92192,13 +92419,13 @@ var CODEX_BIN_NAMES = [
   "omo-git-bash-hook"
 ];
 async function gatherCodexSummary(deps = {}) {
-  const codexHome = resolve19(deps.codexHome ?? process.env.CODEX_HOME ?? join75(homedir21(), ".codex"));
+  const codexHome = resolve20(deps.codexHome ?? process.env.CODEX_HOME ?? join77(homedir21(), ".codex"));
   const binDir = resolveCodexInstallerBinDir({ binDir: deps.binDir, codexHome, env: process.env });
   const detection = await (deps.detectCodexInstallation ?? detectCodexInstallation)();
   const pluginRoot = await resolveInstalledPluginRoot(codexHome);
-  const manifest = pluginRoot === null ? null : await readJson(join75(pluginRoot, ".codex-plugin", "plugin.json"));
-  const installSnapshot = pluginRoot === null ? null : await readJson(join75(pluginRoot, "lazycodex-install.json"));
-  const configPath = join75(codexHome, "config.toml");
+  const manifest = pluginRoot === null ? null : await readJson(join77(pluginRoot, ".codex-plugin", "plugin.json"));
+  const installSnapshot = pluginRoot === null ? null : await readJson(join77(pluginRoot, "lazycodex-install.json"));
+  const configPath = join77(codexHome, "config.toml");
   const pluginVersion = stringField(manifest, "version");
   return {
     codexPath: detection.found && "path" in detection ? detection.path : null,
@@ -92254,7 +92481,7 @@ function buildCodexIssues(summary) {
   if (summary.pluginRoot === null) {
     issues.push({
       title: "OMO Codex plugin is not installed",
-      description: `Expected cached plugin at ${join75("plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME2, DEFAULT_PLUGIN_VERSION)} under CODEX_HOME.`,
+      description: `Expected cached plugin at ${join77("plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME2, DEFAULT_PLUGIN_VERSION)} under CODEX_HOME.`,
       fix: "Run: npx lazycodex-ai install",
       severity: "error",
       affects: ["plugin loading"]
@@ -92307,15 +92534,15 @@ function buildCodexIssues(summary) {
   return issues;
 }
 async function resolveInstalledPluginRoot(codexHome) {
-  const pluginRoot = join75(codexHome, "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME2);
-  if (!existsSync56(pluginRoot))
+  const pluginRoot = join77(codexHome, "plugins", "cache", MARKETPLACE_NAME, PLUGIN_NAME2);
+  if (!existsSync57(pluginRoot))
     return null;
   const versions2 = await readdir8(pluginRoot, { withFileTypes: true });
   const candidates = versions2.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareVersionsDescending);
-  return candidates.length === 0 ? null : join75(pluginRoot, candidates[0] ?? DEFAULT_PLUGIN_VERSION);
+  return candidates.length === 0 ? null : join77(pluginRoot, candidates[0] ?? DEFAULT_PLUGIN_VERSION);
 }
 async function readCodexConfigSummary(configPath) {
-  if (!existsSync56(configPath)) {
+  if (!existsSync57(configPath)) {
     return { exists: false, marketplaceConfigured: false, pluginEnabled: false, pluginsFeatureEnabled: false, pluginHooksFeatureEnabled: false };
   }
   const content = await readFile20(configPath, "utf8");
@@ -92330,17 +92557,17 @@ async function readCodexConfigSummary(configPath) {
 async function readLinkedBins(binDir) {
   const linked = [];
   for (const name of CODEX_BIN_NAMES) {
-    if (await pathExists2(join75(binDir, process.platform === "win32" ? `${name}.cmd` : name)))
+    if (await pathExists2(join77(binDir, process.platform === "win32" ? `${name}.cmd` : name)))
       linked.push(name);
   }
   return linked;
 }
 async function readLinkedAgents(codexHome) {
-  const agentsDir = join75(codexHome, "agents");
-  if (!existsSync56(agentsDir))
+  const agentsDir = join77(codexHome, "agents");
+  if (!existsSync57(agentsDir))
     return [];
   const entries = await readdir8(agentsDir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() || entry.isSymbolicLink()).map((entry) => basename12(entry.name, ".toml")).sort();
+  return entries.filter((entry) => entry.isFile() || entry.isSymbolicLink()).map((entry) => basename13(entry.name, ".toml")).sort();
 }
 async function readJson(path16) {
   try {
@@ -92396,7 +92623,7 @@ async function pathExists2(path16) {
 init_src();
 import { readdir as readdir9, readFile as readFile21, stat as stat4 } from "node:fs/promises";
 import { homedir as homedir22 } from "node:os";
-import { dirname as dirname27, join as join76, relative as relative9, resolve as resolve20, sep as sep9 } from "node:path";
+import { dirname as dirname29, join as join78, relative as relative10, resolve as resolve21, sep as sep9 } from "node:path";
 var CODEX_COMPONENTS_CHECK_ID = "codex-components";
 var CODEX_COMPONENTS_CHECK_NAME = "codex-components";
 var PLUGIN_DATA_DIR_NAME = "omo-sisyphuslabs";
@@ -92406,7 +92633,7 @@ async function checkCodexComponents(deps = {}) {
   const env3 = deps.env ?? process.env;
   const platform = deps.platform ?? process.platform;
   const arch = deps.arch ?? process.arch;
-  const codexHome = resolve20(deps.codexHome ?? env3["CODEX_HOME"] ?? join76(homedir22(), ".codex"));
+  const codexHome = resolve21(deps.codexHome ?? env3["CODEX_HOME"] ?? join78(homedir22(), ".codex"));
   const summary = await gatherCodexSummary({ ...deps, codexHome });
   if (summary.pluginRoot === null) {
     return {
@@ -92431,7 +92658,7 @@ async function checkCodexComponents(deps = {}) {
     });
   }
   const runtimeSgDir = runtimeSgDirectory(codexHome, platform, arch);
-  const runtimeSgPath = join76(runtimeSgDir, sgBinaryName(platform));
+  const runtimeSgPath = join78(runtimeSgDir, sgBinaryName(platform));
   const sg = findSgBinarySync({
     arch,
     env: env3,
@@ -92470,8 +92697,8 @@ async function auditBundleTargets(pluginRoot) {
     const manifest = await readJson2(manifestPath);
     if (manifest === null || !isRecord5(manifest["mcpServers"]))
       continue;
-    const manifestRoot = dirname27(manifestPath);
-    const isRootManifest = resolve20(manifestRoot) === resolve20(pluginRoot);
+    const manifestRoot = dirname29(manifestPath);
+    const isRootManifest = resolve21(manifestRoot) === resolve21(pluginRoot);
     for (const server2 of Object.values(manifest["mcpServers"])) {
       if (!isRecord5(server2) || !Array.isArray(server2["args"]))
         continue;
@@ -92491,7 +92718,7 @@ async function auditBundleTargets(pluginRoot) {
       continue;
     const commands2 = [];
     collectHookCommands(manifest, commands2);
-    const hookPluginRoot = dirname27(dirname27(hookManifestPath));
+    const hookPluginRoot = dirname29(dirname29(hookManifestPath));
     for (const command of commands2) {
       for (const relativePath of extractPluginRootPaths(command)) {
         referencedCount += 1;
@@ -92513,8 +92740,8 @@ function recordBrokenTarget(broken, classified, origin) {
   broken.push(entry);
 }
 async function classifyBundleTarget(bundleRoot, baseRoot, relativePath, allowEscape) {
-  const targetPath = resolve20(baseRoot, relativePath);
-  const bundleRootPath = resolve20(bundleRoot);
+  const targetPath = resolve21(baseRoot, relativePath);
+  const bundleRootPath = resolve21(bundleRoot);
   const bundleRootPrefix = bundleRootPath.endsWith(sep9) ? bundleRootPath : `${bundleRootPath}${sep9}`;
   if (targetPath !== bundleRootPath && !targetPath.startsWith(bundleRootPrefix)) {
     if (allowEscape)
@@ -92530,7 +92757,7 @@ async function classifyBundleTarget(bundleRoot, baseRoot, relativePath, allowEsc
 }
 async function findHookManifestPaths(root) {
   const paths2 = await findManifestPaths(root, "hooks.json");
-  return paths2.filter((path16) => dirname27(path16).endsWith(`${sep9}hooks`));
+  return paths2.filter((path16) => dirname29(path16).endsWith(`${sep9}hooks`));
 }
 async function findManifestPaths(root, manifestName) {
   let entries;
@@ -92543,7 +92770,7 @@ async function findManifestPaths(root, manifestName) {
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === ".git")
       continue;
-    const entryPath = join76(root, entry.name);
+    const entryPath = join78(root, entry.name);
     if (entry.isDirectory()) {
       paths2.push(...await findManifestPaths(entryPath, manifestName));
       continue;
@@ -92586,18 +92813,18 @@ function isPluginRuntimePathArg(arg) {
   return (arg.startsWith("./") || arg.startsWith("../")) && arg.endsWith("/dist/cli.js");
 }
 function runtimeSgDirectory(codexHome, platform, arch) {
-  return join76(codexHome, "runtime", "ast-grep", runtimeSlug(platform, arch));
+  return join78(codexHome, "runtime", "ast-grep", runtimeSlug(platform, arch));
 }
 function describeSgSource(sgPath, env3, runtimeSgDir, platform) {
   const override = env3[SG_PATH_ENV_KEY]?.trim();
   if (override !== undefined && override.length > 0 && sgPath === override)
     return `env override ${SG_PATH_ENV_KEY}`;
-  if (sgPath === join76(runtimeSgDir, sgBinaryName(platform)))
+  if (sgPath === join78(runtimeSgDir, sgBinaryName(platform)))
     return "runtime dir";
   return "PATH";
 }
 async function readBootstrapStateSummary(codexHome) {
-  const statePath = join76(codexHome, "plugins", "data", PLUGIN_DATA_DIR_NAME, "bootstrap", "state.json");
+  const statePath = join78(codexHome, "plugins", "data", PLUGIN_DATA_DIR_NAME, "bootstrap", "state.json");
   const raw = await readJson2(statePath);
   if (raw === null)
     return null;
@@ -92663,7 +92890,7 @@ async function fileSize(path16) {
   }
 }
 function normalizeRelative(root, target) {
-  return normalizePathSeparators(relative9(root, target));
+  return normalizePathSeparators(relative10(root, target));
 }
 function normalizePathSeparators(path16) {
   return path16.split("\\").join("/");
@@ -92673,23 +92900,23 @@ function isRecord5(value) {
 }
 
 // packages/omo-opencode/src/cli/doctor/checks/codex-runtime-wrapper.ts
-import { existsSync as existsSync57 } from "node:fs";
+import { existsSync as existsSync58 } from "node:fs";
 import { readFile as readFile22 } from "node:fs/promises";
 import { homedir as homedir23 } from "node:os";
-import { join as join77, resolve as resolve21 } from "node:path";
+import { join as join79, resolve as resolve22 } from "node:path";
 var RUNTIME_WRAPPER_MARKER2 = "OMO_GENERATED_RUNTIME_WRAPPER";
 var CHECK_NAME = "codex-runtime-wrapper";
 var REINSTALL_COMMAND = "npx --yes lazycodex-ai@latest install --no-tui";
 async function checkCodexRuntimeWrapper(deps = {}) {
-  const codexHome = resolve21(deps.codexHome ?? process.env.CODEX_HOME ?? join77(homedir23(), ".codex"));
+  const codexHome = resolve22(deps.codexHome ?? process.env.CODEX_HOME ?? join79(homedir23(), ".codex"));
   const binDir = resolveCodexInstallerBinDir({ binDir: deps.binDir, codexHome, env: process.env });
   const platform = deps.platform ?? process.platform;
-  const wrapperPath = join77(binDir, platform === "win32" ? "omo.cmd" : "omo");
+  const wrapperPath = join79(binDir, platform === "win32" ? "omo.cmd" : "omo");
   const wrapper = await readRuntimeWrapper(wrapperPath);
   const issues = [];
   if (wrapper?.includes(RUNTIME_WRAPPER_MARKER2) === true) {
     const targetPath = parseRuntimeTargetPath(wrapper);
-    if (targetPath !== null && !existsSync57(targetPath)) {
+    if (targetPath !== null && !existsSync58(targetPath)) {
       issues.push({
         title: "omo runtime wrapper target is missing",
         description: `Generated omo runtime wrapper at ${wrapperPath} points to missing target ${targetPath}.`,
@@ -93181,7 +93408,7 @@ Doctor failed unexpectedly: ${message}`];
 import { createHash as createHash4 } from "node:crypto";
 import {
   chmodSync as chmodSync4,
-  existsSync as existsSync60,
+  existsSync as existsSync61,
   mkdirSync as mkdirSync14,
   readdirSync as readdirSync9,
   readFileSync as readFileSync41,
@@ -93189,15 +93416,15 @@ import {
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { basename as basename13, dirname as dirname28, join as join80 } from "node:path";
+import { basename as basename14, dirname as dirname30, join as join82 } from "node:path";
 
 // packages/mcp-client-core/src/config-dir.ts
-import { existsSync as existsSync58, realpathSync as realpathSync8 } from "node:fs";
+import { existsSync as existsSync59, realpathSync as realpathSync8 } from "node:fs";
 import { homedir as homedir24 } from "node:os";
-import { join as join78, resolve as resolve22 } from "node:path";
+import { join as join80, resolve as resolve23 } from "node:path";
 function resolveConfigPath2(pathValue) {
-  const resolvedPath = resolve22(pathValue);
-  if (!existsSync58(resolvedPath))
+  const resolvedPath = resolve23(pathValue);
+  if (!existsSync59(resolvedPath))
     return resolvedPath;
   try {
     return realpathSync8(resolvedPath);
@@ -93212,13 +93439,13 @@ function getOpenCodeCliConfigDir(env3 = process.env) {
   if (customConfigDir) {
     return resolveConfigPath2(customConfigDir);
   }
-  const xdgConfigDir = env3["XDG_CONFIG_HOME"]?.trim() || join78(homedir24(), ".config");
-  return resolveConfigPath2(join78(xdgConfigDir, "opencode"));
+  const xdgConfigDir = env3["XDG_CONFIG_HOME"]?.trim() || join80(homedir24(), ".config");
+  return resolveConfigPath2(join80(xdgConfigDir, "opencode"));
 }
 
 // packages/mcp-client-core/src/mcp-oauth/storage-index.ts
-import { chmodSync as chmodSync3, existsSync as existsSync59, readFileSync as readFileSync40, renameSync as renameSync6, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join79 } from "node:path";
+import { chmodSync as chmodSync3, existsSync as existsSync60, readFileSync as readFileSync40, renameSync as renameSync6, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join81 } from "node:path";
 var INDEX_FILE_NAME = "index.json";
 function isTokenIndex(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -93226,11 +93453,11 @@ function isTokenIndex(value) {
   return Object.values(value).every((entry) => typeof entry === "string");
 }
 function getIndexPath(storageDir) {
-  return join79(storageDir, INDEX_FILE_NAME);
+  return join81(storageDir, INDEX_FILE_NAME);
 }
 function readTokenIndex(storageDir) {
   const indexPath = getIndexPath(storageDir);
-  if (!existsSync59(indexPath))
+  if (!existsSync60(indexPath))
     return {};
   try {
     const parsed = JSON.parse(readFileSync40(indexPath, "utf-8"));
@@ -93270,16 +93497,16 @@ function deleteTokenIndexEntry(storageDir, hash2) {
 var STORAGE_DIR_NAME = "mcp-oauth";
 var LEGACY_STORAGE_FILE_NAME = "mcp-oauth.json";
 function getMcpOauthStorageDir() {
-  return join80(getOpenCodeCliConfigDir(), STORAGE_DIR_NAME);
+  return join82(getOpenCodeCliConfigDir(), STORAGE_DIR_NAME);
 }
 function getMcpOauthServerHash(serverHost, resource) {
   return createHash4("sha256").update(buildKey(serverHost, resource)).digest("hex").slice(0, 32);
 }
 function getMcpOauthStoragePath(serverHost, resource) {
-  return join80(getMcpOauthStorageDir(), `${getMcpOauthServerHash(serverHost, resource)}.json`);
+  return join82(getMcpOauthStorageDir(), `${getMcpOauthServerHash(serverHost, resource)}.json`);
 }
 function getLegacyStoragePath() {
-  return join80(getOpenCodeCliConfigDir(), LEGACY_STORAGE_FILE_NAME);
+  return join82(getOpenCodeCliConfigDir(), LEGACY_STORAGE_FILE_NAME);
 }
 function normalizeHost2(serverHost) {
   let host = serverHost.trim();
@@ -93340,7 +93567,7 @@ function isOAuthTokenData(value) {
   return clientSecret === undefined || typeof clientSecret === "string";
 }
 function readTokenFile(filePath) {
-  if (!existsSync60(filePath))
+  if (!existsSync61(filePath))
     return null;
   try {
     const parsed = JSON.parse(readFileSync41(filePath, "utf-8"));
@@ -93353,7 +93580,7 @@ function readTokenFile(filePath) {
 }
 function readLegacyStore() {
   const filePath = getLegacyStoragePath();
-  if (!existsSync60(filePath))
+  if (!existsSync61(filePath))
     return null;
   try {
     const parsed = JSON.parse(readFileSync41(filePath, "utf-8"));
@@ -93373,8 +93600,8 @@ function readLegacyStore() {
 }
 function writeTokenFile(filePath, token) {
   try {
-    const dir = dirname28(filePath);
-    if (!existsSync60(dir)) {
+    const dir = dirname30(filePath);
+    if (!existsSync61(dir)) {
       mkdirSync14(dir, { recursive: true });
     }
     const tempPath = `${filePath}.tmp.${Date.now()}`;
@@ -93398,7 +93625,7 @@ function saveToken(serverHost, resource, token) {
 }
 function deleteToken(serverHost, resource) {
   const filePath = getMcpOauthStoragePath(serverHost, resource);
-  if (!existsSync60(filePath))
+  if (!existsSync61(filePath))
     return deleteLegacyToken(serverHost, resource);
   try {
     unlinkSync8(filePath);
@@ -93420,7 +93647,7 @@ function deleteLegacyToken(serverHost, resource) {
   if (Object.keys(store2).length === 0) {
     try {
       const filePath = getLegacyStoragePath();
-      if (existsSync60(filePath))
+      if (existsSync61(filePath))
         unlinkSync8(filePath);
       return true;
     } catch (deleteError) {
@@ -93458,7 +93685,7 @@ function listTokensByHost(serverHost) {
   for (const [hash2, indexedKey] of Object.entries(index)) {
     if (!indexedKey.startsWith(prefix))
       continue;
-    const indexedToken = readTokenFile(join80(getMcpOauthStorageDir(), `${hash2}.json`));
+    const indexedToken = readTokenFile(join82(getMcpOauthStorageDir(), `${hash2}.json`));
     if (indexedToken)
       result[indexedKey] = indexedToken;
   }
@@ -93467,14 +93694,14 @@ function listTokensByHost(serverHost) {
 function listAllTokens() {
   const result = { ...readLegacyStore() ?? {} };
   const dir = getMcpOauthStorageDir();
-  if (!existsSync60(dir))
+  if (!existsSync61(dir))
     return result;
   const index = readTokenIndex(dir);
   for (const entry of readdirSync9(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".json") || entry.name === "index.json")
       continue;
-    const token = readTokenFile(join80(dir, entry.name));
-    const hash2 = basename13(entry.name, ".json");
+    const token = readTokenFile(join82(dir, entry.name));
+    const hash2 = basename14(entry.name, ".json");
     if (token)
       result[index[hash2] ?? hash2] = token;
   }
@@ -93673,7 +93900,7 @@ function buildAuthorizationUrl(authorizationEndpoint, options) {
 }
 var CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
 function startCallbackServer(port) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     let timeoutId;
     const server2 = createServer2((request, response) => {
       clearTimeout(timeoutId);
@@ -93699,7 +93926,7 @@ function startCallbackServer(port) {
       response.writeHead(200, { "content-type": "text/html" });
       response.end("<html><body><h1>Authorization successful. You can close this tab.</h1></body></html>");
       server2.close();
-      resolve23({ code, state: state2 });
+      resolve24({ code, state: state2 });
     });
     timeoutId = setTimeout(() => {
       server2.close();
@@ -94039,7 +94266,7 @@ function createMcpOAuthCommand() {
 }
 
 // packages/omo-opencode/src/cli/boulder/boulder.ts
-import { existsSync as existsSync61 } from "node:fs";
+import { existsSync as existsSync62 } from "node:fs";
 
 // packages/omo-opencode/src/cli/boulder/formatter.ts
 var import_picocolors22 = __toESM(require_picocolors(), 1);
@@ -94176,10 +94403,10 @@ async function boulder(options) {
   const boulderFilePath = getBoulderFilePath(directory);
   const state2 = readBoulderState(directory);
   if (!state2) {
-    const message = existsSync61(boulderFilePath) ? formatReadErrorMessage(options.json) : formatNoBoulderMessage(options.json);
+    const message = existsSync62(boulderFilePath) ? formatReadErrorMessage(options.json) : formatNoBoulderMessage(options.json);
     process.stderr.write(`${message}
 `);
-    return existsSync61(boulderFilePath) ? 2 : 1;
+    return existsSync62(boulderFilePath) ? 2 : 1;
   }
   const works = getBoulderWorks(state2);
   const filteredWorks = options.workId ? works.filter((work) => work.work_id === options.workId) : works;
@@ -94197,7 +94424,7 @@ async function boulder(options) {
 }
 // packages/omo-opencode/src/cli/codex-ulw-loop.ts
 import { spawn as spawn5 } from "node:child_process";
-import { existsSync as existsSync62, realpathSync as realpathSync9 } from "node:fs";
+import { existsSync as existsSync63, realpathSync as realpathSync9 } from "node:fs";
 import { homedir as homedir25 } from "node:os";
 function resolveCodexUlwLoopCommand(input = {}) {
   const env3 = input.env ?? process.env;
@@ -94222,22 +94449,22 @@ async function codexUlwLoop(args) {
     console.error("Codex ulw-loop is not installed. Run: npx lazycodex-ai@latest install --no-tui");
     return 1;
   }
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const child = spawn5(command.executable, [...command.argsPrefix, ...args], { stdio: "inherit" });
     child.on("error", (error51) => {
       console.error(error51.message);
-      resolve23(1);
+      resolve24(1);
     });
-    child.on("close", (code) => resolve23(code ?? 1));
+    child.on("close", (code) => resolve24(code ?? 1));
   });
 }
 function resolveLocalUlwLoopBin(env3, homeDir) {
   const candidates = resolveCodexComponentBinCandidates({ executableName: "omo-ulw-loop", env: env3, homeDir });
-  return candidates.find((candidate) => existsSync62(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync63(candidate)) ?? null;
 }
 function resolveLegacyLocalOmoBin(env3, homeDir, currentExecutablePaths) {
   const candidates = resolveCodexComponentBinCandidates({ executableName: "omo", env: env3, homeDir });
-  return candidates.find((candidate) => existsSync62(candidate) && !isCurrentExecutable(candidate, currentExecutablePaths)) ?? null;
+  return candidates.find((candidate) => existsSync63(candidate) && !isCurrentExecutable(candidate, currentExecutablePaths)) ?? null;
 }
 function isCurrentExecutable(candidate, currentExecutablePaths) {
   const candidateRealPath = realpathOrSelf(candidate);
@@ -94286,15 +94513,15 @@ async function refreshModelCapabilities(options, deps = {}) {
 }
 
 // packages/omo-opencode/src/cli/sparkshell.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 import { constants as osConstants } from "node:os";
-import { isAbsolute as isAbsolute10, resolve as resolve23 } from "node:path";
+import { isAbsolute as isAbsolute11, resolve as resolve24 } from "node:path";
 
 // packages/omo-opencode/src/cli/sparkshell-appserver.ts
 init_src();
-import { existsSync as existsSync63 } from "node:fs";
+import { existsSync as existsSync64 } from "node:fs";
 import { homedir as homedir26 } from "node:os";
-import { join as join81 } from "node:path";
+import { join as join83 } from "node:path";
 
 // packages/omo-opencode/src/cli/sparkshell-appserver-websocket.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
@@ -94445,7 +94672,7 @@ function bufferUnreadSocketBytes(socket, unread) {
 // packages/omo-opencode/src/cli/sparkshell-appserver.ts
 function createDefaultSparkShellAppServerClient(env3) {
   const socketPath = resolveAppServerSocketPath(env3);
-  if (!socketPath || !existsSync63(socketPath)) {
+  if (!socketPath || !existsSync64(socketPath)) {
     return null;
   }
   return new JsonRpcSparkShellAppServerClient(socketPath, resolveAppServerTimeoutMs(env3));
@@ -94455,8 +94682,8 @@ function resolveAppServerSocketPath(env3) {
   if (explicit) {
     return explicit;
   }
-  const codexHome = env3["CODEX_HOME"]?.trim() || join81(homedir26(), ".codex");
-  return join81(codexHome, "app-server-control", "app-server-control.sock");
+  const codexHome = env3["CODEX_HOME"]?.trim() || join83(homedir26(), ".codex");
+  return join83(codexHome, "app-server-control", "app-server-control.sock");
 }
 function resolveAppServerTimeoutMs(env3) {
   const parsed = Number.parseInt(env3["OMO_SPARKSHELL_APP_SERVER_TIMEOUT_MS"]?.trim() ?? "", 10);
@@ -94885,9 +95112,9 @@ function extractContextHints(requests) {
       seen.add(key);
       hints.push(hint);
     }
-    const basename14 = hint.slice(hint.lastIndexOf("/") + 1);
-    if (basename14.length > 0 && basename14 !== hint) {
-      add(basename14);
+    const basename15 = hint.slice(hint.lastIndexOf("/") + 1);
+    if (basename15.length > 0 && basename15 !== hint) {
+      add(basename15);
     }
   };
   for (const request of requests) {
@@ -95026,9 +95253,9 @@ function isLowSurrogate(codeUnit) {
 
 // packages/omo-opencode/src/cli/sparkshell-session-context.ts
 init_src();
-import { existsSync as existsSync64, readdirSync as readdirSync10, readFileSync as readFileSync42 } from "node:fs";
+import { existsSync as existsSync65, readdirSync as readdirSync10, readFileSync as readFileSync42 } from "node:fs";
 import { homedir as homedir27 } from "node:os";
-import { join as join82 } from "node:path";
+import { join as join84 } from "node:path";
 var SPARKSHELL_SESSION_CONTEXT_ENV = "OMO_SPARKSHELL_SESSION_CONTEXT";
 var SPARKSHELL_SESSION_ID_ENV = "OMO_SPARKSHELL_SESSION_ID";
 var CODEX_THREAD_ID_ENV = "CODEX_THREAD_ID";
@@ -95041,11 +95268,11 @@ function resolveCodexSessionId(env3) {
   return /^[0-9a-f][0-9a-f-]{7,}$/i.test(candidate) ? candidate : null;
 }
 function findRolloutPath(sessionId, env3, deps = {}) {
-  const fileExists = deps.fileExists ?? existsSync64;
+  const fileExists = deps.fileExists ?? existsSync65;
   const listDirectory = deps.listDirectory ?? ((path16) => readdirSync10(path16));
   const homeDirectory = deps.homeDirectory ?? homedir27;
-  const codexHome = env3["CODEX_HOME"]?.trim() || join82(homeDirectory(), ".codex");
-  const roots = [join82(codexHome, "sessions"), join82(codexHome, "archived_sessions")];
+  const codexHome = env3["CODEX_HOME"]?.trim() || join84(homeDirectory(), ".codex");
+  const roots = [join84(codexHome, "sessions"), join84(codexHome, "archived_sessions")];
   const fileSuffix = `-${sessionId}.jsonl`;
   const scanDay = (dayDir) => {
     if (!fileExists(dayDir)) {
@@ -95053,14 +95280,14 @@ function findRolloutPath(sessionId, env3, deps = {}) {
     }
     for (const name of listSafely(listDirectory, dayDir)) {
       if (name.startsWith("rollout-") && name.endsWith(fileSuffix)) {
-        return join82(dayDir, name);
+        return join84(dayDir, name);
       }
     }
     return null;
   };
   for (const dayDir of uuidV7DayDirCandidates(sessionId)) {
     for (const root of roots) {
-      const found = scanDay(join82(root, dayDir));
+      const found = scanDay(join84(root, dayDir));
       if (found) {
         return found;
       }
@@ -95071,9 +95298,9 @@ function findRolloutPath(sessionId, env3, deps = {}) {
       continue;
     }
     for (const year of numericNamesDescending(listSafely(listDirectory, root))) {
-      for (const month of numericNamesDescending(listSafely(listDirectory, join82(root, year)))) {
-        for (const day of numericNamesDescending(listSafely(listDirectory, join82(root, year, month)))) {
-          const found = scanDay(join82(root, year, month, day));
+      for (const month of numericNamesDescending(listSafely(listDirectory, join84(root, year)))) {
+        for (const day of numericNamesDescending(listSafely(listDirectory, join84(root, year, month)))) {
+          const found = scanDay(join84(root, year, month, day));
           if (found) {
             return found;
           }
@@ -95233,7 +95460,7 @@ function uuidV7DayDirCandidates(sessionId) {
   const candidates = [];
   for (const offsetDays of [0, 1, -1]) {
     const date5 = new Date(ms + offsetDays * DAY_MS);
-    candidates.push(join82(String(date5.getFullYear()), pad2(date5.getMonth() + 1), pad2(date5.getDate())));
+    candidates.push(join84(String(date5.getFullYear()), pad2(date5.getMonth() + 1), pad2(date5.getDate())));
   }
   return candidates;
 }
@@ -95271,10 +95498,10 @@ function isFalsy2(value) {
 }
 
 // packages/omo-opencode/src/cli/sparkshell-spark.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 import { mkdtempSync, readFileSync as readFileSync43, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join83 } from "node:path";
+import { join as join85 } from "node:path";
 var SPARKSHELL_SPARK_ENV = "OMO_SPARKSHELL_SPARK";
 var SPARKSHELL_SPARK_MODEL_ENV = "OMO_SPARKSHELL_SPARK_MODEL";
 var SPARKSHELL_SPARK_TIMEOUT_ENV = "OMO_SPARKSHELL_SPARK_TIMEOUT_MS";
@@ -95348,10 +95575,10 @@ function buildSparkExecArgs(env3, lastMessagePath) {
 function createDefaultSparkSummarizer(env3, cwd) {
   return (request) => {
     const binary = env3[SPARKSHELL_SPARK_BIN_ENV]?.trim() || "codex";
-    const tempDir = mkdtempSync(join83(tmpdir4(), "omo-sparkshell-spark-"));
-    const lastMessagePath = join83(tempDir, "last-message.txt");
+    const tempDir = mkdtempSync(join85(tmpdir4(), "omo-sparkshell-spark-"));
+    const lastMessagePath = join85(tempDir, "last-message.txt");
     try {
-      const result = spawnSync3(binary, [...buildSparkExecArgs(env3, lastMessagePath)], {
+      const result = spawnSync4(binary, [...buildSparkExecArgs(env3, lastMessagePath)], {
         cwd,
         env: { ...process.env, ...env3, [SPARKSHELL_SPARK_ENV]: "0" },
         input: buildSparkSummaryPrompt(request),
@@ -95544,7 +95771,7 @@ function resolveNativeBinaryOverride(env3, cwd) {
   if (override.length === 0) {
     return "";
   }
-  return isAbsolute10(override) || /^[A-Za-z]:[\\/]/.test(override) ? override : resolve23(cwd, override);
+  return isAbsolute11(override) || /^[A-Za-z]:[\\/]/.test(override) ? override : resolve24(cwd, override);
 }
 async function runAppServerCommand(args, appServerClient, options) {
   let invocation;
@@ -95656,13 +95883,13 @@ function signalExitCode(signal) {
   return typeof signalNumber === "number" && Number.isFinite(signalNumber) ? 128 + signalNumber : 1;
 }
 function defaultCommandExists(command) {
-  const result = spawnSync4(command, ["--version"], {
+  const result = spawnSync5(command, ["--version"], {
     stdio: "ignore"
   });
   return result.error === undefined;
 }
 function defaultSpawn(command, args, options) {
-  const result = spawnSync4(command, [...args], {
+  const result = spawnSync5(command, [...args], {
     cwd: options.cwd,
     env: { ...process.env, ...options.env },
     stdio: ["inherit", "pipe", "pipe"],