@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/orchestrator/src/cli/codexDefaultsSetup.js

@@ -4,23 +4,29 @@ import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import process from 'node:process';
 import { resolveCodexHome } from './utils/codexPaths.js';
+import { resolveCodexCliBin } from './utils/codexCli.js';
+import { codexFeatureProbeDisablesMultiAgentV2, codexFeatureProbeRejectsAgentMaxThreads, readCodexFeatureProbe } from './utils/codexFeatures.js';
 import { findPackageRoot } from './utils/packageInfo.js';
 import { writeAtomicFile } from '../utils/atomicWrite.js';
 const require = createRequire(import.meta.url);
-const toml = require('@iarna/toml');
-const canonicalize = require('canonicalize');
-export const BASELINE_MODEL = 'gpt-5.3-codex';
+let tomlLibrary;
+export const BASELINE_MODEL = 'gpt-5.4';
+export const BASELINE_REVIEW_MODEL = BASELINE_MODEL;
+export const CURRENT_CHATGPT_MODEL = 'gpt-5.5';
 export const BASELINE_REASONING = 'xhigh';
 export const BASELINE_REASONING_MINIMUM = 'high';
 export const BASELINE_AGENTS = {
     max_threads: 12,
-    max_depth: 4,
-    max_spawn_depth: 4
+    max_depth: 4
 };
+export const LOCAL_MODEL_OPT_INS = [CURRENT_CHATGPT_MODEL];
+const LOCAL_MODEL_OPT_IN_SET = new Set(LOCAL_MODEL_OPT_INS);
+const CODEX_ORCHESTRATOR_CONFIG_KEY = 'codex_orchestrator';
+const LOCAL_MODEL_OPT_IN_CONFIG_KEY = 'local_model_opt_in';
 const ROLE_DEFINITIONS = [
     {
         key: 'explorer_fast',
-        description: 'Fast explorer (spark text-only).',
+        description: 'Fast explorer (spark file/codebase search only).',
         fileName: 'explorer-fast.toml',
         configFile: './agents/explorer-fast.toml',
         templatePath: join('templates', 'codex', '.codex', 'agents', 'explorer-fast.toml')
@@ -30,26 +36,45 @@ const ROLE_DEFINITIONS = [
         description: 'Complex implementation role.',
         fileName: 'worker-complex.toml',
         configFile: './agents/worker-complex.toml',
-        templatePath: join('templates', 'codex', '.codex', 'agents', 'worker-complex.toml')
+        templatePath: join('templates', 'codex', '.codex', 'agents', 'worker-complex.toml'),
+        managedMigrationBaselines: [{ model: 'gpt-5.5', modelReasoningEffort: 'xhigh' }]
     },
     {
         key: 'awaiter',
         description: 'Awaiter override (keeps awaiter behavior with latest codex/high reasoning).',
         fileName: 'awaiter-high.toml',
         configFile: './agents/awaiter-high.toml',
-        templatePath: join('templates', 'codex', '.codex', 'agents', 'awaiter-high.toml')
+        templatePath: join('templates', 'codex', '.codex', 'agents', 'awaiter-high.toml'),
+        managedMigrationBaselines: [{ model: 'gpt-5.5', modelReasoningEffort: 'xhigh' }],
+        managedMigrationContentVariants: [
+            {
+                model: 'gpt-5.5',
+                modelReasoningEffort: 'high',
+                overrideComment: '# with CO portable override to use gpt-5.4 at high reasoning.'
+            }
+        ]
     }
 ];
 export async function runCodexDefaultsSetup(options = {}) {
     const env = options.env ?? process.env;
     const force = Boolean(options.force);
     const apply = Boolean(options.apply);
-    const plan = buildPlan(env, force);
+    const configState = await loadConfigState(buildConfigPath(env));
+    const topLevelLocalModelOptIn = resolveRequestedLocalModelOptIn(configState.parsed, options.authScope);
+    const roleAndReviewLocalModelOptIn = resolveRoleAndReviewLocalModelOptIn(configState.parsed, topLevelLocalModelOptIn, options.authScope);
+    const authScope = topLevelLocalModelOptIn ? 'chatgpt' : 'portable';
+    const plan = buildPlan(env, force, authScope);
     const roleDefinitions = await loadRoleDefinitions();
-    const configState = await loadConfigState(plan.configPath);
-    const nextConfig = mergeBaselineDefaults(configState.parsed, roleDefinitions);
-    const configChanged = canonicalize(configState.parsed) !== canonicalize(nextConfig);
-    const roleChanges = await planRoleChanges(plan.agentsDir, force, roleDefinitions);
+    const featureProbe = readCodexFeatureProbe(resolveCodexCliBin(env), env);
+    const nextConfig = mergeBaselineDefaults(configState.parsed, roleDefinitions, {
+        topLevelLocalModelOptIn,
+        reviewModelOptIn: roleAndReviewLocalModelOptIn,
+        requestedAuthScope: options.authScope,
+        featureProbe
+    });
+    const activeRoleDefinitions = buildActiveRoleDefinitions(roleDefinitions, roleAndReviewLocalModelOptIn);
+    const configChanged = canonicalizeConfigValue(configState.parsed) !== canonicalizeConfigValue(nextConfig);
+    const roleChanges = await planRoleChanges(plan.agentsDir, force, activeRoleDefinitions);
     if (!apply) {
         const changes = buildPlannedChanges({
             configPath: plan.configPath,
@@ -65,7 +90,7 @@ export async function runCodexDefaultsSetup(options = {}) {
     }
     const changes = [];
     if (configChanged || !configState.exists) {
-        const rendered = `${toml.stringify(nextConfig)}\n`;
+        const rendered = `${getTomlLibrary().stringify(nextConfig)}\n`;
         await writeAtomicFile(plan.configPath, rendered, { ensureDir: true, encoding: 'utf8' });
         changes.push({
             target: 'config',
@@ -73,7 +98,7 @@ export async function runCodexDefaultsSetup(options = {}) {
             path: plan.configPath,
             status: configState.exists ? 'updated' : 'created',
             detail: configState.exists
-                ? 'Updated CO baseline defaults additively and preserved unrelated keys.'
+                ? 'Updated CO-compatible baseline defaults and preserved unrelated keys.'
                 : 'Created config.toml with CO baseline defaults.'
         });
     }
@@ -88,9 +113,7 @@ export async function runCodexDefaultsSetup(options = {}) {
     }
     await mkdir(plan.agentsDir, { recursive: true });
     for (const roleChange of roleChanges) {
-        const shouldWrite = roleChange.existingContent === null
-            || (force && roleChange.existingContent !== roleChange.definition.content);
-        if (shouldWrite) {
+        if (roleChange.writeReason) {
             await writeAtomicFile(roleChange.path, roleChange.definition.content, {
                 ensureDir: true,
                 encoding: 'utf8'
@@ -100,9 +123,7 @@ export async function runCodexDefaultsSetup(options = {}) {
                 name: roleChange.definition.key,
                 path: roleChange.path,
                 status: roleChange.existingContent === null ? 'created' : 'updated',
-                detail: roleChange.existingContent === null
-                    ? `Created ${roleChange.definition.fileName}.`
-                    : `Overwrote ${roleChange.definition.fileName} because --force was set.`
+                detail: formatAppliedRoleWriteDetail(roleChange)
             });
             continue;
         }
@@ -127,6 +148,7 @@ export function formatCodexDefaultsSetupSummary(result) {
     lines.push(`- Config: ${result.plan.configPath}`);
     lines.push(`- Agents dir: ${result.plan.agentsDir}`);
     lines.push(`- Force overwrite: ${result.plan.force ? 'yes' : 'no'}`);
+    lines.push(`- Auth scope: ${result.plan.authScope}`);
     lines.push('- Changes:');
     for (const change of result.changes) {
         lines.push(`  - ${change.target}:${change.name} -> ${change.status} (${change.path})`);
@@ -137,13 +159,18 @@ export function formatCodexDefaultsSetupSummary(result) {
     }
     return lines;
 }
-function buildPlan(env, force) {
+function buildConfigPath(env) {
+    return join(resolveCodexHome(env), 'config.toml');
+}
+function buildPlan(env, force, authScope) {
+    const configPath = buildConfigPath(env);
     const codexHome = resolveCodexHome(env);
     return {
         codexHome,
-        configPath: join(codexHome, 'config.toml'),
+        configPath,
         agentsDir: join(codexHome, 'agents'),
-        force
+        force,
+        authScope
     };
 }
 async function loadConfigState(configPath) {
@@ -152,7 +179,7 @@ async function loadConfigState(configPath) {
     }
     const raw = await readFile(configPath, 'utf8');
     try {
-        const parsed = toml.parse(raw);
+        const parsed = getTomlLibrary().parse(raw);
         if (!isRecord(parsed)) {
             throw new Error('top-level TOML document must be a table.');
         }
@@ -163,14 +190,59 @@ async function loadConfigState(configPath) {
         throw new Error(`Failed to parse Codex config TOML at ${configPath}: ${reason}`);
     }
 }
-function mergeBaselineDefaults(existing, roleDefinitions) {
+function getTomlLibrary() {
+    if (tomlLibrary) {
+        return tomlLibrary;
+    }
+    if (tomlLibrary === null) {
+        throw new Error('Failed to load @iarna/toml.');
+    }
+    try {
+        tomlLibrary = require('@iarna/toml');
+        return tomlLibrary;
+    }
+    catch (error) {
+        tomlLibrary = null;
+        throw error;
+    }
+}
+function canonicalizeConfigValue(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => canonicalizeConfigValue(entry) ?? 'null').join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
+            .flatMap(([key, entry]) => {
+            const canonicalEntry = canonicalizeConfigValue(entry);
+            if (typeof canonicalEntry === 'undefined') {
+                return [];
+            }
+            return [`${JSON.stringify(key)}:${canonicalEntry}`];
+        });
+        return `{${entries.join(',')}}`;
+    }
+    return undefined;
+}
+function mergeBaselineDefaults(existing, roleDefinitions, options) {
     const next = structuredClone(existing);
-    next.model = BASELINE_MODEL;
+    next.model = resolveModelDefault(options.topLevelLocalModelOptIn, BASELINE_MODEL);
+    next.review_model = resolveModelDefault(options.reviewModelOptIn, BASELINE_REVIEW_MODEL);
     next.model_reasoning_effort = BASELINE_REASONING;
+    removeLegacyLocalModelOptInMarker(next);
     const agents = isRecord(next.agents) ? structuredClone(next.agents) : {};
-    agents.max_threads = BASELINE_AGENTS.max_threads;
-    agents.max_depth = BASELINE_AGENTS.max_depth;
-    agents.max_spawn_depth = BASELINE_AGENTS.max_spawn_depth;
+    if (isMultiAgentV2Enabled(next, options.featureProbe)) {
+        delete agents.max_threads;
+    }
+    else {
+        agents.max_threads = BASELINE_AGENTS.max_threads;
+    }
     for (const role of roleDefinitions) {
         const existingRole = isRecord(agents[role.key])
             ? structuredClone(agents[role.key])
@@ -182,6 +254,71 @@ function mergeBaselineDefaults(existing, roleDefinitions) {
     next.agents = agents;
     return next;
 }
+export function isLocalModelOptIn(value) {
+    return typeof value === 'string' && LOCAL_MODEL_OPT_IN_SET.has(value);
+}
+export function resolveLocalModelOptIn(existing) {
+    const localConfig = isRecord(existing[CODEX_ORCHESTRATOR_CONFIG_KEY])
+        ? existing[CODEX_ORCHESTRATOR_CONFIG_KEY]
+        : null;
+    const configuredModel = localConfig?.[LOCAL_MODEL_OPT_IN_CONFIG_KEY];
+    return isLocalModelOptIn(configuredModel) ? configuredModel : null;
+}
+function resolveRequestedLocalModelOptIn(existing, requestedAuthScope) {
+    if (requestedAuthScope === 'portable') {
+        return null;
+    }
+    if (requestedAuthScope === 'chatgpt') {
+        return CURRENT_CHATGPT_MODEL;
+    }
+    const model = readOptionalString(existing.model);
+    const reviewModel = readOptionalString(existing.review_model);
+    if (isLocalModelOptIn(model)) {
+        return model;
+    }
+    if (isLocalModelOptIn(reviewModel)) {
+        return reviewModel;
+    }
+    return null;
+}
+function resolveRoleAndReviewLocalModelOptIn(existing, topLevelLocalModelOptIn, requestedAuthScope) {
+    if (requestedAuthScope === 'portable') {
+        return null;
+    }
+    if (topLevelLocalModelOptIn) {
+        return topLevelLocalModelOptIn;
+    }
+    const reviewModel = readOptionalString(existing.review_model);
+    const existingLocalModelOptIn = resolveLocalModelOptIn(existing);
+    return existingLocalModelOptIn === topLevelLocalModelOptIn
+        && reviewModel === topLevelLocalModelOptIn
+        && isLocalModelOptIn(reviewModel)
+        ? reviewModel
+        : null;
+}
+function readOptionalString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function removeLegacyLocalModelOptInMarker(next) {
+    const existingConfig = isRecord(next[CODEX_ORCHESTRATOR_CONFIG_KEY])
+        ? structuredClone(next[CODEX_ORCHESTRATOR_CONFIG_KEY])
+        : {};
+    if (LOCAL_MODEL_OPT_IN_CONFIG_KEY in existingConfig) {
+        delete existingConfig[LOCAL_MODEL_OPT_IN_CONFIG_KEY];
+        if (Object.keys(existingConfig).length > 0) {
+            next[CODEX_ORCHESTRATOR_CONFIG_KEY] = existingConfig;
+        }
+        else {
+            delete next[CODEX_ORCHESTRATOR_CONFIG_KEY];
+        }
+    }
+}
+export function formatModelDefaultExpectation(baseline) {
+    return `${CURRENT_CHATGPT_MODEL} when ChatGPT-auth access is verified (fallback: ${baseline})`;
+}
+function resolveModelDefault(localModelOptIn, baseline) {
+    return localModelOptIn ?? baseline;
+}
 async function planRoleChanges(agentsDir, force, roleDefinitions) {
     const changes = [];
     for (const definition of roleDefinitions) {
@@ -192,7 +329,8 @@ async function planRoleChanges(agentsDir, force, roleDefinitions) {
                 path,
                 existingContent: null,
                 currentStatus: 'pending',
-                detail: `Will create ${definition.fileName}.`
+                detail: `Will create ${definition.fileName}.`,
+                writeReason: 'create'
             });
             continue;
         }
@@ -203,7 +341,8 @@ async function planRoleChanges(agentsDir, force, roleDefinitions) {
                 path,
                 existingContent: current,
                 currentStatus: 'unchanged',
-                detail: `${definition.fileName} already matches CO baseline defaults.`
+                detail: `${definition.fileName} already matches CO baseline defaults.`,
+                writeReason: null
             });
             continue;
         }
@@ -213,7 +352,19 @@ async function planRoleChanges(agentsDir, force, roleDefinitions) {
                 path,
                 existingContent: current,
                 currentStatus: 'pending',
-                detail: `Will overwrite ${definition.fileName} because --force is set.`
+                detail: `Will overwrite ${definition.fileName} because --force is set.`,
+                writeReason: 'force'
+            });
+            continue;
+        }
+        if (definition.managedMigrationContents.includes(current)) {
+            changes.push({
+                definition,
+                path,
+                existingContent: current,
+                currentStatus: 'pending',
+                detail: `Will update ${definition.fileName} from a prior CO-managed model baseline.`,
+                writeReason: 'managed_migration'
             });
             continue;
         }
@@ -222,7 +373,8 @@ async function planRoleChanges(agentsDir, force, roleDefinitions) {
             path,
             existingContent: current,
             currentStatus: 'preserved',
-            detail: `${definition.fileName} already exists; preserving without --force.`
+            detail: `${definition.fileName} already exists; preserving without --force.`,
+            writeReason: null
         });
     }
     return changes;
@@ -240,10 +392,69 @@ async function loadRoleDefinitions() {
             const reason = error?.message ?? String(error);
             throw new Error(`Unable to read role template ${templateFile}: ${reason}`);
         }
-        loaded.push({ ...definition, content });
+        loaded.push({
+            ...definition,
+            content,
+            managedMigrationContents: buildManagedMigrationContents(content, definition)
+        });
     }
     return loaded;
 }
+function buildActiveRoleDefinitions(roleDefinitions, localModelOptIn) {
+    if (!localModelOptIn) {
+        return [...roleDefinitions];
+    }
+    return roleDefinitions.map((definition) => {
+        const matchingOptInBaseline = definition.managedMigrationBaselines?.find((baseline) => baseline.model === localModelOptIn);
+        if (!matchingOptInBaseline) {
+            return definition;
+        }
+        const optInContent = applyRoleBaselineOverrides(definition.content, definition.fileName, matchingOptInBaseline);
+        return {
+            ...definition,
+            content: optInContent,
+            managedMigrationContents: uniqueRoleContents([
+                definition.content,
+                ...definition.managedMigrationContents
+            ]).filter((migrationContent) => migrationContent !== optInContent)
+        };
+    });
+}
+function buildManagedMigrationContents(content, definition) {
+    const migrationContents = [
+        ...(definition.managedMigrationBaselines ?? []),
+        ...(definition.managedMigrationContentVariants ?? [])
+    ].map((baseline) => applyRoleBaselineOverrides(content, definition.fileName, baseline));
+    return uniqueRoleContents(migrationContents).filter((migrationContent) => migrationContent !== content);
+}
+function uniqueRoleContents(contents) {
+    return [...new Set(contents)];
+}
+function formatAppliedRoleWriteDetail(roleChange) {
+    switch (roleChange.writeReason) {
+        case 'create':
+            return `Created ${roleChange.definition.fileName}.`;
+        case 'force':
+            return `Overwrote ${roleChange.definition.fileName} because --force was set.`;
+        case 'managed_migration':
+            return `Updated ${roleChange.definition.fileName} from a prior CO-managed model baseline.`;
+        case null:
+            return roleChange.detail;
+    }
+}
+function applyRoleBaselineOverrides(content, fileName, baseline) {
+    let next = replaceRoleTomlString(content, 'model', baseline.model, fileName);
+    next = replaceRoleTomlString(next, 'model_reasoning_effort', baseline.modelReasoningEffort, fileName);
+    return next.replace(/^# with CO override to use .+ at .+ reasoning\.$/m, baseline.overrideComment
+        ?? `# with CO override to use ${baseline.model} at ${baseline.modelReasoningEffort} reasoning.`);
+}
+function replaceRoleTomlString(content, key, value, fileName) {
+    const pattern = new RegExp(`^(${key}\\s*=\\s*)"[^"]*"$`, 'm');
+    if (!pattern.test(content)) {
+        throw new Error(`Role template ${fileName} is missing a ${key} assignment.`);
+    }
+    return content.replace(pattern, (_match, prefix) => `${prefix}"${value}"`);
+}
 function buildPlannedChanges(params) {
     const changes = [];
     const configStatus = params.configChanged || !params.configExists ? 'pending' : 'unchanged';
@@ -254,7 +465,7 @@ function buildPlannedChanges(params) {
         status: configStatus,
         detail: configStatus === 'pending'
             ? params.configExists
-                ? 'Will update CO baseline defaults additively while preserving unrelated keys.'
+                ? 'Will update CO-compatible baseline defaults while preserving unrelated keys.'
                 : 'Will create config.toml with CO baseline defaults.'
             : 'CO baseline defaults already present.'
     });
@@ -272,3 +483,21 @@ function buildPlannedChanges(params) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
 }
+function isMultiAgentV2Enabled(config, featureProbe) {
+    if (featureProbe.flags?.multi_agent_v2 === true) {
+        return true;
+    }
+    if (codexFeatureProbeDisablesMultiAgentV2(featureProbe)) {
+        return false;
+    }
+    if (codexFeatureProbeRejectsAgentMaxThreads(featureProbe)) {
+        return true;
+    }
+    if (!isRecord(config.features)) {
+        return false;
+    }
+    return readBooleanValue(config.features.multi_agent_v2) === true;
+}
+function readBooleanValue(value) {
+    return typeof value === 'boolean' ? value : null;
+}