negotium 0.6.2 → 0.6.4

package/dist/mcp-factories.js

@@ -1025,235 +1025,6 @@ 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 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
-import {
-  chmodSync as chmodSync3,
-  copyFileSync,
-  existsSync as existsSync6,
-  mkdtempSync,
-  readFileSync as readFileSync6,
-  renameSync as renameSync4,
-  rmSync,
-  unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync5
-} from "fs";
-import { createRequire as createRequire2 } from "module";
-import { tmpdir } from "os";
-import { dirname as dirname4, join as join5 } from "path";
-function readPackageVersion(packageJsonPath) {
-  const parsed = JSON.parse(readFileSync6(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 join5(dirname4(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 = readFileSync6(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 (existsSync6(path) && readFileSync6(path, "utf8") === contents)
-    return;
-  const tempPath = `${path}.${process.pid}.${randomUUID3()}.tmp`;
-  try {
-    writeFileSync5(tempPath, contents, { encoding: "utf8", mode: 384 });
-    renameSync4(tempPath, path);
-    chmodSync3(path, 384);
-  } finally {
-    try {
-      unlinkSync6(tempPath);
-    } catch {}
-  }
-}
-function bundledCodexModelCachePath(authFilePath) {
-  return join5(dirname4(authFilePath), NEGOTIUM_MODEL_CACHE);
-}
-async function bootstrapCodexModelCache(codexHome, cachePath) {
-  const child = spawn(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
-    env: { ...process.env, CODEX_HOME: codexHome },
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  await new Promise((resolve4, 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 (!existsSync6(cachePath))
-        reject(new Error("Codex did not create its model cache"));
-      else
-        resolve4();
-    };
-    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 = dirname4(authFilePath);
-  const isolatedHome = mkdtempSync(join5(tmpdir(), "negotium-codex-models-"));
-  const isolatedCachePath = join5(isolatedHome, "models_cache.json");
-  try {
-    const isolatedAuthPath = join5(isolatedHome, "auth.json");
-    copyFileSync(authFilePath, isolatedAuthPath);
-    chmodSync3(isolatedAuthPath, 384);
-    const sourceConfigPath = join5(sourceHome, "config.toml");
-    if (existsSync6(sourceConfigPath)) {
-      const isolatedConfigPath = join5(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 = dirname4(authFilePath);
-  const configuredCachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE;
-  if (configuredCachePath) {
-    if (!existsSync6(configuredCachePath)) {
-      throw new Error(`Configured Codex model cache does not exist: ${configuredCachePath}`);
-    }
-    readCompatibleCodexModelCache(configuredCachePath);
-    return configuredCachePath;
-  }
-  const bundledCachePath = bundledCodexModelCachePath(authFilePath);
-  const sharedCachePath = join5(codexHome, "models_cache.json");
-  if (existsSync6(sharedCachePath)) {
-    try {
-      const shared = readCompatibleCodexModelCache(sharedCachePath);
-      writePrivateFileAtomic(bundledCachePath, shared.contents);
-      return bundledCachePath;
-    } catch {}
-  }
-  if (existsSync6(bundledCachePath)) {
-    try {
-      readCompatibleCodexModelCache(bundledCachePath);
-      return bundledCachePath;
-    } catch {}
-  }
-  const refreshedContents = await bootstrapIsolatedCodexModelCache(authFilePath, bootstrap);
-  writePrivateFileAtomic(bundledCachePath, refreshedContents);
-  return bundledCachePath;
-}
-function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath) {
-  const codexHome = dirname4(authFilePath);
-  const outputPath = join5(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/security/sensitive-path.ts
 import { realpathSync } from "fs";
 import { resolve as resolve4 } from "path";
@@ -1482,7 +1253,7 @@ function deriveBgBashContextCapability(runtimeCapability, userId, topic) {
 var init_context = () => {};
 
 // ../../packages/core/src/platform/background-bash/manager.ts
-import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
+import { execFileSync as execFileSync2, spawn } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 function makeBgBashKey(_userId, _topic) {
   return "runtime";
@@ -1509,7 +1280,7 @@ function createBackgroundBashManager(options = {}) {
   const now = options.now ?? Date.now;
   const wait = options.delay ?? delay;
   const portPids = options.portPids ?? defaultPortPids;
-  const spawnImpl = options.spawn ?? ((command, args, spawnOptions) => spawn2(command, [...args], spawnOptions));
+  const spawnImpl = options.spawn ?? ((command, args, spawnOptions) => spawn(command, [...args], spawnOptions));
   function contextKey(userId, topic) {
     return `${userId}\x00${topic}`;
   }
@@ -2303,7 +2074,7 @@ var init_mcp_config = __esm(() => {
 // ../../packages/core/src/storage/storage-host.ts
 import { mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname5, join as join6, resolve as resolve5 } from "path";
+import { dirname as dirname4, join as join5, resolve as resolve5 } from "path";
 function storageState() {
   const holder = globalThis;
   const existing = holder[STORAGE_HOST_STATE];
@@ -2331,23 +2102,23 @@ function envPath(name, fallback) {
   return resolve5(value2 || fallback);
 }
 function defaultStateDir() {
-  return envPath("NEGOTIUM_STATE_DIR", join6(homedir4(), ".negotium"));
+  return envPath("NEGOTIUM_STATE_DIR", join5(homedir4(), ".negotium"));
 }
 function defaultDataDir() {
-  return envPath("NEGOTIUM_DATA_DIR", join6(defaultStateDir(), "data"));
+  return envPath("NEGOTIUM_DATA_DIR", join5(defaultStateDir(), "data"));
 }
 function defaultLogDir() {
-  return envPath("NEGOTIUM_LOG_DIR", join6(defaultStateDir(), "logs"));
+  return envPath("NEGOTIUM_LOG_DIR", join5(defaultStateDir(), "logs"));
 }
 function defaultWorkspaceDir() {
-  return envPath("NEGOTIUM_WORKSPACE_DIR", join6(defaultStateDir(), "workspace"));
+  return envPath("NEGOTIUM_WORKSPACE_DIR", join5(defaultStateDir(), "workspace"));
 }
 function defaultSessionAsksDir() {
-  const runDir = envPath("NEGOTIUM_RUN_DIR", join6(defaultStateDir(), "runtime"));
-  return join6(runDir, "session-asks");
+  const runDir = envPath("NEGOTIUM_RUN_DIR", join5(defaultStateDir(), "runtime"));
+  return join5(runDir, "session-asks");
 }
 function defaultSessionsDatabasePath() {
-  return envPath("SESSIONS_DB_PATH", join6(resolveStorageDataDir(), "sessions.db"));
+  return envPath("SESSIONS_DB_PATH", join5(resolveStorageDataDir(), "sessions.db"));
 }
 function isSqliteBusy(error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -2382,7 +2153,7 @@ function defaultDatabase() {
     return state.fallbackDatabase;
   if (state.fallbackDatabase)
     state.fallbackDatabase.close();
-  mkdirSync6(dirname5(path), { recursive: true });
+  mkdirSync6(dirname4(path), { recursive: true });
   state.fallbackDatabase = new Database(path, { create: true });
   state.fallbackDatabasePath = path;
   initializeDatabase(state.fallbackDatabase);
@@ -2404,7 +2175,7 @@ function resolveStorageWorkspaceDir() {
   return storageState().configuredHost.workspaceDir ?? defaultWorkspaceDir();
 }
 function resolveStorageSharedWikiDir() {
-  return storageState().configuredHost.sharedWikiDir ?? join6(resolveStorageWorkspaceDir(), "wiki");
+  return storageState().configuredHost.sharedWikiDir ?? join5(resolveStorageWorkspaceDir(), "wiki");
 }
 function registerStorageSchemaInitializer(initialize, priority = 100) {
   const initializers = storageState().schemaInitializers;
@@ -2513,8 +2284,8 @@ var init_vault_crypto = __esm(() => {
 });
 
 // ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync4, mkdirSync as mkdirSync7 } from "fs";
-import { join as join7 } from "path";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync7 } from "fs";
+import { join as join6 } from "path";
 function initializeVaultDatabase(database) {
   database.exec("PRAGMA journal_mode = WAL");
   database.exec("PRAGMA busy_timeout = 5000");
@@ -2549,11 +2320,11 @@ function initializeVaultDatabase(database) {
   }
 }
 function openVaultDatabase(dataDir) {
-  const vaultDir = join7(dataDir, "vault");
-  const path = join7(vaultDir, "vault.db");
+  const vaultDir = join6(dataDir, "vault");
+  const path = join6(vaultDir, "vault.db");
   mkdirSync7(vaultDir, { recursive: true, mode: 448 });
   const database = new Database(path, { create: true });
-  chmodSync4(path, 384);
+  chmodSync3(path, 384);
   initializeVaultDatabase(database);
   return database;
 }
@@ -2658,7 +2429,7 @@ var init_vault = __esm(async () => {
 
 // ../../packages/core/src/agents/execution-host.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname5 } from "path";
 function activeHost() {
   const scoped = scopedHost.getStore();
   if (scoped)
@@ -2693,7 +2464,7 @@ function hostedCodexAuthFilePath() {
   return activeHost().codexAuthFilePath();
 }
 function hostedCodexHomePath() {
-  return dirname6(hostedCodexAuthFilePath());
+  return dirname5(hostedCodexAuthFilePath());
 }
 var defaultHost, hostRegistrations, scopedHost;
 var init_execution_host = __esm(async () => {
@@ -2715,15 +2486,15 @@ var init_execution_host = __esm(async () => {
 
 // ../../packages/core/src/agents/rollout/codex.ts
 import { randomBytes as randomBytes4 } from "crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync7, realpathSync as realpathSync2, statSync as statSync3, unlinkSync as unlinkSync7 } from "fs";
-import { basename as basename2, dirname as dirname7, join as join8, resolve as resolve6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, realpathSync as realpathSync2, statSync as statSync3, unlinkSync as unlinkSync6 } from "fs";
+import { basename as basename2, dirname as dirname6, join as join7, resolve as resolve6 } from "path";
 function codexSessionsDir() {
-  return join8(hostedCodexHomePath(), "sessions");
+  return join7(hostedCodexHomePath(), "sessions");
 }
 function loadCodexShell() {
   if (_shellCache)
     return _shellCache;
-  const raw = readFileSync7(join8(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
+  const raw = readFileSync6(join7(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}`);
@@ -2790,8 +2561,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 = join8(codexSessionsDir(), yyyy, mm, dd);
-  return join8(dir, `rollout-${yyyy}-${mm}-${dd}T${hh}-${min}-${ss}-${threadId}.jsonl`);
+  const dir = join7(codexSessionsDir(), yyyy, mm, dd);
+  return join7(dir, `rollout-${yyyy}-${mm}-${dd}T${hh}-${min}-${ss}-${threadId}.jsonl`);
 }
 function canonicalFilePath(path) {
   const absolute = resolve6(path);
@@ -2799,7 +2570,7 @@ function canonicalFilePath(path) {
     return realpathSync2(absolute);
   } catch {
     try {
-      return join8(realpathSync2(dirname7(absolute)), basename2(absolute));
+      return join7(realpathSync2(dirname6(absolute)), basename2(absolute));
     } catch {
       return absolute;
     }
@@ -2909,7 +2680,7 @@ function readCodexPatchCallIds(threadId) {
   if (!path)
     return [];
   try {
-    return extractCodexPatchCallIds(readFileSync7(path, "utf8"));
+    return extractCodexPatchCallIds(readFileSync6(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex patch ids: rollout read failed");
     return [];
@@ -2920,7 +2691,7 @@ function readLatestCodexPatchPreview(threadId, expectedPaths, consumedCallIds =
   if (!path)
     return;
   try {
-    return extractLatestCodexPatchPreview(readFileSync7(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
+    return extractLatestCodexPatchPreview(readFileSync6(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
   } catch (error) {
     logger.debug({ error, threadId }, "codex patch preview: rollout read failed");
     return;
@@ -2978,7 +2749,7 @@ function readLatestCodexContextUsage(threadId) {
   if (!path)
     return;
   try {
-    return extractLatestCodexContextUsage(readFileSync7(path, "utf8"));
+    return extractLatestCodexContextUsage(readFileSync6(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex context usage: rollout read failed");
     return;
@@ -2989,7 +2760,7 @@ function readLatestCodexTokenTotals(threadId) {
   if (!path)
     return;
   try {
-    return extractLatestCodexTokenTotals(readFileSync7(path, "utf8"));
+    return extractLatestCodexTokenTotals(readFileSync6(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex token totals: rollout read failed");
     return;
@@ -3000,7 +2771,7 @@ function migrateCodexRolloutNativeMultiAgentMetadata(threadId) {
   if (!path)
     return false;
   try {
-    const entries = parseJsonlText(readFileSync7(path, "utf8"));
+    const entries = parseJsonlText(readFileSync6(path, "utf8"));
     let changed = false;
     for (const entry of entries) {
       if (entry.type !== "session_meta" && entry.type !== "turn_context")
@@ -3029,19 +2800,19 @@ function latestCodexRolloutPath(threadId) {
   try {
     if (buckets) {
       for (const bucket of buckets) {
-        const dir = join8(sessionsDir, bucket);
-        if (!existsSync7(dir))
+        const dir = join7(sessionsDir, bucket);
+        if (!existsSync6(dir))
           continue;
         const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
         for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-          candidates.push(join8(dir, rel));
+          candidates.push(join7(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(join8(sessionsDir, rel));
+        candidates.push(join7(sessionsDir, rel));
       }
     }
     return candidates.sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs)[0];
@@ -3162,15 +2933,15 @@ function sweepPriorRolloutsForThread(threadId) {
     return;
   }
   for (const bucket of buckets) {
-    const dir = join8(sessionsDir, bucket);
-    if (!existsSync7(dir))
+    const dir = join7(sessionsDir, bucket);
+    if (!existsSync6(dir))
       continue;
     try {
       const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-        const fullPath = join8(dir, rel);
+        const fullPath = join7(dir, rel);
         try {
-          unlinkSync7(fullPath);
+          unlinkSync6(fullPath);
         } catch (e) {
           if (e?.code !== "ENOENT") {
             logger.warn({ err: e, path: fullPath }, "writeCodexRollout: prior-rollout unlink failed (continuing)");
@@ -3186,9 +2957,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 = join8(sessionsDir, rel);
+      const fullPath = join7(sessionsDir, rel);
       try {
-        unlinkSync7(fullPath);
+        unlinkSync6(fullPath);
       } catch (e) {
         if (e?.code !== "ENOENT") {
           logger.warn({ err: e, path: fullPath }, "writeCodexRollout: prior-rollout unlink failed (continuing)");
@@ -3247,7 +3018,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 randomUUID3 } from "crypto";
+import {
+  chmodSync as chmodSync4,
+  copyFileSync,
+  existsSync as existsSync7,
+  mkdtempSync,
+  readFileSync as readFileSync7,
+  renameSync as renameSync4,
+  rmSync,
+  unlinkSync as unlinkSync7,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { createRequire as createRequire2 } from "module";
+import { tmpdir } from "os";
+import { dirname as dirname7, join as join8 } from "path";
+function readPackageVersion(packageJsonPath) {
+  const parsed = JSON.parse(readFileSync7(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 join8(dirname7(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 = readFileSync7(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 (existsSync7(path) && readFileSync7(path, "utf8") === contents)
+    return;
+  const tempPath = `${path}.${process.pid}.${randomUUID3()}.tmp`;
+  try {
+    writeFileSync5(tempPath, contents, { encoding: "utf8", mode: 384 });
+    renameSync4(tempPath, path);
+    chmodSync4(path, 384);
+  } finally {
+    try {
+      unlinkSync7(tempPath);
+    } catch {}
+  }
+}
+function bundledCodexModelCachePath(authFilePath) {
+  return join8(dirname7(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((resolve7, 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 (!existsSync7(cachePath))
+        reject(new Error("Codex did not create its model cache"));
+      else
+        resolve7();
+    };
+    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 = dirname7(authFilePath);
+  const isolatedHome = mkdtempSync(join8(tmpdir(), "negotium-codex-models-"));
+  const isolatedCachePath = join8(isolatedHome, "models_cache.json");
+  try {
+    const isolatedAuthPath = join8(isolatedHome, "auth.json");
+    copyFileSync(authFilePath, isolatedAuthPath);
+    chmodSync4(isolatedAuthPath, 384);
+    const sourceConfigPath = join8(sourceHome, "config.toml");
+    if (existsSync7(sourceConfigPath)) {
+      const isolatedConfigPath = join8(isolatedHome, "config.toml");
+      copyFileSync(sourceConfigPath, isolatedConfigPath);
+      chmodSync4(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 = dirname7(authFilePath);
+  const configuredCachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE;
+  if (configuredCachePath) {
+    if (!existsSync7(configuredCachePath)) {
+      throw new Error(`Configured Codex model cache does not exist: ${configuredCachePath}`);
+    }
+    readCompatibleCodexModelCache(configuredCachePath);
+    return configuredCachePath;
+  }
+  const bundledCachePath = bundledCodexModelCachePath(authFilePath);
+  const sharedCachePath = join8(codexHome, "models_cache.json");
+  if (existsSync7(sharedCachePath)) {
+    try {
+      const shared = readCompatibleCodexModelCache(sharedCachePath);
+      writePrivateFileAtomic(bundledCachePath, shared.contents);
+      return bundledCachePath;
+    } catch {}
+  }
+  if (existsSync7(bundledCachePath)) {
+    try {
+      readCompatibleCodexModelCache(bundledCachePath);
+      return bundledCachePath;
+    } catch {}
+  }
+  const refreshedContents = await bootstrapIsolatedCodexModelCache(authFilePath, bootstrap);
+  writePrivateFileAtomic(bundledCachePath, refreshedContents);
+  return bundledCachePath;
+}
+function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath) {
+  const codexHome = dirname7(authFilePath);
+  const outputPath = join8(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) => {
@@ -3367,7 +3372,6 @@ import { existsSync as existsSync8, unlinkSync as unlinkSync8 } from "fs";
 import { join as join9 } 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();
@@ -3402,7 +3406,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)
@@ -21542,4 +21547,4 @@ export {
   createAgentHealthMcpServer
 };
 
-//# debugId=DA8078449BC2B6E364756E2164756E21
+//# debugId=17A2FD732002839B64756E2164756E21