@kbediako/codex-orchestrator 0.1.2 → 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

@@ -2,8 +2,11 @@ import process from 'node:process';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { TaskManager } from '../manager.js';
+import { RunManifestWriter } from '../persistence/RunManifestWriter.js';
+import { TaskStateStore } from '../persistence/TaskStateStore.js';
 import { CommandPlanner, CommandBuilder, CommandTester, CommandReviewer } from './adapters/index.js';
-import { resolveEnvironment } from './run/environment.js';
+import { resolveEnvironmentPaths } from '../../../scripts/lib/run-manifests.js';
+import { normalizeEnvironmentPaths } from './run/environment.js';
 import { bootstrapManifest, loadManifest, updateHeartbeat, finalizeStatus, appendSummary, ensureGuardrailStatus, resetForResume, recordResumeEvent } from './run/manifest.js';
 import { ManifestPersister, persistManifest } from './run/manifestPersister.js';
 import { generateRunId } from './utils/runId.js';
@@ -15,17 +18,45 @@ 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 { loadUserConfig } from './config/userConfig.js';
-import { RunEventPublisher, snapshotStages } from './events/runEvents.js';
+import { loadPackageConfig, loadUserConfig } from './config/userConfig.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();
     scheduler = new SchedulerService();
-    constructor(baseEnv = resolveEnvironment()) {
+    constructor(baseEnv = resolveBaseEnvironment()) {
         this.baseEnv = baseEnv;
     }
     async start(options = {}) {
@@ -50,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;
@@ -77,7 +173,10 @@ export class CodexOrchestrator {
         const resolver = new PipelineResolver();
         const designConfig = await resolver.loadDesignConfig(actualEnv.repoRoot);
         const userConfig = await loadUserConfig(actualEnv);
-        const pipeline = resolvePipelineForResume(actualEnv, manifest, userConfig);
+        const fallbackConfig = manifest.pipeline_id === 'rlm' && userConfig?.source === 'repo'
+            ? await loadPackageConfig(actualEnv)
+            : null;
+        const pipeline = resolvePipelineForResume(actualEnv, manifest, userConfig, fallbackConfig);
         const envOverrides = resolver.resolveDesignEnvOverrides(designConfig, pipeline.id);
         await this.validateResumeToken(paths, manifest, options.resumeToken ?? null);
         recordResumeEvent(manifest, {
@@ -103,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;
@@ -196,11 +360,13 @@ export class CodexOrchestrator {
             logPath: params.paths.logPath
         });
     }
-    createTaskManager(runId, pipeline, executePipeline, getResult, plannerInstance) {
+    createTaskManager(runId, pipeline, executePipeline, getResult, plannerInstance, env) {
         const planner = plannerInstance ?? new CommandPlanner(pipeline);
         const builder = new CommandBuilder(executePipeline);
         const tester = new CommandTester(getResult);
         const reviewer = new CommandReviewer(getResult);
+        const stateStore = new TaskStateStore({ outDir: env.outRoot, runsDir: env.runsRoot });
+        const manifestWriter = new RunManifestWriter({ runsDir: env.runsRoot });
         const options = {
             planner,
             builder,
@@ -208,7 +374,7 @@ export class CodexOrchestrator {
             reviewer,
             runIdFactory: () => runId,
             modePolicy: (task, subtask) => this.determineMode(task, subtask),
-            persistence: { autoStart: true }
+            persistence: { autoStart: true, stateStore, manifestWriter }
         };
         return new TaskManager(options);
     }
@@ -251,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 });
@@ -262,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) {
@@ -399,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 {
@@ -435,6 +619,8 @@ export class CodexOrchestrator {
                     manifest,
                     paths,
                     runEvents: context.runEvents,
+                    eventStream: context.eventStream,
+                    onEventEntry: context.onEventEntry,
                     persister,
                     envOverrides
                 }).then((result) => {
@@ -445,7 +631,7 @@ export class CodexOrchestrator {
             return executing;
         };
         const getResult = () => pipelineResult;
-        const manager = this.createTaskManager(runId, pipeline, executePipeline, getResult, planner);
+        const manager = this.createTaskManager(runId, pipeline, executePipeline, getResult, planner, env);
         this.attachPlanTargetTracker(manager, manifest, paths, persister);
         getPrivacyGuard().reset();
         const controlPlaneResult = await this.controlPlane.guard({

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

@@ -1,34 +1,23 @@
-import { defaultDiagnosticsPipeline } from './defaultDiagnostics.js';
-import { designReferencePipeline } from './designReference.js';
-import { hiFiDesignToolkitPipeline } from './hiFiDesignToolkit.js';
 import { findPipeline } from '../config/userConfig.js';
-const builtinPipelines = new Map([
-    [defaultDiagnosticsPipeline.id, defaultDiagnosticsPipeline],
-    [designReferencePipeline.id, designReferencePipeline],
-    [hiFiDesignToolkitPipeline.id, hiFiDesignToolkitPipeline]
-]);
-function getBuiltinPipeline(id) {
-    if (!id) {
-        return null;
-    }
-    return builtinPipelines.get(id) ?? null;
+function resolveConfigSource(config) {
+    return config?.source === 'package' ? 'default' : 'user';
 }
-export function resolvePipeline(env, options) {
+export function resolvePipeline(_env, options) {
     const { pipelineId, config } = options;
+    const configSource = resolveConfigSource(config);
     if (pipelineId) {
         const fromUser = findPipeline(config, pipelineId);
         if (fromUser) {
-            return { pipeline: fromUser, source: 'user' };
-        }
-        const builtin = getBuiltinPipeline(pipelineId);
-        if (builtin) {
-            return { pipeline: builtin, source: 'default' };
+            return { pipeline: fromUser, source: configSource };
         }
-        throw new Error(`Pipeline '${pipelineId}' not found.`);
+        const suffix = config ? '' : ' (missing codex.orchestrator.json)';
+        throw new Error(`Pipeline '${pipelineId}' not found${suffix}.`);
     }
-    const defaultId = config?.defaultPipeline ?? defaultDiagnosticsPipeline.id;
+    const defaultId = config?.defaultPipeline ?? 'diagnostics';
     const userPipeline = findPipeline(config, defaultId);
-    const chosen = userPipeline ?? getBuiltinPipeline(defaultId) ?? defaultDiagnosticsPipeline;
-    const source = userPipeline ? 'user' : 'default';
-    return { pipeline: chosen, source };
+    if (userPipeline) {
+        return { pipeline: userPipeline, source: configSource };
+    }
+    const suffix = config ? '' : ' (missing codex.orchestrator.json)';
+    throw new Error(`Pipeline '${defaultId}' not found${suffix}.`);
 }

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

@@ -0,0 +1,31 @@
+import { basename } from 'node:path';
+export function buildRlmPrompt(input) {
+    const repoName = basename(input.repoRoot) || 'repo';
+    const maxIterations = input.maxIterations === 0 ? 'unlimited' : String(input.maxIterations);
+    const lines = [
+        `You are Codex running an RLM loop in repo "${repoName}".`,
+        `Goal: ${input.goal}`,
+        `Iteration: ${input.iteration} of ${maxIterations}.`
+    ];
+    if (input.diffSummary) {
+        lines.push('', 'Workspace summary:', input.diffSummary.trim());
+    }
+    if (input.lastValidatorOutput) {
+        lines.push('', 'Last validator output:', input.lastValidatorOutput.trim());
+    }
+    if (input.validatorCommand) {
+        lines.push('', `Validator command (do NOT run it): ${input.validatorCommand}`);
+    }
+    else {
+        lines.push('', 'Validator: none (budgeted run)');
+    }
+    lines.push('', 'Instructions:', '- Plan and apply minimal changes toward the goal.', '- Use tools as needed (edit files, run commands, inspect diffs).', '- Do not run the validator command; it will be run after you finish.', '- Self-refine before finalizing (ensure changes align with goal).');
+    if (input.roles === 'triad') {
+        if (input.subagentsEnabled) {
+            lines.push('', 'Use subagents if available: Planner, Critic, Reviser.');
+        }
+        lines.push('', 'Role split (single response with sections):', 'Planner: outline the plan.', 'Critic: identify risks or missing steps.', 'Reviser: execute the plan and summarize changes.');
+    }
+    lines.push('', 'End your response with:', 'Summary: <one-line summary of changes>', 'Next: <what to try next if validator still fails>');
+    return lines.join('\n');
+}

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

@@ -0,0 +1,177 @@
+import { execFile } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { promisify } from 'node:util';
+import { isoTimestamp } from '../utils/time.js';
+const execFileAsync = promisify(execFile);
+const MAX_DIFF_CHARS = 2000;
+const MAX_VALIDATOR_OUTPUT_CHARS = 4000;
+function truncate(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    return `${value.slice(0, maxChars)}...`;
+}
+function extractSummary(output) {
+    const lines = output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i] ?? '';
+        if (line.toLowerCase().startsWith('summary:')) {
+            return line.slice('summary:'.length).trim() || null;
+        }
+    }
+    return null;
+}
+function summarizeValidatorOutput(result) {
+    const combined = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join('\n');
+    if (!combined) {
+        return null;
+    }
+    return truncate(combined, MAX_VALIDATOR_OUTPUT_CHARS);
+}
+async function collectGitSummary(repoRoot) {
+    try {
+        const [statusResult, diffResult] = await Promise.all([
+            execFileAsync('git', ['status', '--short'], { cwd: repoRoot }),
+            execFileAsync('git', ['diff', '--stat'], { cwd: repoRoot })
+        ]);
+        const statusText = statusResult.stdout.trim() || 'clean';
+        const diffText = diffResult.stdout.trim() || 'no diff';
+        return [
+            'status:',
+            truncate(statusText, MAX_DIFF_CHARS),
+            'diff:',
+            truncate(diffText, MAX_DIFF_CHARS)
+        ].join('\n');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `git summary unavailable: ${message}`;
+    }
+}
+async function writeStateFile(path, state) {
+    await writeFile(path, JSON.stringify(state, null, 2), 'utf8');
+}
+async function writeValidatorLog(path, command, result) {
+    const lines = [];
+    lines.push(`[${isoTimestamp()}] $ ${command}`);
+    if (result.spawnError) {
+        lines.push('[validator] spawn error');
+    }
+    if (result.stdout.trim()) {
+        lines.push(result.stdout.trimEnd());
+    }
+    if (result.stderr.trim()) {
+        lines.push(result.stderr.trimEnd());
+    }
+    lines.push(`[exit] ${result.exitCode}`);
+    await writeFile(path, `${lines.join('\n')}\n`, 'utf8');
+}
+export async function runRlmLoop(options) {
+    const now = options.now ?? isoTimestamp;
+    const log = options.logger ?? (() => undefined);
+    const state = {
+        goal: options.goal,
+        validator: options.validatorCommand ?? 'none',
+        roles: options.roles,
+        maxIterations: options.maxIterations,
+        maxMinutes: options.maxMinutes ?? null,
+        iterations: []
+    };
+    const runDir = options.runDir;
+    const statePath = join(runDir, 'state.json');
+    await mkdir(runDir, { recursive: true });
+    const collectSummary = options.collectDiffSummary ?? collectGitSummary;
+    const maxIterations = options.maxIterations;
+    const maxMinutes = options.maxMinutes ?? null;
+    const startTime = Date.now();
+    const deadline = maxMinutes && maxMinutes > 0 ? startTime + maxMinutes * 60 * 1000 : null;
+    if (maxIterations === 0 && !options.validatorCommand && !deadline) {
+        state.final = { status: 'invalid_config', exitCode: 5 };
+        await writeStateFile(statePath, state);
+        return { state, exitCode: 5, error: 'validator none with unbounded budget' };
+    }
+    const timeExceeded = () => deadline !== null && Date.now() >= deadline;
+    let lastValidatorOutput = null;
+    const finalize = async (status) => {
+        state.final = status ?? { status: 'error', exitCode: 10 };
+        await writeStateFile(statePath, state);
+        return { state, exitCode: state.final.exitCode };
+    };
+    try {
+        for (let iteration = 1; maxIterations === 0 || iteration <= maxIterations; iteration += 1) {
+            if (timeExceeded()) {
+                if (options.validatorCommand) {
+                    return await finalize({ status: 'max_minutes', exitCode: 3 });
+                }
+                return await finalize({ status: 'budget_complete', exitCode: 0 });
+            }
+            const iterationStartedAt = now();
+            const preDiffSummary = await collectSummary(options.repoRoot);
+            const agentResult = await options.runAgent({
+                goal: options.goal,
+                iteration,
+                maxIterations,
+                roles: options.roles,
+                subagentsEnabled: options.subagentsEnabled,
+                validatorCommand: options.validatorCommand,
+                lastValidatorOutput,
+                diffSummary: preDiffSummary,
+                repoRoot: options.repoRoot
+            });
+            const postDiffSummary = await collectSummary(options.repoRoot);
+            const summary = agentResult.summary ?? extractSummary(agentResult.output) ?? null;
+            let validatorExitCode = null;
+            let validatorLogPath = null;
+            let validatorResult = null;
+            if (options.validatorCommand) {
+                if (!options.runValidator) {
+                    throw new Error('Validator runner missing');
+                }
+                const validatorLogFile = join(runDir, `validator-${iteration}.log`);
+                validatorResult = await options.runValidator(options.validatorCommand);
+                await writeValidatorLog(validatorLogFile, options.validatorCommand, validatorResult);
+                validatorLogPath = relative(options.repoRoot, validatorLogFile);
+                validatorExitCode = validatorResult.exitCode;
+                lastValidatorOutput = summarizeValidatorOutput(validatorResult);
+            }
+            state.iterations.push({
+                n: iteration,
+                startedAt: iterationStartedAt,
+                summary,
+                validatorExitCode,
+                validatorLogPath,
+                diffSummary: postDiffSummary
+            });
+            await writeStateFile(statePath, state);
+            if (validatorResult?.spawnError) {
+                return await finalize({ status: 'error', exitCode: 4 });
+            }
+            if (validatorExitCode === 0) {
+                return await finalize({ status: 'passed', exitCode: 0 });
+            }
+            if (maxIterations > 0 && iteration >= maxIterations) {
+                if (options.validatorCommand) {
+                    return await finalize({ status: 'max_iterations', exitCode: 3 });
+                }
+                return await finalize({ status: 'budget_complete', exitCode: 0 });
+            }
+            if (timeExceeded()) {
+                if (options.validatorCommand) {
+                    return await finalize({ status: 'max_minutes', exitCode: 3 });
+                }
+                return await finalize({ status: 'budget_complete', exitCode: 0 });
+            }
+            log(`RLM iteration ${iteration} complete; continuing.`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await finalize({ status: 'error', exitCode: 10 });
+        return { state, exitCode: 10, error: message };
+    }
+    return await finalize({ status: 'error', exitCode: 10 });
+}

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

@@ -0,0 +1 @@
+export {};