negotium 0.6.2 → 0.6.4

package/dist/agent-helpers.js

@@ -2445,246 +2445,17 @@ var init_claude_registry = __esm(() => {
   };
 });
 
-// ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.6.1";
-
-// ../../packages/core/src/agents/codex-native-multi-agent.ts
-import { spawn as spawn2 } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
-import {
-  chmodSync as chmodSync3,
-  copyFileSync,
-  existsSync as existsSync4,
-  mkdtempSync,
-  readFileSync as readFileSync4,
-  renameSync as renameSync3,
-  rmSync,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { createRequire as createRequire2 } from "module";
-import { tmpdir } from "os";
-import { dirname as dirname5, join as join6 } from "path";
-function readPackageVersion(packageJsonPath) {
-  const parsed = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
-  if (typeof parsed.version !== "string" || !parsed.version.trim()) {
-    throw new Error(`Codex package has no valid version: ${packageJsonPath}`);
-  }
-  return parsed.version;
-}
-function codexCliScriptPath() {
-  return join6(dirname5(bundledCodexPackagePath), "bin", "codex.js");
-}
-function parseCodexModelCache(contents, sourcePath) {
-  let parsed;
-  try {
-    parsed = JSON.parse(contents);
-  } catch (error) {
-    throw new Error(`Codex model cache is invalid JSON: ${sourcePath}`, { cause: error });
-  }
-  if (!Array.isArray(parsed.models) || parsed.models.length === 0) {
-    throw new Error(`Codex model cache has no models: ${sourcePath}`);
-  }
-  return parsed;
-}
-function readCodexModelCache(cachePath) {
-  const contents = readFileSync4(cachePath, "utf8");
-  return { contents, parsed: parseCodexModelCache(contents, cachePath) };
-}
-function readCompatibleCodexModelCache(cachePath) {
-  const cache = readCodexModelCache(cachePath);
-  if (cache.parsed.client_version !== BUNDLED_CODEX_VERSION) {
-    const found = typeof cache.parsed.client_version === "string" ? cache.parsed.client_version : "missing or invalid";
-    throw new Error(`Codex model cache version ${found} does not match Negotium's bundled Codex ${BUNDLED_CODEX_VERSION}: ${cachePath}`);
-  }
-  return cache;
-}
-function writePrivateFileAtomic(path, contents) {
-  if (existsSync4(path) && readFileSync4(path, "utf8") === contents)
-    return;
-  const tempPath = `${path}.${process.pid}.${randomUUID2()}.tmp`;
-  try {
-    writeFileSync4(tempPath, contents, { encoding: "utf8", mode: 384 });
-    renameSync3(tempPath, path);
-    chmodSync3(path, 384);
-  } finally {
-    try {
-      unlinkSync4(tempPath);
-    } catch {}
-  }
-}
-function bundledCodexModelCachePath(authFilePath) {
-  return join6(dirname5(authFilePath), NEGOTIUM_MODEL_CACHE);
-}
-async function bootstrapCodexModelCache(codexHome, cachePath) {
-  const child = spawn2(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
-    env: { ...process.env, CODEX_HOME: codexHome },
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  await new Promise((resolve5, reject) => {
-    let settled = false;
-    let stdoutBuffer = "";
-    let stderr = "";
-    const timer = setTimeout(() => finish(new Error("timed out while refreshing the Codex model catalog")), 15000);
-    const finish = (error) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      try {
-        child.stdin.end();
-        child.kill();
-      } catch {}
-      if (error)
-        reject(error);
-      else if (!existsSync4(cachePath))
-        reject(new Error("Codex did not create its model cache"));
-      else
-        resolve5();
-    };
-    const send = (message) => {
-      child.stdin.write(`${JSON.stringify(message)}
-`);
-    };
-    child.stderr.on("data", (chunk) => {
-      if (stderr.length < 4096)
-        stderr += String(chunk);
-    });
-    child.on("error", (error) => finish(error));
-    child.on("exit", (code, signal) => {
-      if (!settled) {
-        finish(new Error(`Codex model catalog refresh exited with ${signal ? `signal ${signal}` : `code ${code ?? 1}`}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
-      }
-    });
-    child.stdout.on("data", (chunk) => {
-      stdoutBuffer += String(chunk);
-      for (;; ) {
-        const newline = stdoutBuffer.indexOf(`
-`);
-        if (newline < 0)
-          break;
-        const line = stdoutBuffer.slice(0, newline);
-        stdoutBuffer = stdoutBuffer.slice(newline + 1);
-        let message;
-        try {
-          message = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        if (message.id === 1) {
-          if (message.error) {
-            finish(new Error(message.error.message || "Codex initialization failed"));
-            return;
-          }
-          send({ method: "initialized" });
-          send({ id: 2, method: "model/list", params: { includeHidden: true } });
-        } else if (message.id === 2) {
-          if (message.error) {
-            finish(new Error(message.error.message || "Codex model listing failed"));
-          } else {
-            finish();
-          }
-          return;
-        }
-      }
-    });
-    send({
-      id: 1,
-      method: "initialize",
-      params: {
-        clientInfo: { name: "negotium", version: NEGOTIUM_VERSION },
-        capabilities: { experimentalApi: true }
-      }
-    });
-  });
-}
-async function bootstrapIsolatedCodexModelCache(authFilePath, bootstrap) {
-  const sourceHome = dirname5(authFilePath);
-  const isolatedHome = mkdtempSync(join6(tmpdir(), "negotium-codex-models-"));
-  const isolatedCachePath = join6(isolatedHome, "models_cache.json");
-  try {
-    const isolatedAuthPath = join6(isolatedHome, "auth.json");
-    copyFileSync(authFilePath, isolatedAuthPath);
-    chmodSync3(isolatedAuthPath, 384);
-    const sourceConfigPath = join6(sourceHome, "config.toml");
-    if (existsSync4(sourceConfigPath)) {
-      const isolatedConfigPath = join6(isolatedHome, "config.toml");
-      copyFileSync(sourceConfigPath, isolatedConfigPath);
-      chmodSync3(isolatedConfigPath, 384);
-    }
-    await bootstrap(isolatedHome, isolatedCachePath);
-    return readCompatibleCodexModelCache(isolatedCachePath).contents;
-  } finally {
-    rmSync(isolatedHome, { recursive: true, force: true });
-  }
-}
-async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexModelCache) {
-  const codexHome = dirname5(authFilePath);
-  const configuredCachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE;
-  if (configuredCachePath) {
-    if (!existsSync4(configuredCachePath)) {
-      throw new Error(`Configured Codex model cache does not exist: ${configuredCachePath}`);
-    }
-    readCompatibleCodexModelCache(configuredCachePath);
-    return configuredCachePath;
-  }
-  const bundledCachePath = bundledCodexModelCachePath(authFilePath);
-  const sharedCachePath = join6(codexHome, "models_cache.json");
-  if (existsSync4(sharedCachePath)) {
-    try {
-      const shared = readCompatibleCodexModelCache(sharedCachePath);
-      writePrivateFileAtomic(bundledCachePath, shared.contents);
-      return bundledCachePath;
-    } catch {}
-  }
-  if (existsSync4(bundledCachePath)) {
-    try {
-      readCompatibleCodexModelCache(bundledCachePath);
-      return bundledCachePath;
-    } catch {}
-  }
-  const refreshedContents = await bootstrapIsolatedCodexModelCache(authFilePath, bootstrap);
-  writePrivateFileAtomic(bundledCachePath, refreshedContents);
-  return bundledCachePath;
-}
-function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath) {
-  const codexHome = dirname5(authFilePath);
-  const outputPath = join6(codexHome, NEGOTIUM_MODEL_CATALOG);
-  const parsed = readCodexModelCache(sourcePath).parsed;
-  const models = parsed.models.map((model, index) => {
-    if (!model || typeof model !== "object" || Array.isArray(model)) {
-      throw new Error(`Codex model cache entry ${index} is invalid: ${sourcePath}`);
-    }
-    return { ...model, multi_agent_version: "disabled" };
-  });
-  const contents = `${JSON.stringify({ models }, null, 2)}
-`;
-  writePrivateFileAtomic(outputPath, contents);
-  return outputPath;
-}
-var moduleRequire, codexSdkPackagePath, codexSdkRequire, bundledCodexPackagePath, BUNDLED_CODEX_VERSION, SAFE_BUNDLED_CODEX_VERSION, NEGOTIUM_MODEL_CACHE, NEGOTIUM_MODEL_CATALOG;
-var init_codex_native_multi_agent = __esm(() => {
-  moduleRequire = createRequire2(import.meta.url);
-  codexSdkPackagePath = moduleRequire.resolve("@openai/codex-sdk/package.json");
-  codexSdkRequire = createRequire2(codexSdkPackagePath);
-  bundledCodexPackagePath = codexSdkRequire.resolve("@openai/codex/package.json");
-  BUNDLED_CODEX_VERSION = readPackageVersion(bundledCodexPackagePath);
-  SAFE_BUNDLED_CODEX_VERSION = BUNDLED_CODEX_VERSION.replace(/[^a-zA-Z0-9._-]/g, "_");
-  NEGOTIUM_MODEL_CACHE = `negotium-models-cache-${SAFE_BUNDLED_CODEX_VERSION}.json`;
-  NEGOTIUM_MODEL_CATALOG = `negotium-model-catalog-${SAFE_BUNDLED_CODEX_VERSION}.json`;
-});
-
 // ../../packages/core/src/agents/rollout/codex.ts
 import { randomBytes as randomBytes4 } from "crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync2, unlinkSync as unlinkSync5 } from "fs";
-import { basename, dirname as dirname6, join as join7, resolve as resolve5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, realpathSync as realpathSync2, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
+import { basename, dirname as dirname5, join as join6, resolve as resolve5 } from "path";
 function codexSessionsDir() {
-  return join7(hostedCodexHomePath(), "sessions");
+  return join6(hostedCodexHomePath(), "sessions");
 }
 function loadCodexShell() {
   if (_shellCache)
     return _shellCache;
-  const raw = readFileSync5(join7(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
+  const raw = readFileSync4(join6(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
   const lines = parseJsonlText(raw);
   if (lines.length < 5) {
     throw new Error(`loadCodexShell: expected >=5 entries in codex-shell.jsonl, got ${lines.length}`);
@@ -2751,8 +2522,8 @@ function codexRolloutPath(threadId, fallback) {
   const hh = String(createdAt.getHours()).padStart(2, "0");
   const min = String(createdAt.getMinutes()).padStart(2, "0");
   const ss = String(createdAt.getSeconds()).padStart(2, "0");
-  const dir = join7(codexSessionsDir(), yyyy, mm, dd);
-  return join7(dir, `rollout-${yyyy}-${mm}-${dd}T${hh}-${min}-${ss}-${threadId}.jsonl`);
+  const dir = join6(codexSessionsDir(), yyyy, mm, dd);
+  return join6(dir, `rollout-${yyyy}-${mm}-${dd}T${hh}-${min}-${ss}-${threadId}.jsonl`);
 }
 function canonicalFilePath(path) {
   const absolute = resolve5(path);
@@ -2760,7 +2531,7 @@ function canonicalFilePath(path) {
     return realpathSync2(absolute);
   } catch {
     try {
-      return join7(realpathSync2(dirname6(absolute)), basename(absolute));
+      return join6(realpathSync2(dirname5(absolute)), basename(absolute));
     } catch {
       return absolute;
     }
@@ -2870,7 +2641,7 @@ function readCodexPatchCallIds(threadId) {
   if (!path)
     return [];
   try {
-    return extractCodexPatchCallIds(readFileSync5(path, "utf8"));
+    return extractCodexPatchCallIds(readFileSync4(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex patch ids: rollout read failed");
     return [];
@@ -2881,7 +2652,7 @@ function readLatestCodexPatchPreview(threadId, expectedPaths, consumedCallIds =
   if (!path)
     return;
   try {
-    return extractLatestCodexPatchPreview(readFileSync5(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
+    return extractLatestCodexPatchPreview(readFileSync4(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
   } catch (error) {
     logger.debug({ error, threadId }, "codex patch preview: rollout read failed");
     return;
@@ -2939,7 +2710,7 @@ function readLatestCodexContextUsage(threadId) {
   if (!path)
     return;
   try {
-    return extractLatestCodexContextUsage(readFileSync5(path, "utf8"));
+    return extractLatestCodexContextUsage(readFileSync4(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex context usage: rollout read failed");
     return;
@@ -2950,7 +2721,7 @@ function readLatestCodexTokenTotals(threadId) {
   if (!path)
     return;
   try {
-    return extractLatestCodexTokenTotals(readFileSync5(path, "utf8"));
+    return extractLatestCodexTokenTotals(readFileSync4(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex token totals: rollout read failed");
     return;
@@ -2961,7 +2732,7 @@ function migrateCodexRolloutNativeMultiAgentMetadata(threadId) {
   if (!path)
     return false;
   try {
-    const entries = parseJsonlText(readFileSync5(path, "utf8"));
+    const entries = parseJsonlText(readFileSync4(path, "utf8"));
     let changed = false;
     for (const entry of entries) {
       if (entry.type !== "session_meta" && entry.type !== "turn_context")
@@ -2990,19 +2761,19 @@ function latestCodexRolloutPath(threadId) {
   try {
     if (buckets) {
       for (const bucket of buckets) {
-        const dir = join7(sessionsDir, bucket);
-        if (!existsSync5(dir))
+        const dir = join6(sessionsDir, bucket);
+        if (!existsSync4(dir))
           continue;
         const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
         for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-          candidates.push(join7(dir, rel));
+          candidates.push(join6(dir, rel));
         }
       }
     }
     if (candidates.length === 0) {
       const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-        candidates.push(join7(sessionsDir, rel));
+        candidates.push(join6(sessionsDir, rel));
       }
     }
     return candidates.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
@@ -3123,15 +2894,15 @@ function sweepPriorRolloutsForThread(threadId) {
     return;
   }
   for (const bucket of buckets) {
-    const dir = join7(sessionsDir, bucket);
-    if (!existsSync5(dir))
+    const dir = join6(sessionsDir, bucket);
+    if (!existsSync4(dir))
       continue;
     try {
       const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-        const fullPath = join7(dir, rel);
+        const fullPath = join6(dir, rel);
         try {
-          unlinkSync5(fullPath);
+          unlinkSync4(fullPath);
         } catch (e) {
           if (e?.code !== "ENOENT") {
             logger.warn({ err: e, path: fullPath }, "writeCodexRollout: prior-rollout unlink failed (continuing)");
@@ -3147,9 +2918,9 @@ function sweepPriorRolloutsFullTree(threadId, sessionsDir) {
   try {
     const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
     for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-      const fullPath = join7(sessionsDir, rel);
+      const fullPath = join6(sessionsDir, rel);
       try {
-        unlinkSync5(fullPath);
+        unlinkSync4(fullPath);
       } catch (e) {
         if (e?.code !== "ENOENT") {
           logger.warn({ err: e, path: fullPath }, "writeCodexRollout: prior-rollout unlink failed (continuing)");
@@ -3208,7 +2979,241 @@ var init_codex = __esm(async () => {
   init_logger();
 });
 
+// ../../packages/core/src/version.ts
+var NEGOTIUM_VERSION = "0.6.4";
+
+// ../../packages/core/src/agents/codex-native-multi-agent.ts
+import { spawn as spawn2 } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  chmodSync as chmodSync3,
+  copyFileSync,
+  existsSync as existsSync5,
+  mkdtempSync,
+  readFileSync as readFileSync5,
+  renameSync as renameSync3,
+  rmSync,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { createRequire as createRequire2 } from "module";
+import { tmpdir } from "os";
+import { dirname as dirname6, join as join7 } from "path";
+function readPackageVersion(packageJsonPath) {
+  const parsed = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
+  if (typeof parsed.version !== "string" || !parsed.version.trim()) {
+    throw new Error(`Codex package has no valid version: ${packageJsonPath}`);
+  }
+  return parsed.version;
+}
+function codexCliScriptPath() {
+  return join7(dirname6(bundledCodexPackagePath), "bin", "codex.js");
+}
+function parseCodexModelCache(contents, sourcePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch (error) {
+    throw new Error(`Codex model cache is invalid JSON: ${sourcePath}`, { cause: error });
+  }
+  if (!Array.isArray(parsed.models) || parsed.models.length === 0) {
+    throw new Error(`Codex model cache has no models: ${sourcePath}`);
+  }
+  return parsed;
+}
+function readCodexModelCache(cachePath) {
+  const contents = readFileSync5(cachePath, "utf8");
+  return { contents, parsed: parseCodexModelCache(contents, cachePath) };
+}
+function readCompatibleCodexModelCache(cachePath) {
+  const cache = readCodexModelCache(cachePath);
+  if (cache.parsed.client_version !== BUNDLED_CODEX_VERSION) {
+    const found = typeof cache.parsed.client_version === "string" ? cache.parsed.client_version : "missing or invalid";
+    throw new Error(`Codex model cache version ${found} does not match Negotium's bundled Codex ${BUNDLED_CODEX_VERSION}: ${cachePath}`);
+  }
+  return cache;
+}
+function writePrivateFileAtomic(path, contents) {
+  if (existsSync5(path) && readFileSync5(path, "utf8") === contents)
+    return;
+  const tempPath = `${path}.${process.pid}.${randomUUID2()}.tmp`;
+  try {
+    writeFileSync4(tempPath, contents, { encoding: "utf8", mode: 384 });
+    renameSync3(tempPath, path);
+    chmodSync3(path, 384);
+  } finally {
+    try {
+      unlinkSync5(tempPath);
+    } catch {}
+  }
+}
+function bundledCodexModelCachePath(authFilePath) {
+  return join7(dirname6(authFilePath), NEGOTIUM_MODEL_CACHE);
+}
+async function bootstrapCodexModelCache(codexHome, cachePath) {
+  const child = spawn2(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
+    env: { ...process.env, CODEX_HOME: codexHome },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  await new Promise((resolve6, reject) => {
+    let settled = false;
+    let stdoutBuffer = "";
+    let stderr = "";
+    const timer = setTimeout(() => finish(new Error("timed out while refreshing the Codex model catalog")), 15000);
+    const finish = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.stdin.end();
+        child.kill();
+      } catch {}
+      if (error)
+        reject(error);
+      else if (!existsSync5(cachePath))
+        reject(new Error("Codex did not create its model cache"));
+      else
+        resolve6();
+    };
+    const send = (message) => {
+      child.stdin.write(`${JSON.stringify(message)}
+`);
+    };
+    child.stderr.on("data", (chunk) => {
+      if (stderr.length < 4096)
+        stderr += String(chunk);
+    });
+    child.on("error", (error) => finish(error));
+    child.on("exit", (code, signal) => {
+      if (!settled) {
+        finish(new Error(`Codex model catalog refresh exited with ${signal ? `signal ${signal}` : `code ${code ?? 1}`}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+      }
+    });
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += String(chunk);
+      for (;; ) {
+        const newline = stdoutBuffer.indexOf(`
+`);
+        if (newline < 0)
+          break;
+        const line = stdoutBuffer.slice(0, newline);
+        stdoutBuffer = stdoutBuffer.slice(newline + 1);
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (message.id === 1) {
+          if (message.error) {
+            finish(new Error(message.error.message || "Codex initialization failed"));
+            return;
+          }
+          send({ method: "initialized" });
+          send({ id: 2, method: "model/list", params: { includeHidden: true } });
+        } else if (message.id === 2) {
+          if (message.error) {
+            finish(new Error(message.error.message || "Codex model listing failed"));
+          } else {
+            finish();
+          }
+          return;
+        }
+      }
+    });
+    send({
+      id: 1,
+      method: "initialize",
+      params: {
+        clientInfo: { name: "negotium", version: NEGOTIUM_VERSION },
+        capabilities: { experimentalApi: true }
+      }
+    });
+  });
+}
+async function bootstrapIsolatedCodexModelCache(authFilePath, bootstrap) {
+  const sourceHome = dirname6(authFilePath);
+  const isolatedHome = mkdtempSync(join7(tmpdir(), "negotium-codex-models-"));
+  const isolatedCachePath = join7(isolatedHome, "models_cache.json");
+  try {
+    const isolatedAuthPath = join7(isolatedHome, "auth.json");
+    copyFileSync(authFilePath, isolatedAuthPath);
+    chmodSync3(isolatedAuthPath, 384);
+    const sourceConfigPath = join7(sourceHome, "config.toml");
+    if (existsSync5(sourceConfigPath)) {
+      const isolatedConfigPath = join7(isolatedHome, "config.toml");
+      copyFileSync(sourceConfigPath, isolatedConfigPath);
+      chmodSync3(isolatedConfigPath, 384);
+    }
+    await bootstrap(isolatedHome, isolatedCachePath);
+    return readCompatibleCodexModelCache(isolatedCachePath).contents;
+  } finally {
+    rmSync(isolatedHome, { recursive: true, force: true });
+  }
+}
+async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexModelCache) {
+  const codexHome = dirname6(authFilePath);
+  const configuredCachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE;
+  if (configuredCachePath) {
+    if (!existsSync5(configuredCachePath)) {
+      throw new Error(`Configured Codex model cache does not exist: ${configuredCachePath}`);
+    }
+    readCompatibleCodexModelCache(configuredCachePath);
+    return configuredCachePath;
+  }
+  const bundledCachePath = bundledCodexModelCachePath(authFilePath);
+  const sharedCachePath = join7(codexHome, "models_cache.json");
+  if (existsSync5(sharedCachePath)) {
+    try {
+      const shared = readCompatibleCodexModelCache(sharedCachePath);
+      writePrivateFileAtomic(bundledCachePath, shared.contents);
+      return bundledCachePath;
+    } catch {}
+  }
+  if (existsSync5(bundledCachePath)) {
+    try {
+      readCompatibleCodexModelCache(bundledCachePath);
+      return bundledCachePath;
+    } catch {}
+  }
+  const refreshedContents = await bootstrapIsolatedCodexModelCache(authFilePath, bootstrap);
+  writePrivateFileAtomic(bundledCachePath, refreshedContents);
+  return bundledCachePath;
+}
+function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath) {
+  const codexHome = dirname6(authFilePath);
+  const outputPath = join7(codexHome, NEGOTIUM_MODEL_CATALOG);
+  const parsed = readCodexModelCache(sourcePath).parsed;
+  const models = parsed.models.map((model, index) => {
+    if (!model || typeof model !== "object" || Array.isArray(model)) {
+      throw new Error(`Codex model cache entry ${index} is invalid: ${sourcePath}`);
+    }
+    return { ...model, multi_agent_version: "disabled" };
+  });
+  const contents = `${JSON.stringify({ models }, null, 2)}
+`;
+  writePrivateFileAtomic(outputPath, contents);
+  return outputPath;
+}
+var moduleRequire, codexSdkPackagePath, codexSdkRequire, bundledCodexPackagePath, BUNDLED_CODEX_VERSION, SAFE_BUNDLED_CODEX_VERSION, NEGOTIUM_MODEL_CACHE, NEGOTIUM_MODEL_CATALOG;
+var init_codex_native_multi_agent = __esm(() => {
+  moduleRequire = createRequire2(import.meta.url);
+  codexSdkPackagePath = moduleRequire.resolve("@openai/codex-sdk/package.json");
+  codexSdkRequire = createRequire2(codexSdkPackagePath);
+  bundledCodexPackagePath = codexSdkRequire.resolve("@openai/codex/package.json");
+  BUNDLED_CODEX_VERSION = readPackageVersion(bundledCodexPackagePath);
+  SAFE_BUNDLED_CODEX_VERSION = BUNDLED_CODEX_VERSION.replace(/[^a-zA-Z0-9._-]/g, "_");
+  NEGOTIUM_MODEL_CACHE = `negotium-models-cache-${SAFE_BUNDLED_CODEX_VERSION}.json`;
+  NEGOTIUM_MODEL_CATALOG = `negotium-model-catalog-${SAFE_BUNDLED_CODEX_VERSION}.json`;
+});
+
 // ../../packages/core/src/agents/codex-app-server.ts
+var exports_codex_app_server = {};
+__export(exports_codex_app_server, {
+  forkCodexSession: () => forkCodexSession,
+  createCodexAppServerForker: () => createCodexAppServerForker
+});
 import { spawn as spawn3 } from "child_process";
 function createCodexAppServerForker(host) {
   return async (parentThreadId) => {
@@ -3328,7 +3333,6 @@ import { existsSync as existsSync6, unlinkSync as unlinkSync6 } from "fs";
 import { join as join8 } from "path";
 var VALID_EFFORTS2, codexRegistry, codexRegistryOperations;
 var init_codex_registry = __esm(async () => {
-  await init_codex_app_server();
   await init_execution_host();
   await init_codex();
   init_logger();
@@ -3363,7 +3367,8 @@ var init_codex_registry = __esm(async () => {
       return { sessionId: threadId, rolloutPath };
     },
     async forkSession({ parentSessionId }) {
-      return await forkCodexSession(parentSessionId);
+      const { forkCodexSession: forkCodexSession2 } = await init_codex_app_server().then(() => exports_codex_app_server);
+      return await forkCodexSession2(parentSessionId);
     },
     async cleanupRollouts({ sessionIds }) {
       if (sessionIds.length === 0)
@@ -19289,4 +19294,4 @@ export {
   DEFAULT_SELF_CONFIG_PRODUCT
 };
 
-//# debugId=03CA2F824FB8358C64756E2164756E21
+//# debugId=6BFDBF463059259E64756E2164756E21