@kbediako/codex-orchestrator 0.1.3 → 0.1.4

package/dist/orchestrator/src/cli/metrics/metricsRecorder.js

@@ -5,7 +5,7 @@ import { ensureGuardrailStatus, appendSummary, upsertGuardrailSummary } from '..
 import { isoTimestamp } from '../utils/time.js';
 import { persistManifest } from '../run/manifestPersister.js';
 import { logger } from '../../logger.js';
-import { mergePendingMetricsEntries, updateMetricsAggregates, withMetricsLock } from './metricsAggregator.js';
+import { ensureMetricsTrailingNewline, mergePendingMetricsEntries, updateMetricsAggregates, withMetricsLock } from './metricsAggregator.js';
 import { EnvUtils } from '../../../../packages/shared/config/index.js';
 const TERMINAL_STATES = new Set(['succeeded', 'failed', 'cancelled']);
 const METRICS_PENDING_DIRNAME = 'metrics.pending';
@@ -89,6 +89,7 @@ export async function appendMetricsEntry(env, paths, manifest, persister) {
     };
     await mkdir(metricsRoot, { recursive: true });
     const appendEntry = async () => {
+        await ensureMetricsTrailingNewline(metricsPath);
         await appendFile(metricsPath, `${JSON.stringify(entry)}\n`, 'utf8');
     };
     const appendPendingEntry = async () => {
@@ -124,11 +125,8 @@ export async function appendMetricsEntry(env, paths, manifest, persister) {
         await mergePendingMetricsEntries(env);
         await appendEntry();
         await finalizeManifest(true);
+        await mergePendingMetricsEntries(env);
         await updateMetricsAggregates(env);
-        const mergedAfter = await mergePendingMetricsEntries(env);
-        if (mergedAfter > 0) {
-            await updateMetricsAggregates(env);
-        }
     });
     if (!acquired) {
         const pendingPath = await appendPendingEntry();

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

@@ -18,13 +18,40 @@ import { logger } from '../logger.js';
 import { getPrivacyGuard } from './services/execRuntime.js';
 import { PipelineResolver } from './services/pipelineResolver.js';
 import { ControlPlaneService } from './services/controlPlaneService.js';
+import { ControlWatcher } from './control/controlWatcher.js';
 import { SchedulerService } from './services/schedulerService.js';
 import { applyHandlesToRunSummary, applyPrivacyToRunSummary, persistRunSummary } from './services/runSummaryWriter.js';
 import { prepareRun, resolvePipelineForResume, overrideTaskEnvironment } from './services/runPreparation.js';
 import { loadPackageConfig, loadUserConfig } from './config/userConfig.js';
-import { RunEventPublisher, snapshotStages } from './events/runEvents.js';
+import { loadDelegationConfigFiles, computeEffectiveDelegationConfig, parseDelegationConfigOverride, splitDelegationConfigOverrides } from './config/delegationConfig.js';
+import { ControlServer } from './control/controlServer.js';
+import { RunEventEmitter, RunEventPublisher, snapshotStages } from './events/runEvents.js';
+import { RunEventStream, attachRunEventAdapter } from './events/runEventStream.js';
 import { CLI_EXECUTION_MODE_PARSER, resolveRequiresCloudPolicy } from '../utils/executionMode.js';
 const resolveBaseEnvironment = () => normalizeEnvironmentPaths(resolveEnvironmentPaths());
+const CONFIG_OVERRIDE_ENV_KEYS = ['CODEX_CONFIG_OVERRIDES', 'CODEX_MCP_CONFIG_OVERRIDES'];
+function collectDelegationEnvOverrides(env = process.env) {
+    const layers = [];
+    for (const key of CONFIG_OVERRIDE_ENV_KEYS) {
+        const raw = env[key];
+        if (!raw) {
+            continue;
+        }
+        const values = splitDelegationConfigOverrides(raw);
+        for (const value of values) {
+            try {
+                const layer = parseDelegationConfigOverride(value, 'env');
+                if (layer) {
+                    layers.push(layer);
+                }
+            }
+            catch (error) {
+                logger.warn(`Invalid delegation config override (env): ${error?.message ?? String(error)}`);
+            }
+        }
+    }
+    return layers;
+}
 export class CodexOrchestrator {
     baseEnv;
     controlPlane = new ControlPlaneService();
@@ -54,25 +81,90 @@ export class CodexOrchestrator {
             paths,
             persistIntervalMs: Math.max(1000, manifest.heartbeat_interval_seconds * 1000)
         });
-        const runEvents = this.createRunEventPublisher({
-            runId,
-            pipeline: preparation.pipeline,
-            manifest,
-            paths,
-            emitter: options.runEvents
-        });
-        return await this.performRunLifecycle({
-            env: preparation.env,
-            pipeline: preparation.pipeline,
-            manifest,
-            paths,
-            planner: preparation.planner,
-            taskContext: preparation.taskContext,
-            runId,
-            runEvents,
-            persister,
-            envOverrides: preparation.envOverrides
-        });
+        const emitter = options.runEvents ?? new RunEventEmitter();
+        let eventStream = null;
+        let controlServer = null;
+        let detachStream = null;
+        let onEventEntry;
+        try {
+            const stream = await RunEventStream.create({
+                paths,
+                taskId: manifest.task_id,
+                runId,
+                pipelineId: preparation.pipeline.id,
+                pipelineTitle: preparation.pipeline.title
+            });
+            eventStream = stream;
+            const configFiles = await loadDelegationConfigFiles({ repoRoot: preparation.env.repoRoot });
+            const envOverrideLayers = collectDelegationEnvOverrides();
+            const layers = [configFiles.global, configFiles.repo, ...envOverrideLayers].filter(Boolean);
+            const effectiveConfig = computeEffectiveDelegationConfig({
+                repoRoot: preparation.env.repoRoot,
+                layers
+            });
+            controlServer = effectiveConfig.ui.controlEnabled
+                ? await ControlServer.start({
+                    paths,
+                    config: effectiveConfig,
+                    eventStream: stream,
+                    runId
+                })
+                : null;
+            onEventEntry = (entry) => {
+                controlServer?.broadcast(entry);
+            };
+            const onStreamError = (error, payload) => {
+                logger.warn(`Failed to append run event ${payload.event}: ${error.message}`);
+            };
+            detachStream = attachRunEventAdapter(emitter, stream, onEventEntry, onStreamError);
+            const runEvents = this.createRunEventPublisher({
+                runId,
+                pipeline: preparation.pipeline,
+                manifest,
+                paths,
+                emitter
+            });
+            return await this.performRunLifecycle({
+                env: preparation.env,
+                pipeline: preparation.pipeline,
+                manifest,
+                paths,
+                planner: preparation.planner,
+                taskContext: preparation.taskContext,
+                runId,
+                runEvents,
+                eventStream: stream,
+                onEventEntry,
+                persister,
+                envOverrides: preparation.envOverrides
+            });
+        }
+        finally {
+            if (detachStream) {
+                try {
+                    detachStream();
+                }
+                catch (error) {
+                    logger.warn(`Failed to detach run event stream: ${error?.message ?? String(error)}`);
+                }
+            }
+            if (controlServer) {
+                try {
+                    await controlServer.close();
+                }
+                catch (error) {
+                    logger.warn(`Failed to close control server: ${error?.message ?? String(error)}`);
+                }
+            }
+            if (eventStream) {
+                try {
+                    await eventStream.close();
+                }
+                catch (error) {
+                    logger.warn(`Failed to close run event stream: ${error?.message ?? String(error)}`);
+                }
+            }
+        }
     }
     async resume(options) {
         const env = this.baseEnv;
@@ -110,25 +202,90 @@ export class CodexOrchestrator {
             persistIntervalMs: Math.max(1000, manifest.heartbeat_interval_seconds * 1000)
         });
         await persister.schedule({ manifest: true, heartbeat: true, force: true });
-        const runEvents = this.createRunEventPublisher({
-            runId: manifest.run_id,
-            pipeline,
-            manifest,
-            paths,
-            emitter: options.runEvents
-        });
-        return await this.performRunLifecycle({
-            env: preparation.env,
-            pipeline,
-            manifest,
-            paths,
-            planner: preparation.planner,
-            taskContext: preparation.taskContext,
-            runId: manifest.run_id,
-            runEvents,
-            persister,
-            envOverrides: preparation.envOverrides
-        });
+        const emitter = options.runEvents ?? new RunEventEmitter();
+        let eventStream = null;
+        let controlServer = null;
+        let detachStream = null;
+        let onEventEntry;
+        try {
+            const stream = await RunEventStream.create({
+                paths,
+                taskId: manifest.task_id,
+                runId: manifest.run_id,
+                pipelineId: pipeline.id,
+                pipelineTitle: pipeline.title
+            });
+            eventStream = stream;
+            const configFiles = await loadDelegationConfigFiles({ repoRoot: preparation.env.repoRoot });
+            const envOverrideLayers = collectDelegationEnvOverrides();
+            const layers = [configFiles.global, configFiles.repo, ...envOverrideLayers].filter(Boolean);
+            const effectiveConfig = computeEffectiveDelegationConfig({
+                repoRoot: preparation.env.repoRoot,
+                layers
+            });
+            controlServer = effectiveConfig.ui.controlEnabled
+                ? await ControlServer.start({
+                    paths,
+                    config: effectiveConfig,
+                    eventStream: stream,
+                    runId: manifest.run_id
+                })
+                : null;
+            onEventEntry = (entry) => {
+                controlServer?.broadcast(entry);
+            };
+            const onStreamError = (error, payload) => {
+                logger.warn(`Failed to append run event ${payload.event}: ${error.message}`);
+            };
+            detachStream = attachRunEventAdapter(emitter, stream, onEventEntry, onStreamError);
+            const runEvents = this.createRunEventPublisher({
+                runId: manifest.run_id,
+                pipeline,
+                manifest,
+                paths,
+                emitter
+            });
+            return await this.performRunLifecycle({
+                env: preparation.env,
+                pipeline,
+                manifest,
+                paths,
+                planner: preparation.planner,
+                taskContext: preparation.taskContext,
+                runId: manifest.run_id,
+                runEvents,
+                eventStream: stream,
+                onEventEntry,
+                persister,
+                envOverrides: preparation.envOverrides
+            });
+        }
+        finally {
+            if (detachStream) {
+                try {
+                    detachStream();
+                }
+                catch (error) {
+                    logger.warn(`Failed to detach run event stream: ${error?.message ?? String(error)}`);
+                }
+            }
+            if (controlServer) {
+                try {
+                    await controlServer.close();
+                }
+                catch (error) {
+                    logger.warn(`Failed to close control server: ${error?.message ?? String(error)}`);
+                }
+            }
+            if (eventStream) {
+                try {
+                    await eventStream.close();
+                }
+                catch (error) {
+                    logger.warn(`Failed to close run event stream: ${error?.message ?? String(error)}`);
+                }
+            }
+        }
     }
     async status(options) {
         const env = this.baseEnv;
@@ -260,6 +417,13 @@ export class CodexOrchestrator {
             updateHeartbeat(manifest);
             return schedulePersist({ manifest: forceManifest, heartbeat: true, force: forceManifest });
         };
+        const controlWatcher = new ControlWatcher({
+            paths,
+            manifest,
+            eventStream: options.eventStream,
+            onEntry: options.onEventEntry,
+            persist: () => schedulePersist({ manifest: true, force: true })
+        });
         manifest.status = 'in_progress';
         updateHeartbeat(manifest);
         await schedulePersist({ manifest: true, heartbeat: true, force: true });
@@ -271,6 +435,13 @@ export class CodexOrchestrator {
         }, manifest.heartbeat_interval_seconds * 1000);
         try {
             for (let i = 0; i < pipeline.stages.length; i += 1) {
+                await controlWatcher.sync();
+                await controlWatcher.waitForResume();
+                if (controlWatcher.isCanceled()) {
+                    manifest.status_detail = 'run-canceled';
+                    success = false;
+                    break;
+                }
                 const stage = pipeline.stages[i];
                 const entry = manifest.commands[i];
                 if (!entry) {
@@ -408,7 +579,11 @@ export class CodexOrchestrator {
             clearInterval(heartbeatInterval);
             await schedulePersist({ force: true });
         }
-        if (success) {
+        await controlWatcher.sync();
+        if (controlWatcher.isCanceled()) {
+            finalizeStatus(manifest, 'cancelled', manifest.status_detail ?? 'run-canceled');
+        }
+        else if (success) {
             finalizeStatus(manifest, 'succeeded');
         }
         else {
@@ -444,6 +619,8 @@ export class CodexOrchestrator {
                     manifest,
                     paths,
                     runEvents: context.runEvents,
+                    eventStream: context.eventStream,
+                    onEventEntry: context.onEventEntry,
                     persister,
                     envOverrides
                 }).then((result) => {

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

@@ -13,6 +13,8 @@ import { buildRlmPrompt } from './rlm/prompt.js';
 import { runRlmLoop } from './rlm/runner.js';
 const execAsync = promisify(exec);
 const DEFAULT_MAX_ITERATIONS = 88;
+const DEFAULT_MAX_MINUTES = 48 * 60;
+const UNBOUNDED_ITERATION_ALIASES = new Set(['unbounded', 'unlimited', 'infinite', 'infinity']);
 function parseArgs(argv) {
     const parsed = {};
     for (let i = 0; i < argv.length; i += 1) {
@@ -120,6 +122,16 @@ function parsePositiveInt(value, fallback) {
     }
     return parsed;
 }
+function parseMaxIterations(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (UNBOUNDED_ITERATION_ALIASES.has(normalized)) {
+        return 0;
+    }
+    return parsePositiveInt(value, fallback);
+}
 function parseRoles(value, fallback) {
     if (!value) {
         return fallback;
@@ -257,8 +269,8 @@ async function main() {
     const parsedArgs = parseArgs(process.argv.slice(2));
     const goal = (parsedArgs.goal ?? env.RLM_GOAL)?.trim();
     const roles = parseRoles(parsedArgs.roles ?? env.RLM_ROLES, 'single');
-    const maxIterations = parsePositiveInt(parsedArgs.maxIterations ?? env.RLM_MAX_ITERATIONS, DEFAULT_MAX_ITERATIONS);
-    const maxMinutes = parsePositiveInt(parsedArgs.maxMinutes ?? env.RLM_MAX_MINUTES, 0);
+    const maxIterations = parseMaxIterations(parsedArgs.maxIterations ?? env.RLM_MAX_ITERATIONS, DEFAULT_MAX_ITERATIONS);
+    const maxMinutes = parsePositiveInt(parsedArgs.maxMinutes ?? env.RLM_MAX_MINUTES, DEFAULT_MAX_MINUTES);
     if (!goal) {
         const state = {
             goal: '',
@@ -300,7 +312,7 @@ async function main() {
             final: { status: 'invalid_config', exitCode: 5 }
         };
         await writeTerminalState(runDir, state);
-        console.error('Invalid max iterations value.');
+        console.error('Invalid max iterations value. Use a non-negative integer or one of "unlimited", "unbounded", "infinite", "infinity".');
         process.exitCode = 5;
         return;
     }
@@ -405,6 +417,11 @@ async function main() {
     const finalStatus = result.state.final?.status ?? 'unknown';
     const iterationCount = result.state.iterations.length;
     console.log(`RLM completed: status=${finalStatus} iterations=${iterationCount} exit=${result.exitCode}`);
+    const hasTimeCap = maxMinutes !== null && maxMinutes > 0;
+    const unboundedBudgetInvalid = validatorCommand === null && maxIterations === 0 && !hasTimeCap;
+    if (finalStatus === 'invalid_config' && unboundedBudgetInvalid) {
+        console.error('Invalid configuration: --validator none with unbounded iterations and --max-minutes 0 would run forever. Fix: set --max-minutes / RLM_MAX_MINUTES to a positive value (default 2880), set --max-iterations to a positive value, or provide a validator.');
+    }
     process.exitCode = result.exitCode;
 }
 const entry = process.argv[1] ? resolve(process.argv[1]) : null;
@@ -415,3 +432,9 @@ if (entry && entry === self) {
         process.exitCode = 10;
     });
 }
+export const __test__ = {
+    parseMaxIterations,
+    parsePositiveInt,
+    DEFAULT_MAX_ITERATIONS,
+    DEFAULT_MAX_MINUTES
+};

package/dist/orchestrator/src/cli/run/manifestPersister.js

@@ -21,6 +21,7 @@ export class ManifestPersister {
         this.writeHeartbeat = options.writeHeartbeat ?? writeHeartbeatFile;
     }
     schedule(options = {}) {
+        this.pendingPersist = this.pendingPersist.catch(() => undefined);
         const { manifest: includeManifest = false, heartbeat: includeHeartbeat = false, force = false } = options;
         this.dirtyManifest = this.dirtyManifest || includeManifest;
         this.dirtyHeartbeat = this.dirtyHeartbeat || includeHeartbeat;
@@ -70,13 +71,42 @@ export class ManifestPersister {
         const writeHeartbeat = this.dirtyHeartbeat;
         this.dirtyManifest = false;
         this.dirtyHeartbeat = false;
-        this.lastPersistAt = this.now();
+        const tasks = [];
         if (writeManifest) {
-            await this.writeManifest(this.paths, this.manifest);
+            tasks.push({
+                kind: 'manifest',
+                promise: Promise.resolve().then(() => this.writeManifest(this.paths, this.manifest))
+            });
         }
         if (writeHeartbeat) {
-            await this.writeHeartbeat(this.paths, this.manifest);
+            tasks.push({
+                kind: 'heartbeat',
+                promise: Promise.resolve().then(() => this.writeHeartbeat(this.paths, this.manifest))
+            });
+        }
+        const results = await Promise.allSettled(tasks.map((task) => task.promise));
+        let manifestError = null;
+        let heartbeatError = null;
+        let manifestFailed = false;
+        let heartbeatFailed = false;
+        results.forEach((result, index) => {
+            if (result.status === 'rejected') {
+                if (tasks[index].kind === 'manifest') {
+                    this.dirtyManifest = true;
+                    manifestFailed = true;
+                    manifestError = result.reason;
+                }
+                else {
+                    this.dirtyHeartbeat = true;
+                    heartbeatFailed = true;
+                    heartbeatError = result.reason;
+                }
+            }
+        });
+        if (manifestFailed || heartbeatFailed) {
+            throw manifestFailed ? manifestError : heartbeatError;
         }
+        this.lastPersistAt = this.now();
     }
 }
 export async function persistManifest(paths, manifest, persister, options = {}) {

package/dist/orchestrator/src/cli/run/runPaths.js

@@ -7,6 +7,13 @@ export function resolveRunPaths(env, runId) {
     const heartbeatPath = join(runDir, '.heartbeat');
     const resumeTokenPath = join(runDir, '.resume-token');
     const logPath = join(runDir, 'runner.ndjson');
+    const eventsPath = join(runDir, 'events.jsonl');
+    const controlPath = join(runDir, 'control.json');
+    const controlAuthPath = join(runDir, 'control_auth.json');
+    const controlEndpointPath = join(runDir, 'control_endpoint.json');
+    const confirmationsPath = join(runDir, 'confirmations.json');
+    const questionsPath = join(runDir, 'questions.json');
+    const delegationTokensPath = join(runDir, 'delegation_tokens.json');
     const commandsDir = join(runDir, 'commands');
     const errorsDir = join(runDir, 'errors');
     const compatDir = join(env.runsRoot, env.taskId, 'mcp', safeRunId);
@@ -18,6 +25,13 @@ export function resolveRunPaths(env, runId) {
         heartbeatPath,
         resumeTokenPath,
         logPath,
+        eventsPath,
+        controlPath,
+        controlAuthPath,
+        controlEndpointPath,
+        confirmationsPath,
+        questionsPath,
+        delegationTokensPath,
         commandsDir,
         errorsDir,
         compatDir,

package/dist/orchestrator/src/cli/services/commandRunner.js

@@ -12,7 +12,7 @@ import { EnvUtils } from '../../../../packages/shared/config/index.js';
 import { findPackageRoot } from '../utils/packageInfo.js';
 const MAX_BUFFERED_OUTPUT_BYTES = 64 * 1024;
 const EMIT_COMMAND_STREAM_MIRRORS = EnvUtils.getBoolean('CODEX_ORCHESTRATOR_EMIT_COMMAND_STREAMS', false);
-const MAX_CAPTURED_CHUNK_EVENTS = EnvUtils.getInt('CODEX_ORCHESTRATOR_EXEC_EVENT_MAX_CHUNKS', 0);
+export const MAX_CAPTURED_CHUNK_EVENTS = EnvUtils.getInt('CODEX_ORCHESTRATOR_EXEC_EVENT_MAX_CHUNKS', 500);
 const PACKAGE_ROOT = findPackageRoot();
 export async function runCommandStage(context, hooks = {}) {
     const { env, paths, manifest, stage, index, events, persister, envOverrides } = context;

package/dist/orchestrator/src/cli/utils/devtools.js

@@ -5,6 +5,7 @@ import process from 'node:process';
 import { EnvUtils } from '../../../../packages/shared/config/env.js';
 export const DEVTOOLS_SKILL_NAME = 'chrome-devtools';
 export const DEVTOOLS_CONFIG_OVERRIDE = 'mcp_servers.chrome-devtools.enabled=true';
+const CONFIG_OVERRIDE_ENV_KEYS = ['CODEX_MCP_CONFIG_OVERRIDES', 'CODEX_CONFIG_OVERRIDES'];
 const DEVTOOLS_CONFIG_FILENAME = 'config.toml';
 const DEVTOOLS_MCP_COMMAND = [
     'mcp',
@@ -86,16 +87,18 @@ export function buildDevtoolsSetupPlan(env = process.env) {
     };
 }
 export function resolveCodexCommand(args, env = process.env) {
+    const overrides = parseConfigOverrides(env);
     if (!isDevtoolsEnabled(env)) {
-        return { command: 'codex', args };
+        return { command: 'codex', args: applyConfigOverrides(overrides, args) };
     }
     const readiness = resolveDevtoolsReadiness(env);
     if (readiness.status !== 'ok') {
         throw new Error(formatDevtoolsPreflightError(readiness));
     }
+    const mergedOverrides = dedupeOverrides([DEVTOOLS_CONFIG_OVERRIDE, ...overrides]);
     return {
         command: 'codex',
-        args: ['-c', DEVTOOLS_CONFIG_OVERRIDE, ...args]
+        args: applyConfigOverrides(mergedOverrides, args)
     };
 }
 export function formatDevtoolsPreflightError(readiness) {
@@ -187,6 +190,34 @@ function hasDevtoolsConfigEntry(raw) {
     }
     return false;
 }
+function parseConfigOverrides(env) {
+    const overrides = [];
+    for (const key of CONFIG_OVERRIDE_ENV_KEYS) {
+        const raw = env[key];
+        if (!raw) {
+            continue;
+        }
+        const parts = raw
+            .split(/[,;\n]/)
+            .map((part) => part.trim())
+            .filter((part) => part.length > 0);
+        overrides.push(...parts);
+    }
+    return dedupeOverrides(overrides);
+}
+function applyConfigOverrides(overrides, args) {
+    if (overrides.length === 0) {
+        return args;
+    }
+    const configArgs = [];
+    for (const override of overrides) {
+        configArgs.push('-c', override);
+    }
+    return [...configArgs, ...args];
+}
+function dedupeOverrides(overrides) {
+    return Array.from(new Set(overrides.filter((override) => override.trim().length > 0)));
+}
 function stripTomlComment(line) {
     const index = line.indexOf('#');
     if (index === -1) {