lazycodex-ai 5.1.0 → 5.1.1

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

@@ -438,9 +438,9 @@ async function readOptionalFile(path) {
 }
 
 // components/bootstrap/src/worker.ts
-import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile15 } from "node:fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile17 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname10, join as join24, resolve as resolve8 } from "node:path";
+import { dirname as dirname10, join as join25, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // components/bootstrap/src/provision.ts
@@ -1000,8 +1000,8 @@ async function defaultVersionProbe2(binaryPath) {
 }
 
 // components/bootstrap/src/setup.ts
-import { copyFile as copyFile2, mkdir as mkdir7, readFile as readFile14, readdir as readdir5, rm as rm11, stat as stat5 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir7, readFile as readFile16, readdir as readdir5, rm as rm12, stat as stat5 } from "node:fs/promises";
+import { join as join24 } from "node:path";
 
 // ../../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
@@ -7379,6 +7379,7 @@ var OmoTaskSettingsSchema = object({
   process_runner: _enum(["host", "child-process"]).default("host"),
   host_engine_policy: _enum(["upgrade", "fallback"]).default("upgrade"),
   host_idle_exit_ms: number2().int().positive().optional(),
+  host_shard_prewarm: _enum(["off", "first-turn", "session-start"]).default("first-turn"),
   default_concurrency: number2().int().nonnegative().default(5),
   global_concurrency: number2().int().nonnegative().default(8),
   provider_concurrency: record(string2(), number2().int().nonnegative()).optional(),
@@ -7428,6 +7429,7 @@ var OmoTaskSettingsLayerSchema = object({
   process_runner: _enum(["host", "child-process"]).optional(),
   host_engine_policy: _enum(["upgrade", "fallback"]).optional(),
   host_idle_exit_ms: number2().int().positive().optional(),
+  host_shard_prewarm: _enum(["off", "first-turn", "session-start"]).optional(),
   default_concurrency: number2().int().nonnegative().optional(),
   global_concurrency: number2().int().nonnegative().optional(),
   provider_concurrency: record(string2(), number2().int().nonnegative()).optional(),
@@ -8991,21 +8993,93 @@ function loadOmoConfig(options = {}) {
   };
 }
 
-// ../src/install/codex-default-role-config.ts
-function readDefaultRoleConfig(options = {}) {
+// ../src/install/codex-cache-fs.ts
+import { lstat } from "node:fs/promises";
+async function fileExistsStrict(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (isNodeErrorWithCode(error) && error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeErrorWithCode(error) {
+  return typeof error === "object" && error !== null && "code" in error;
+}
+
+// ../src/install/codex-agent-config.ts
+function readCodexAgentConfig(options = {}) {
   const result = loadOmoConfig({ ...options, harness: "codex" });
+  const overrides = readAgentOverrides(result);
+  return {
+    defaultRoleEnabled: result.config.agents?.default?.disable !== true,
+    agentOverrides: overrides.agentOverrides,
+    warnings: [...result.diagnostics.map((diagnostic) => diagnostic.message), ...overrides.warnings]
+  };
+}
+function unmanagedAgentOverrideWarnings(agentOverrides, managedAgentNames) {
+  return [...agentOverrides.keys()].filter((name) => !managedAgentNames.has(name)).map((name) => `[codex].agents.${name} does not name a LazyCodex-managed agent role; its model override was not applied`);
+}
+function readAgentOverrides(result) {
+  let merged = {};
+  for (const layer of result.layers)
+    merged = mergeOmoConfigRecords(merged, layer.config);
+  const profile = result.profile === undefined ? undefined : recordAt(recordAt(merged, "profiles"), result.profile);
+  let agents = {};
+  for (const scope of [merged, profile]) {
+    agents = mergeOmoConfigRecords(agents, recordAt(recordAt(scope, "[codex]"), "agents") ?? {});
+  }
+  const agentOverrides = new Map;
+  const warnings = [];
+  for (const [name, value] of Object.entries(agents)) {
+    if (name === "default")
+      continue;
+    const parsed = OmoAgentDefSchema.safeParse(value);
+    if (!parsed.success) {
+      warnings.push(`[codex].agents.${name} is invalid and was ignored: ${parsed.error.issues[0]?.message ?? "unknown error"}`);
+      continue;
+    }
+    const override = toCodexAgentOverride(parsed.data.model, parsed.data.reasoning);
+    if (override.model !== undefined || override.reasoningEffort !== undefined)
+      agentOverrides.set(name, override);
+  }
+  return { agentOverrides, warnings };
+}
+function toCodexAgentOverride(model, reasoning) {
+  const split = model === undefined ? undefined : splitReasoningSuffix(model);
+  const effort = codexReasoningEffort(reasoning ?? split?.level);
   return {
-    enabled: result.config.agents?.default?.disable !== true,
-    warnings: result.diagnostics.map((diagnostic) => diagnostic.message)
+    ...split === undefined || split.base === "" ? {} : { model: split.base },
+    ...effort === undefined ? {} : { reasoningEffort: effort }
   };
 }
+function codexReasoningEffort(reasoning) {
+  if (reasoning === undefined || reasoning === "auto")
+    return;
+  return reasoning === "off" ? "none" : reasoning;
+}
+function recordAt(value, key) {
+  if (!isPlainRecord(value))
+    return;
+  const child = value[key];
+  return isPlainRecord(child) ? child : undefined;
+}
 
 // ../src/install/link-cached-plugin-agents.ts
-import { copyFile, lstat as lstat5, mkdir as mkdir4, readdir as readdir2, rm as rm7, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename4, join as join13 } from "node:path";
+import { copyFile, lstat as lstat6, mkdir as mkdir4, readdir as readdir2, readFile as readFile8, rm as rm8, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename4, join as join14 } from "node:path";
+
+// ../src/install/agent-model-overrides.ts
+import { readFile as readFile5, rm as rm5, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 
 // ../src/install/preserved-agent-settings.ts
-import { lstat, readFile as readFile4, readdir, writeFile as writeFile3 } from "node:fs/promises";
+import { lstat as lstat2, readFile as readFile4, readdir, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join9 } from "node:path";
 
 // ../src/install/toml-section-editor.ts
@@ -9809,6 +9883,17 @@ async function restorePreservedServiceTier(input) {
     return;
   await writeFile3(input.linkPath, replacement.content);
 }
+async function restorePreservedModel(input) {
+  if (input.value === null)
+    return;
+  const content = await readFile4(input.linkPath, "utf8");
+  if (extractModel(content) === input.value)
+    return;
+  const replacement = replaceTopLevelStringSetting(content, "model", input.value, { insertIfMissing: true });
+  if (!replacement.replaced)
+    return;
+  await writeFile3(input.linkPath, replacement.content);
+}
 async function readTextIfExists(path) {
   try {
     return await readFile4(path, "utf8");
@@ -9891,7 +9976,7 @@ function agentNameFromToml(fileName) {
 }
 async function exists(path) {
   try {
-    await lstat(path);
+    await lstat2(path);
     return true;
   } catch (error) {
     if (nodeErrorCode(error) !== "ENOENT")
@@ -9905,9 +9990,86 @@ function nodeErrorCode(error) {
   return typeof error.code === "string" ? error.code : null;
 }
 
+// ../src/install/agent-model-overrides.ts
+var RECEIPT_FILE = ".lazycodex-agent-models.json";
+async function readAgentModelReceipts(codexHome) {
+  const content = await readTextIfExists(receiptPath(codexHome));
+  if (content === null)
+    return new Map;
+  const parsed = parseJson(content);
+  if (!isPlainRecord(parsed))
+    return new Map;
+  const receipts = new Map;
+  for (const [name, value] of Object.entries(parsed)) {
+    if (!isPlainRecord(value))
+      continue;
+    const model = value["model"];
+    const reasoningEffort = value["reasoningEffort"];
+    receipts.set(name, {
+      ...typeof model === "string" ? { model } : {},
+      ...typeof reasoningEffort === "string" ? { reasoningEffort } : {}
+    });
+  }
+  return receipts;
+}
+async function writeAgentModelReceipts(codexHome, receipts) {
+  const path = receiptPath(codexHome);
+  if (receipts.size === 0) {
+    await rm5(path, { force: true });
+    return;
+  }
+  await writeFile4(path, `${JSON.stringify(Object.fromEntries(receipts), null, "\t")}
+`);
+}
+async function applyAgentOverride(input) {
+  if (input.override === undefined)
+    return;
+  let content = await readFile5(input.linkPath, "utf8");
+  if (input.override.model !== undefined) {
+    content = replaceTopLevelStringSetting(content, "model", input.override.model, { insertIfMissing: true }).content;
+  }
+  if (input.override.reasoningEffort !== undefined) {
+    content = replaceTopLevelStringSetting(content, "model_reasoning_effort", input.override.reasoningEffort, {
+      insertIfMissing: true
+    }).content;
+  }
+  await writeFile4(input.linkPath, content);
+}
+function receiptPath(codexHome) {
+  return join10(codexHome, "agents", RECEIPT_FILE);
+}
+function parseJson(content) {
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      return null;
+    throw error;
+  }
+}
+
+// ../src/install/managed-agent-model-defaults.ts
+var PREVIOUSLY_BUNDLED_AGENT_MODELS = new Set([
+  "gpt-5.2",
+  "gpt-5.4-mini",
+  "gpt-5.5",
+  "gpt-5.6-luna",
+  "gpt-5.6-luna-fast",
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-6-astra"
+]);
+function handEditedAgentModel(installedModel, receipt) {
+  if (installedModel === null)
+    return null;
+  if (receipt?.model !== undefined)
+    return installedModel === receipt.model ? null : installedModel;
+  return PREVIOUSLY_BUNDLED_AGENT_MODELS.has(installedModel) ? null : installedModel;
+}
+
 // ../src/install/retired-managed-agent-purge.ts
-import { lstat as lstat2, readFile as readFile5, rm as rm5 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { lstat as lstat3, readFile as readFile6, rm as rm6 } from "node:fs/promises";
+import { join as join11 } from "node:path";
 var RETIRED_MANAGED_AGENT_FILES = [
   {
     fileName: "codex-ultrawork-reviewer.toml",
@@ -9919,20 +10081,20 @@ var RETIRED_MANAGED_AGENT_FILES = [
   }
 ];
 async function purgeRetiredManagedAgentFiles(input) {
-  const agentsDir = join10(input.codexHome, "agents");
+  const agentsDir = join11(input.codexHome, "agents");
   if (!await exists2(agentsDir))
     return;
   for (const retiredAgent of RETIRED_MANAGED_AGENT_FILES) {
-    const agentPath = join10(agentsDir, retiredAgent.fileName);
+    const agentPath = join11(agentsDir, retiredAgent.fileName);
     if (!await exists2(agentPath))
       continue;
-    const agentStat = await lstat2(agentPath);
+    const agentStat = await lstat3(agentPath);
     if (agentStat.isDirectory() && !agentStat.isSymbolicLink())
       continue;
     const content = await readTextIfExists2(agentPath);
     if (content === null || !hasRequiredMarkers(content, retiredAgent.requiredMarkers))
       continue;
-    await rm5(agentPath, { force: true });
+    await rm6(agentPath, { force: true });
   }
 }
 function hasRequiredMarkers(content, markers) {
@@ -9940,7 +10102,7 @@ function hasRequiredMarkers(content, markers) {
 }
 async function readTextIfExists2(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch (error) {
     if (nodeErrorCode2(error) === "ENOENT")
       return null;
@@ -9949,7 +10111,7 @@ async function readTextIfExists2(path) {
 }
 async function exists2(path) {
   try {
-    await lstat2(path);
+    await lstat3(path);
     return true;
   } catch (error) {
     if (nodeErrorCode2(error) !== "ENOENT")
@@ -9965,18 +10127,18 @@ function nodeErrorCode2(error) {
 
 // ../src/install/default-agent-role.ts
 import { createHash as createHash3 } from "node:crypto";
-import { lstat as lstat4, readFile as readFile6, rm as rm6 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { lstat as lstat5, readFile as readFile7, rm as rm7 } from "node:fs/promises";
+import { join as join13 } from "node:path";
 
 // ../src/install/codex-config-atomic-write.ts
-import { lstat as lstat3, readlink, realpath, rename as rename3, unlink, writeFile as writeFile4 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute2, join as join11, resolve as resolve4 } from "node:path";
+import { lstat as lstat4, readlink, realpath, rename as rename3, unlink, writeFile as writeFile5 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute2, join as join12, resolve as resolve4 } 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 = join11(dirname6(writeTarget), `.tmp-${basename3(writeTarget)}-${process.pid}-${Date.now()}`);
-  await writeFile4(temporaryPath, data);
+  const temporaryPath = join12(dirname6(writeTarget), `.tmp-${basename3(writeTarget)}-${process.pid}-${Date.now()}`);
+  await writeFile5(temporaryPath, data);
   try {
     await renameWithRetry(temporaryPath, writeTarget);
   } catch (error) {
@@ -9990,7 +10152,7 @@ async function writeFileAtomic(targetPath, data) {
 }
 async function resolveSymlinkTarget(targetPath) {
   try {
-    const linkStats = await lstat3(targetPath);
+    const linkStats = await lstat4(targetPath);
     if (!linkStats.isSymbolicLink())
       return targetPath;
   } catch (error) {
@@ -10081,11 +10243,11 @@ function tomlKeySegment(value) {
 // ../src/install/default-agent-role.ts
 var REGISTRATION = { name: "default", configFile: "./agents/default.toml" };
 async function installDefaultAgentRole(input) {
-  const target = join12(input.codexHome, "agents", "default.toml");
-  const receipt = join12(input.codexHome, "agents", ".lazycodex-default.sha256");
-  const configPath = join12(input.codexHome, "config.toml");
+  const target = join13(input.codexHome, "agents", "default.toml");
+  const receipt = join13(input.codexHome, "agents", ".lazycodex-default.sha256");
+  const configPath = join13(input.codexHome, "config.toml");
   const config = await readIfPresent(configPath);
-  const entry = await lstat4(target).catch((error) => {
+  const entry = await lstat5(target).catch((error) => {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return null;
     throw error;
@@ -10106,15 +10268,15 @@ async function installDefaultAgentRole(input) {
         if (next !== config)
           await writeFileAtomic(configPath, next);
       }
-      await rm6(target);
-      await rm6(receipt);
+      await rm7(target);
+      await rm7(receipt);
     }
     return null;
   }
   if (foreign || existing !== null && !owned) {
     throw new Error("Preserved user-owned agents.default / agents/default.toml. Move it aside to install the LazyCodex fallback, or set [codex].agents.default.disable = true in omo.jsonc. Explicit LazyCodex roles remain required.");
   }
-  const worker = await readFile6(input.worker.path, "utf8");
+  const worker = await readFile7(input.worker.path, "utf8");
   const content = worker.replace(/^name\s*=\s*["']lazycodex-worker-medium["']\s*$/m, 'name = "default"');
   if (content === worker)
     throw new Error("Cannot derive default: medium worker has no matching internal name");
@@ -10124,7 +10286,7 @@ async function installDefaultAgentRole(input) {
 }
 async function readIfPresent(path) {
   try {
-    return await readFile6(path, "utf8");
+    return await readFile7(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return null;
@@ -10144,27 +10306,19 @@ async function linkCachedPluginAgents(input) {
     await writeManifest(input.pluginRoot, []);
     return [];
   }
-  const agentsDir = join13(input.codexHome, "agents");
+  const agentsDir = join14(input.codexHome, "agents");
   await mkdir4(agentsDir, { recursive: true });
+  const previousReceipts = await readAgentModelReceipts(input.codexHome);
+  const receipts = new Map;
   const linked = [];
   for (const agentPath of bundledAgents) {
     const agentFileName = basename4(agentPath);
     const agentName = agentNameFromToml2(agentFileName);
-    const linkPath = join13(agentsDir, agentFileName);
-    await replaceWithCopy(linkPath, agentPath);
-    await restorePreservedReasoning({
-      agentName,
-      linkPath,
-      target: agentPath,
-      value: input.preservedReasoning?.get(agentName)
-    });
-    await restorePreservedServiceTier({
-      linkPath,
-      preserved: input.preservedServiceTier?.has(agentName) ?? false,
-      value: input.preservedServiceTier?.get(agentName) ?? null
-    });
+    const linkPath = join14(agentsDir, agentFileName);
+    receipts.set(agentName, await syncAgentFile({ ...input, agentName, agentPath, linkPath, previousReceipt: previousReceipts.get(agentName) }));
     linked.push({ name: agentFileName, path: linkPath, target: agentPath });
   }
+  await writeAgentModelReceipts(input.codexHome, receipts);
   const worker = linked.find((entry) => entry.name === "lazycodex-worker-medium.toml");
   if (worker !== undefined) {
     const fallback = await installDefaultAgentRole({ codexHome: input.codexHome, worker, enabled: input.defaultRoleEnabled !== false });
@@ -10174,8 +10328,33 @@ async function linkCachedPluginAgents(input) {
   await writeManifest(input.pluginRoot, linked.map((entry) => entry.path));
   return linked;
 }
+async function syncAgentFile(input) {
+  const installed = await readTextIfExists(input.linkPath);
+  const installedModel = installed === null ? null : extractModel(installed);
+  const preservedReasoning = input.preservedReasoning?.get(input.agentName);
+  const override = input.agentOverrides?.get(input.agentName);
+  await replaceWithCopy(input.linkPath, input.agentPath);
+  await restorePreservedModel({ linkPath: input.linkPath, value: handEditedAgentModel(installedModel, input.previousReceipt) });
+  await restorePreservedReasoning({
+    agentName: input.agentName,
+    linkPath: input.linkPath,
+    target: input.agentPath,
+    value: preservedReasoning?.effort === input.previousReceipt?.reasoningEffort ? undefined : preservedReasoning
+  });
+  await restorePreservedServiceTier({
+    linkPath: input.linkPath,
+    preserved: input.preservedServiceTier?.has(input.agentName) ?? false,
+    value: input.preservedServiceTier?.get(input.agentName) ?? null
+  });
+  await applyAgentOverride({ linkPath: input.linkPath, override });
+  const model = override?.model ?? extractModel(await readFile8(input.agentPath, "utf8"));
+  return {
+    ...model === null ? {} : { model },
+    ...override?.reasoningEffort === undefined ? {} : { reasoningEffort: override.reasoningEffort }
+  };
+}
 async function discoverBundledAgents(pluginRoot) {
-  const componentsRoot = join13(pluginRoot, "components");
+  const componentsRoot = join14(pluginRoot, "components");
   if (!await exists3(componentsRoot))
     return [];
   const componentEntries = await readdir2(componentsRoot, { withFileTypes: true });
@@ -10183,14 +10362,14 @@ async function discoverBundledAgents(pluginRoot) {
   for (const entry of componentEntries) {
     if (!entry.isDirectory())
       continue;
-    const agentsRoot = join13(componentsRoot, entry.name, "agents");
+    const agentsRoot = join14(componentsRoot, entry.name, "agents");
     if (!await exists3(agentsRoot))
       continue;
     const agentEntries = await readdir2(agentsRoot, { withFileTypes: true });
     for (const file of agentEntries) {
       if (!file.isFile() || !file.name.endsWith(".toml"))
         continue;
-      agents.push(join13(agentsRoot, file.name));
+      agents.push(join14(agentsRoot, file.name));
     }
   }
   agents.sort();
@@ -10203,16 +10382,16 @@ async function replaceWithCopy(linkPath, target) {
 async function prepareReplacement(linkPath) {
   if (!await exists3(linkPath))
     return;
-  const entryStat = await lstat5(linkPath);
+  const entryStat = await lstat6(linkPath);
   if (entryStat.isDirectory() && !entryStat.isSymbolicLink()) {
     throw new Error(`${linkPath} already exists and is a directory; refusing to replace`);
   }
-  await rm7(linkPath, { force: true });
+  await rm8(linkPath, { force: true });
 }
 async function writeManifest(pluginRoot, agentPaths) {
-  const manifestPath = join13(pluginRoot, MANIFEST_FILE);
+  const manifestPath = join14(pluginRoot, MANIFEST_FILE);
   const payload = { agents: [...agentPaths].sort() };
-  await writeFile5(manifestPath, `${JSON.stringify(payload, null, "\t")}
+  await writeFile6(manifestPath, `${JSON.stringify(payload, null, "\t")}
 `);
 }
 function agentNameFromToml2(fileName) {
@@ -10220,7 +10399,7 @@ function agentNameFromToml2(fileName) {
 }
 async function exists3(path) {
   try {
-    await lstat5(path);
+    await lstat6(path);
     return true;
   } catch (error) {
     if (nodeErrorCode3(error) !== "ENOENT")
@@ -10235,8 +10414,8 @@ function nodeErrorCode3(error) {
 }
 
 // ../src/install/codex-cache-bins.ts
-import { chmod as chmod2, lstat as lstat9, mkdir as mkdir5, readFile as readFile9, readdir as readdir4, readlink as readlink4, rm as rm10, stat as stat4, symlink, writeFile as writeFile6 } from "node:fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute4, join as join17, relative as relative2, resolve as resolve6, sep } from "node:path";
+import { chmod as chmod2, lstat as lstat9, mkdir as mkdir5, readFile as readFile11, readdir as readdir4, readlink as readlink4, rm as rm11, stat as stat4, symlink, writeFile as writeFile7 } from "node:fs/promises";
+import { basename as basename5, isAbsolute as isAbsolute4, join as join18, relative as relative2, resolve as resolve6, sep } from "node:path";
 
 // ../src/install/codex-cache-command-shim.ts
 var COMMAND_SHIM_MARKER = ":: generated by oh-my-openagent Codex installer";
@@ -10280,36 +10459,15 @@ function windowsCommandShim(targetPath) {
 }
 
 // ../src/install/codex-cache-dangling-bins.ts
-import { lstat as lstat7, readFile as readFile7, readdir as readdir3, readlink as readlink2, rm as rm8, stat as stat3 } from "node:fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute3, join as join14, resolve as resolve5 } from "node:path";
-
-// ../src/install/codex-cache-fs.ts
-import { lstat as lstat6 } from "node:fs/promises";
-async function fileExistsStrict(path) {
-  try {
-    await lstat6(path);
-    return true;
-  } catch (error) {
-    if (isNodeErrorWithCode(error) && error.code === "ENOENT")
-      return false;
-    throw error;
-  }
-}
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isNodeErrorWithCode(error) {
-  return typeof error === "object" && error !== null && "code" in error;
-}
-
-// ../src/install/codex-cache-dangling-bins.ts
+import { lstat as lstat7, readFile as readFile9, readdir as readdir3, readlink as readlink2, rm as rm9, stat as stat3 } from "node:fs/promises";
+import { dirname as dirname7, isAbsolute as isAbsolute3, join as join15, resolve as resolve5 } from "node:path";
 async function removeDanglingManagedComponentBins(binDir, platform, managedBinNames) {
   const entries = await readdir3(binDir, { withFileTypes: true });
   for (const entry of entries) {
     const binName = managedBinNameForEntry(entry.name, platform);
     if (binName === null || !managedBinNames.has(binName))
       continue;
-    const linkPath = join14(binDir, entry.name);
+    const linkPath = join15(binDir, entry.name);
     if (platform === "win32") {
       await removeDanglingGeneratedCommandShim(linkPath);
       continue;
@@ -10330,7 +10488,7 @@ async function removeDanglingManagedSymlink(linkPath) {
     const linkTarget = await readlink2(linkPath);
     const target = isAbsolute3(linkTarget) ? linkTarget : resolve5(dirname7(linkPath), linkTarget);
     if (!await isFileSystemEntry(target) && isManagedComponentBinTarget(target))
-      await rm8(linkPath, { force: true });
+      await rm9(linkPath, { force: true });
   } catch (error) {
     if (isNodeErrorWithCode(error) && error.code === "ENOENT")
       return;
@@ -10342,12 +10500,12 @@ async function removeDanglingGeneratedCommandShim(linkPath) {
     const linkStat = await lstat7(linkPath);
     if (!linkStat.isFile())
       return;
-    const content = await readFile7(linkPath, "utf8");
+    const content = await readFile9(linkPath, "utf8");
     if (!content.includes(COMMAND_SHIM_MARKER))
       return;
     const target = extractCommandShimTarget(content);
     if (target !== null && !await isFileSystemEntry(target) && isManagedComponentBinTarget(target))
-      await rm8(linkPath, { force: true });
+      await rm9(linkPath, { force: true });
   } catch (error) {
     if (isNodeErrorWithCode(error) && error.code === "ENOENT")
       return;
@@ -10390,8 +10548,8 @@ function hasOmoCodexPluginPrefix(parts, endExclusive) {
 }
 
 // ../src/install/codex-cache-legacy-bins.ts
-import { lstat as lstat8, readFile as readFile8, readlink as readlink3, rm as rm9 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { lstat as lstat8, readFile as readFile10, readlink as readlink3, rm as rm10 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 var LEGACY_CODEX_COMPONENT_BINS = [
   { name: "omo", component: "ulw-loop" },
   { name: "codex-comment-checker", component: "comment-checker" },
@@ -10404,7 +10562,7 @@ var LEGACY_CODEX_COMPONENT_BINS = [
 var LEGACY_CODEX_COMPONENT_BIN_NAMES = LEGACY_CODEX_COMPONENT_BINS.map((entry) => entry.name);
 async function removeLegacyCodexComponentBins(binDir, platform) {
   for (const entry of LEGACY_CODEX_COMPONENT_BINS) {
-    const linkPath = join15(binDir, platform === "win32" ? `${entry.name}.cmd` : entry.name);
+    const linkPath = join16(binDir, platform === "win32" ? `${entry.name}.cmd` : entry.name);
     await removeLegacyCodexComponentBin(linkPath, entry.component, platform);
   }
 }
@@ -10416,14 +10574,14 @@ async function removeLegacyCodexComponentBin(linkPath, component, platform) {
         return;
       const target = await readlink3(linkPath);
       if (isManagedLegacyComponentTarget(target, component))
-        await rm9(linkPath, { force: true });
+        await rm10(linkPath, { force: true });
       return;
     }
     if (!stat.isFile())
       return;
-    const content = await readFile8(linkPath, "utf8");
+    const content = await readFile10(linkPath, "utf8");
     if (content.includes(COMMAND_SHIM_MARKER))
-      await rm9(linkPath, { force: true });
+      await rm10(linkPath, { force: true });
   } catch (error) {
     if (isNodeErrorWithCode2(error) && error.code === "ENOENT")
       return;
@@ -10455,10 +10613,10 @@ function isNodeErrorWithCode2(error) {
 }
 
 // ../src/install/codex-cache-runtime-wrapper.ts
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 var RUNTIME_WRAPPER_MARKER = "OMO_GENERATED_RUNTIME_WRAPPER";
 function posixRuntimeWrapper(binName, cliPath, codexHome, binDir, nodeCliPath) {
-  const ulwLoopBin = toPosixPath2(join16(binDir, "omo-ulw-loop"));
+  const ulwLoopBin = toPosixPath2(join17(binDir, "omo-ulw-loop"));
   const nodeCli = escapePosixDoubleQuoted(toPosixPath2(nodeCliPath));
   const escapedCliPath = escapePosixDoubleQuoted(toPosixPath2(cliPath));
   const escapedCodexHome = escapePosixDoubleQuoted(toPosixPath2(codexHome));
@@ -10505,7 +10663,7 @@ function posixRuntimeWrapper(binName, cliPath, codexHome, binDir, nodeCliPath) {
 `);
 }
 function windowsRuntimeWrapper(binName, cliPath, codexHome, binDir, nodeCliPath) {
-  const ulwLoopBin = join16(binDir, "omo-ulw-loop.cmd");
+  const ulwLoopBin = join17(binDir, "omo-ulw-loop.cmd");
   return [
     "@echo off",
     `rem ${RUNTIME_WRAPPER_MARKER}`,
@@ -10571,23 +10729,23 @@ async function linkCachedPluginBins(input) {
   return linked;
 }
 async function linkRootRuntimeBin(input) {
-  const cliPath = join17(input.repoRoot, "dist", "cli", "index.js");
+  const cliPath = join18(input.repoRoot, "dist", "cli", "index.js");
   const platform = input.platform ?? process.platform;
-  const legacyPath = join17(input.binDir, platform === "win32" ? "omo.cmd" : "omo");
+  const legacyPath = join18(input.binDir, platform === "win32" ? "omo.cmd" : "omo");
   if (!await isFile2(cliPath)) {
     await removeGeneratedRuntimeWrapper(legacyPath);
     return null;
   }
   const binName = "omo-agent-toolkit";
-  const nodeCliPath = join17(input.repoRoot, "dist", "cli-node", "index.js");
+  const nodeCliPath = join18(input.repoRoot, "dist", "cli-node", "index.js");
   await mkdir5(input.binDir, { recursive: true });
   if (platform === "win32") {
-    const linkPath = join17(input.binDir, `${binName}.cmd`);
+    const linkPath = join18(input.binDir, `${binName}.cmd`);
     await replaceRuntimeWrapper(linkPath, windowsRuntimeWrapper(binName, cliPath, input.codexHome, input.binDir, nodeCliPath));
     await removeGeneratedRuntimeWrapper(legacyPath);
     return { name: binName, path: linkPath, target: cliPath };
   }
-  const linkPath = join17(input.binDir, binName);
+  const linkPath = join18(input.binDir, binName);
   await replaceRuntimeWrapper(linkPath, posixRuntimeWrapper(binName, cliPath, input.codexHome, input.binDir, nodeCliPath));
   await chmod2(linkPath, 493);
   await removeGeneratedRuntimeWrapper(legacyPath);
@@ -10595,11 +10753,11 @@ async function linkRootRuntimeBin(input) {
 }
 async function linkCachedPluginBin(binDir, link, platform) {
   if (platform === "win32") {
-    const linkPath = join17(binDir, `${link.name}.cmd`);
+    const linkPath = join18(binDir, `${link.name}.cmd`);
     await replaceCommandShim(linkPath, link.target);
     return linkPath;
   }
-  const linkPath = join17(binDir, link.name);
+  const linkPath = join18(binDir, link.name);
   await replaceSymlink(linkPath, link.target);
   return linkPath;
 }
@@ -10620,21 +10778,21 @@ async function discoverPackageBins(root) {
 async function collectPackageBins(directory, root, links) {
   const entries = await readdir4(directory, { withFileTypes: true });
   if (entries.some((entry) => entry.isFile() && entry.name === "package.json")) {
-    await appendPackageBinLinks(join17(directory, "package.json"), directory, root, links);
+    await appendPackageBinLinks(join18(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 = join17(directory, entry.name);
+    const childPath = join18(directory, entry.name);
     if (!childPath.startsWith(root))
       continue;
     await collectPackageBins(childPath, root, links);
   }
 }
 async function appendPackageBinLinks(packageJsonPath, packageRoot, root, links) {
-  const packageJson = JSON.parse(await readFile9(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await readFile11(packageJsonPath, "utf8"));
   if (!isPlainRecord(packageJson))
     return;
   const packageName = packageJson.name;
@@ -10680,19 +10838,19 @@ function resolvePackageBinTarget(packageRoot, target) {
 async function replaceSymlink(linkPath, targetPath) {
   if (await existingNonSymlink(linkPath))
     throw new Error(`${linkPath} already exists and is not a symlink`);
-  await rm10(linkPath, { force: true });
+  await rm11(linkPath, { force: true });
   await symlink(targetPath, linkPath);
 }
 async function replaceCommandShim(linkPath, targetPath) {
   if (await existingNonShim(linkPath))
     throw new Error(`${linkPath} already exists and is not a command shim`);
-  await writeFile6(linkPath, windowsCommandShim(targetPath));
+  await writeFile7(linkPath, windowsCommandShim(targetPath));
 }
 async function replaceRuntimeWrapper(linkPath, content) {
   if (await existingNonRuntimeWrapper(linkPath))
     throw new Error(`${linkPath} already exists and is not a generated OMO runtime wrapper`);
-  await rm10(linkPath, { force: true });
-  await writeFile6(linkPath, content);
+  await rm11(linkPath, { force: true });
+  await writeFile7(linkPath, content);
 }
 async function removeGeneratedRuntimeWrapper(path) {
   try {
@@ -10701,7 +10859,7 @@ async function removeGeneratedRuntimeWrapper(path) {
       return;
     const content = await readGeneratedWrapperContent(path);
     if (content.includes(RUNTIME_WRAPPER_MARKER))
-      await rm10(path, { force: true });
+      await rm11(path, { force: true });
   } catch (error) {
     if (isNodeErrorWithCode(error) && error.code === "ENOENT")
       return;
@@ -10710,7 +10868,7 @@ async function removeGeneratedRuntimeWrapper(path) {
 }
 async function readGeneratedWrapperContent(path) {
   try {
-    return await readFile9(path, "utf8");
+    return await readFile11(path, "utf8");
   } catch (error) {
     if (isNodeErrorWithCode(error) && (error.code === "ENOENT" || error.code === "EISDIR"))
       return "";
@@ -10724,7 +10882,7 @@ async function existingNonRuntimeWrapper(path) {
       return false;
     if (!stat.isFile())
       return true;
-    const content = await readFile9(path, "utf8");
+    const content = await readFile11(path, "utf8");
     return !content.includes(RUNTIME_WRAPPER_MARKER);
   } catch (error) {
     if (isNodeErrorWithCode(error) && error.code === "ENOENT")
@@ -10737,7 +10895,7 @@ async function existingNonShim(path) {
     const stat = await lstat9(path);
     if (!stat.isFile())
       return true;
-    const content = await readFile9(path, "utf8");
+    const content = await readFile11(path, "utf8");
     if (content.includes(COMMAND_SHIM_MARKER))
       return false;
     throw new Error(`${path} already exists and is not a generated command shim`);
@@ -10762,7 +10920,7 @@ async function existingNonSymlink(path) {
 }
 
 // ../src/install/codex-config-toml.ts
-import { mkdir as mkdir6, readFile as readFile11 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile13 } from "node:fs/promises";
 import { dirname as dirname9 } from "node:path";
 
 // ../src/install/toml-setting-reader.ts
@@ -11204,8 +11362,8 @@ function isRootSetting(line, key) {
 }
 
 // ../src/install/codex-model-catalog.ts
-import { readFile as readFile10 } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { readFile as readFile12 } from "node:fs/promises";
+import { join as join19 } from "node:path";
 var FALLBACK_CODEX_MODEL_CATALOG = {
   current: {
     model: "gpt-6-astra",
@@ -11236,9 +11394,9 @@ var FALLBACK_CODEX_MODEL_CATALOG = {
   ]
 };
 async function readCodexModelCatalog(codexPackageRoot) {
-  const catalogPath = join18(codexPackageRoot, "plugin", "model-catalog.json");
+  const catalogPath = join19(codexPackageRoot, "plugin", "model-catalog.json");
   try {
-    const parsed = JSON.parse(await readFile10(catalogPath, "utf8"));
+    const parsed = JSON.parse(await readFile12(catalogPath, "utf8"));
     return parseCodexModelCatalog(parsed) ?? FALLBACK_CODEX_MODEL_CATALOG;
   } catch (error) {
     if (error instanceof Error)
@@ -11320,7 +11478,7 @@ function isRootSetting2(line, key) {
 
 // ../src/install/codex-multi-agent-v2-config.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname8, isAbsolute as isAbsolute5, join as join19 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute5, join as join20 } from "node:path";
 var CODEX_AGENTS_HEADER = "agents";
 var CODEX_MULTI_AGENT_V2_HEADER = "features.multi_agent_v2";
 function ensureCodexMultiAgentV2Config(config, options = {}) {
@@ -11348,8 +11506,8 @@ function resolveCodexMultiAgentVersion(config, configPath) {
 }
 function resolveCatalogPath(configuredPath, configPath) {
   if (configuredPath === null)
-    return join19(dirname8(configPath), "models_cache.json");
-  return isAbsolute5(configuredPath) ? configuredPath : join19(dirname8(configPath), configuredPath);
+    return join20(dirname8(configPath), "models_cache.json");
+  return isAbsolute5(configuredPath) ? configuredPath : join20(dirname8(configPath), configuredPath);
 }
 function readCatalogMultiAgentVersion(model, cachePath) {
   let raw;
@@ -11463,7 +11621,7 @@ async function updateCodexConfig(input) {
   await mkdir6(dirname9(input.configPath), { recursive: true });
   let config;
   try {
-    config = await readFile11(input.configPath, "utf8");
+    config = await readFile13(input.configPath, "utf8");
   } catch (error) {
     if (!isMissingFileError(error))
       throw error;
@@ -11509,14 +11667,14 @@ function isMissingFileError(error) {
 }
 
 // ../src/install/codex-git-bash-mcp-env.ts
-import { readFile as readFile12, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
+import { join as join21 } from "node:path";
 var GIT_BASH_ENV_KEY = "OMO_CODEX_GIT_BASH_PATH";
 async function stampGitBashMcpEnv(input) {
-  const manifestPath = join20(input.pluginRoot, ".mcp.json");
+  const manifestPath = join21(input.pluginRoot, ".mcp.json");
   if (!await fileExistsStrict(manifestPath))
     return false;
-  const parsed = JSON.parse(await readFile12(manifestPath, "utf8"));
+  const parsed = JSON.parse(await readFile14(manifestPath, "utf8"));
   if (!isPlainRecord(parsed) || !isPlainRecord(parsed["mcpServers"]))
     return false;
   let changed = false;
@@ -11534,15 +11692,15 @@ async function stampGitBashMcpEnv(input) {
   }
   if (!changed)
     return false;
-  await writeFile7(manifestPath, `${JSON.stringify(parsed, null, "\t")}
+  await writeFile8(manifestPath, `${JSON.stringify(parsed, null, "\t")}
 `);
   return true;
 }
 
 // ../src/install/codex-hook-trust.ts
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { readFile as readFile15 } from "node:fs/promises";
+import { join as join22 } from "node:path";
 var EVENT_LABELS = new Map([
   ["PreToolUse", "pre_tool_use"],
   ["PermissionRequest", "permission_request"],
@@ -11556,18 +11714,18 @@ var EVENT_LABELS = new Map([
   ["Stop", "stop"]
 ]);
 async function trustedHookStatesForPlugin(input) {
-  const manifestPath = join21(input.pluginRoot, ".codex-plugin", "plugin.json");
+  const manifestPath = join22(input.pluginRoot, ".codex-plugin", "plugin.json");
   if (!await exists4(manifestPath))
     return [];
-  const manifest = JSON.parse(await readFile13(manifestPath, "utf8"));
+  const manifest = JSON.parse(await readFile15(manifestPath, "utf8"));
   if (!isPlainRecord(manifest))
     return [];
   const states = [];
   for (const hookPath of hookManifestPaths(manifest.hooks)) {
-    const hooksPath = join21(input.pluginRoot, hookPath);
+    const hooksPath = join22(input.pluginRoot, hookPath);
     if (!await exists4(hooksPath))
       continue;
-    const parsed = JSON.parse(await readFile13(hooksPath, "utf8"));
+    const parsed = JSON.parse(await readFile15(hooksPath, "utf8"));
     if (!isPlainRecord(parsed) || !isPlainRecord(parsed.hooks))
       continue;
     states.push(...trustedHookStatesForHooksFile({
@@ -11650,7 +11808,7 @@ function stripDotSlash(value) {
 }
 async function exists4(path) {
   try {
-    await readFile13(path, "utf8");
+    await readFile15(path, "utf8");
     return true;
   } catch (error) {
     if (error instanceof Error)
@@ -11661,7 +11819,7 @@ async function exists4(path) {
 
 // ../src/install/codex-installer-bin-dir.ts
 import { homedir as homedir4 } from "node:os";
-import { join as join22, resolve as resolve7 } from "node:path";
+import { join as join23, resolve as resolve7 } from "node:path";
 function resolveCodexInstallerBinDir(input) {
   const explicitBinDir = input.binDir ?? input.env?.CODEX_LOCAL_BIN_DIR;
   if (explicitBinDir !== undefined && explicitBinDir.trim().length > 0)
@@ -11670,7 +11828,7 @@ function resolveCodexInstallerBinDir(input) {
   const defaultCodexHome = resolve7(homeDir, ".codex");
   const resolvedCodexHome = resolve7(input.codexHome);
   if (resolvedCodexHome !== defaultCodexHome)
-    return join22(resolvedCodexHome, "bin");
+    return join23(resolvedCodexHome, "bin");
   return resolve7(homeDir, ".local", "bin");
 }
 
@@ -11826,24 +11984,27 @@ async function resolveGitBashStep(options, degraded) {
   return false;
 }
 async function linkBundledAgentsStep(options) {
-  const agentsTarget = join23(options.codexHome, "agents");
+  const agentsTarget = join24(options.codexHome, "agents");
   try {
-    const stageRoot = join23(options.pluginData, "bootstrap", "agents-stage");
+    const stageRoot = join24(options.pluginData, "bootstrap", "agents-stage");
     await stageBundledAgents(options.pluginRoot, stageRoot);
     const preservedReasoning = await capturePreservedAgentReasoning({ codexHome: options.codexHome });
     const preservedServiceTier = await capturePreservedAgentServiceTier({ codexHome: options.codexHome });
-    const config = readDefaultRoleConfig({ env: options.env });
+    const config = readCodexAgentConfig({ env: options.env });
     const linked = await linkCachedPluginAgents({
       codexHome: options.codexHome,
       pluginRoot: stageRoot,
       preservedReasoning,
       preservedServiceTier,
-      defaultRoleEnabled: config.enabled
+      defaultRoleEnabled: config.defaultRoleEnabled,
+      agentOverrides: config.agentOverrides
     });
+    const managedAgentNames = new Set(linked.map((link) => agentNameFromToml3(link.name)));
+    const warnings = [...config.warnings, ...unmanagedAgentOverrideWarnings(config.agentOverrides, managedAgentNames)];
     const agentConfigs = linked.map((link) => ({ configFile: `./agents/${link.name}`, name: agentNameFromToml3(link.name) })).sort((left, right) => left.name.localeCompare(right.name));
     return {
       agentConfigs,
-      degraded: config.warnings.map((reason) => ({ component: "agents-config", hint: BOOTSTRAP_DOCTOR_HINT, reason }))
+      degraded: warnings.map((reason) => ({ component: "agents-config", hint: BOOTSTRAP_DOCTOR_HINT, reason }))
     };
   } catch (error) {
     return {
@@ -11859,23 +12020,23 @@ async function linkBundledAgentsStep(options) {
   }
 }
 async function stageBundledAgents(pluginRoot, stageRoot) {
-  await rm11(stageRoot, { force: true, recursive: true });
+  await rm12(stageRoot, { force: true, recursive: true });
   await mkdir7(stageRoot, { recursive: true });
-  const componentsRoot = join23(pluginRoot, "components");
+  const componentsRoot = join24(pluginRoot, "components");
   for (const componentName of await directoryNames(componentsRoot)) {
-    const agentsDir = join23(componentsRoot, componentName, "agents");
+    const agentsDir = join24(componentsRoot, componentName, "agents");
     const agentFiles = (await fileNames(agentsDir)).filter((name) => name.endsWith(".toml"));
     if (agentFiles.length === 0)
       continue;
-    const stagedAgentsDir = join23(stageRoot, "components", componentName, "agents");
+    const stagedAgentsDir = join24(stageRoot, "components", componentName, "agents");
     await mkdir7(stagedAgentsDir, { recursive: true });
     for (const agentFile of agentFiles) {
-      await copyFile2(join23(agentsDir, agentFile), join23(stagedAgentsDir, agentFile));
+      await copyFile2(join24(agentsDir, agentFile), join24(stagedAgentsDir, agentFile));
     }
   }
 }
 async function updateConfigStep(options, inputs, degraded) {
-  const configPath = join23(options.codexHome, "config.toml");
+  const configPath = join24(options.codexHome, "config.toml");
   try {
     await assertWritableConfigIfPresent(configPath);
     const existingConfig = await readConfigIfPresent(configPath);
@@ -11921,7 +12082,7 @@ function errorCode(error) {
 }
 async function readConfigIfPresent(configPath) {
   try {
-    return await readFile14(configPath, "utf8");
+    return await readFile16(configPath, "utf8");
   } catch (error) {
     if (errorCode(error) === "ENOENT")
       return "";
@@ -11942,7 +12103,7 @@ async function linkComponentBinsStep(options, degraded) {
   await linkRuntimeWrapperStep(options, binDir, degraded);
 }
 async function linkRuntimeWrapperStep(options, binDir, degraded) {
-  const cliPath = join23(options.pluginRoot, "dist", "cli", "index.js");
+  const cliPath = join24(options.pluginRoot, "dist", "cli", "index.js");
   try {
     const linked = await linkRootRuntimeBin({
       binDir,
@@ -11975,7 +12136,7 @@ async function stampGitBashEnvStep(options, degraded) {
     degraded.push({
       component: "git-bash-env",
       hint: BOOTSTRAP_DOCTOR_HINT,
-      reason: `failed to stamp ${join23(options.pluginRoot, ".mcp.json")}: ${errorMessage(error)}`
+      reason: `failed to stamp ${join24(options.pluginRoot, ".mcp.json")}: ${errorMessage(error)}`
     });
   }
 }
@@ -12043,11 +12204,11 @@ function resolvePluginDataRoot(env) {
   const fromEnv = env["PLUGIN_DATA"]?.trim();
   if (fromEnv !== undefined && fromEnv.length > 0)
     return fromEnv;
-  return join24(homedir5(), ".local", "share", "lazycodex");
+  return join25(homedir5(), ".local", "share", "lazycodex");
 }
 async function readPluginVersion(pluginRoot) {
   try {
-    const parsed = JSON.parse(await readFile15(join24(pluginRoot, ".codex-plugin", "plugin.json"), "utf8"));
+    const parsed = JSON.parse(await readFile17(join25(pluginRoot, ".codex-plugin", "plugin.json"), "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return;
     const version = parsed["version"];
@@ -12117,7 +12278,7 @@ async function runBootstrapWorker(options = {}) {
       degraded.push({
         component: "bootstrap",
         hint: BOOTSTRAP_DOCTOR_HINT,
-        reason: `plugin version unresolved from ${join24(pluginRoot, ".codex-plugin", "plugin.json")}`
+        reason: `plugin version unresolved from ${join25(pluginRoot, ".codex-plugin", "plugin.json")}`
       });
     }
     for (const step of steps) {
@@ -12160,7 +12321,7 @@ function resolvePluginRoot(env) {
 }
 async function appendBootstrapLog(pluginData, now, event, details) {
   try {
-    const logPath = join24(pluginData, "bootstrap", "bootstrap.log");
+    const logPath = join25(pluginData, "bootstrap", "bootstrap.log");
     await mkdir8(dirname10(logPath), { recursive: true });
     await appendFile2(logPath, `${JSON.stringify({ timestamp: new Date(now).toISOString(), event, ...details })}
 `);