@kbediako/codex-orchestrator 0.1.1 → 0.1.3

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

@@ -0,0 +1,66 @@
+import { spawn } from 'node:child_process';
+import process from 'node:process';
+import { buildDevtoolsSetupPlan, resolveDevtoolsReadiness } from './utils/devtools.js';
+export async function runDevtoolsSetup(options = {}) {
+    const env = options.env ?? process.env;
+    const plan = buildDevtoolsSetupPlan(env);
+    const readiness = resolveDevtoolsReadiness(env);
+    if (!options.apply) {
+        return { status: 'planned', plan, readiness };
+    }
+    if (readiness.config.status === 'ok') {
+        return {
+            status: 'skipped',
+            reason: 'DevTools MCP is already configured.',
+            plan,
+            readiness
+        };
+    }
+    if (readiness.config.status === 'invalid') {
+        throw new Error(`Cannot apply DevTools setup because config.toml is invalid: ${readiness.config.path}`);
+    }
+    await applyDevtoolsSetup(plan, env);
+    return { status: 'applied', plan, readiness };
+}
+export function formatDevtoolsSetupSummary(result) {
+    const lines = [];
+    lines.push(`DevTools setup: ${result.status}`);
+    if (result.reason) {
+        lines.push(`Note: ${result.reason}`);
+    }
+    lines.push(`- Codex home: ${result.plan.codexHome}`);
+    lines.push(`- Skill: ${result.readiness.skill.status} (${result.readiness.skill.path})`);
+    const configLabel = result.readiness.config.status === 'invalid'
+        ? `invalid (${result.readiness.config.path})`
+        : `${result.readiness.config.status} (${result.readiness.config.path})`;
+    lines.push(`- Config: ${configLabel}`);
+    if (result.readiness.config.detail) {
+        lines.push(`  detail: ${result.readiness.config.detail}`);
+    }
+    if (result.readiness.config.error) {
+        lines.push(`  error: ${result.readiness.config.error}`);
+    }
+    lines.push(`- Command: ${result.plan.commandLine}`);
+    lines.push('- Config snippet:');
+    for (const line of result.plan.configSnippet.split('\n')) {
+        lines.push(`  ${line}`);
+    }
+    if (result.status === 'planned') {
+        lines.push('Run with --yes to apply this setup.');
+    }
+    return lines;
+}
+async function applyDevtoolsSetup(plan, env) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(plan.command, plan.args, { stdio: 'inherit', env });
+        child.once('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`codex mcp add exited with code ${code ?? 'unknown'}`));
+            }
+        });
+    });
+}

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

@@ -1,7 +1,5 @@
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import process from 'node:process';
+import { buildDevtoolsSetupPlan, DEVTOOLS_SKILL_NAME, resolveDevtoolsReadiness } from './utils/devtools.js';
 import { resolveOptionalDependency } from './utils/optionalDeps.js';
 const OPTIONAL_DEPENDENCIES = [
     {
@@ -12,7 +10,6 @@ const OPTIONAL_DEPENDENCIES = [
     { name: 'pixelmatch', install: 'npm install --save-dev pixelmatch' },
     { name: 'cheerio', install: 'npm install --save-dev cheerio' }
 ];
-const DEVTOOLS_SKILL_NAME = 'chrome-devtools';
 export function runDoctor(cwd = process.cwd()) {
     const dependencies = OPTIONAL_DEPENDENCIES.map((entry) => {
         const resolved = resolveOptionalDependency(entry.name, cwd);
@@ -26,20 +23,34 @@ export function runDoctor(cwd = process.cwd()) {
             install: entry.install
         };
     });
-    const codexHome = resolveCodexHome();
-    const skillPath = join(codexHome, 'skills', DEVTOOLS_SKILL_NAME, 'SKILL.md');
-    const skillInstalled = existsSync(skillPath);
+    const readiness = resolveDevtoolsReadiness();
+    const setupPlan = buildDevtoolsSetupPlan();
     const devtools = {
-        status: skillInstalled ? 'ok' : 'missing',
+        status: readiness.status,
         skill: {
             name: DEVTOOLS_SKILL_NAME,
-            status: skillInstalled ? 'ok' : 'missing',
-            path: skillPath,
-            install: skillInstalled
+            status: readiness.skill.status,
+            path: readiness.skill.path,
+            install: readiness.skill.status === 'ok'
                 ? undefined
                 : [
-                    `Copy the ${DEVTOOLS_SKILL_NAME} skill into ${join(codexHome, 'skills', DEVTOOLS_SKILL_NAME)}`,
-                    `Expected file: ${skillPath}`
+                    `Copy the ${DEVTOOLS_SKILL_NAME} skill into ${setupPlan.codexHome}/skills/${DEVTOOLS_SKILL_NAME}`,
+                    `Expected file: ${readiness.skill.path}`
+                ]
+        },
+        config: {
+            status: readiness.config.status,
+            path: readiness.config.path,
+            detail: readiness.config.detail,
+            error: readiness.config.error,
+            install: readiness.config.status === 'ok'
+                ? undefined
+                : [
+                    'Run: codex-orchestrator devtools setup',
+                    `Run: ${setupPlan.commandLine}`,
+                    `Config path: ${setupPlan.configPath}`,
+                    'Config snippet:',
+                    ...setupPlan.configSnippet.split('\n')
                 ]
         },
         enablement: [
@@ -48,9 +59,12 @@ export function runDoctor(cwd = process.cwd()) {
         ]
     };
     const missing = dependencies.filter((dep) => dep.status === 'missing').map((dep) => dep.name);
-    if (!skillInstalled) {
+    if (readiness.skill.status === 'missing') {
         missing.push(DEVTOOLS_SKILL_NAME);
     }
+    if (readiness.config.status !== 'ok') {
+        missing.push(`${DEVTOOLS_SKILL_NAME}-config`);
+    }
     return {
         status: missing.length === 0 ? 'ok' : 'warning',
         missing,
@@ -83,15 +97,26 @@ export function formatDoctorSummary(result) {
             lines.push(`    install: ${instruction}`);
         }
     }
+    if (result.devtools.config.status === 'ok') {
+        lines.push(`  - config.toml: ok (${result.devtools.config.path})`);
+    }
+    else {
+        const label = result.devtools.config.status === 'invalid'
+            ? `invalid (${result.devtools.config.path})`
+            : `missing (${result.devtools.config.path})`;
+        lines.push(`  - config.toml: ${label}`);
+        if (result.devtools.config.detail) {
+            lines.push(`    detail: ${result.devtools.config.detail}`);
+        }
+        if (result.devtools.config.error) {
+            lines.push(`    error: ${result.devtools.config.error}`);
+        }
+        for (const instruction of result.devtools.config.install ?? []) {
+            lines.push(`    install: ${instruction}`);
+        }
+    }
     for (const line of result.devtools.enablement) {
         lines.push(`  - ${line}`);
     }
     return lines;
 }
-function resolveCodexHome() {
-    const override = process.env.CODEX_HOME?.trim();
-    if (override) {
-        return override;
-    }
-    return join(homedir(), '.codex');
-}

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

@@ -1,7 +1,6 @@
 import process from 'node:process';
 import { bootstrapManifest } from '../run/manifest.js';
 import { generateRunId } from '../utils/runId.js';
-import { JsonlWriter } from '../utils/jsonlWriter.js';
 import { ExperienceStore } from '../../persistence/ExperienceStore.js';
 import { createTelemetrySink } from '../../../../packages/orchestrator/src/telemetry/otel-exporter.js';
 import { createNotificationSink } from '../../../../packages/orchestrator/src/notifications/index.js';
@@ -47,7 +46,11 @@ export async function bootstrapExecContext(context, invocation) {
             targets: invocation.notifyTargets,
             envTargets: envNotifications
         });
-    const jsonlWriter = outputMode === 'jsonl' ? new JsonlWriter(stdout) : null;
+    const jsonlWriter = outputMode === 'jsonl'
+        ? (event) => {
+            stdout.write(`${JSON.stringify(event)}\n`);
+        }
+        : null;
     return {
         env,
         invocation,

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

@@ -2,9 +2,6 @@ import process from 'node:process';
 import { persistManifest } from '../run/manifestPersister.js';
 import { isoTimestamp } from '../utils/time.js';
 import { logger } from '../../logger.js';
-import { runLearningHarvester } from '../../learning/harvester.js';
-import { synthesizeScenario } from '../../learning/runner.js';
-import { runScenarioValidation } from '../../learning/validator.js';
 export async function maybeTriggerLearning(runContext, runStatus) {
     const enabled = process.env.LEARNING_PIPELINE_ENABLED === '1';
     if (!enabled) {
@@ -15,6 +12,11 @@ export async function maybeTriggerLearning(runContext, runStatus) {
         return;
     }
     try {
+        const [{ runLearningHarvester }, { synthesizeScenario }, { runScenarioValidation }] = await Promise.all([
+            import('../../learning/harvester.js'),
+            import('../../learning/runner.js'),
+            import('../../learning/validator.js')
+        ]);
         const harvester = await runLearningHarvester(runContext.manifest, {
             repoRoot: runContext.env.repoRoot,
             runsRoot: runContext.env.runsRoot,

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

@@ -10,7 +10,7 @@ export async function runExecStage(context) {
             const serialized = serializeExecEvent(event);
             context.telemetryTasks.push(Promise.resolve(context.telemetrySink.record(serialized)).then(() => undefined));
             if (context.outputMode === 'jsonl' && context.jsonlWriter) {
-                context.jsonlWriter.write(serialized);
+                context.jsonlWriter(serialized);
             }
             else if (context.outputMode === 'interactive') {
                 streamInteractive(context.stdout, context.stderr, event);

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

@@ -61,7 +61,7 @@ export function createRunSummaryPayload(params) {
 }
 export function renderRunOutput(context, summaryPayload, summaryEvent) {
     if (context.outputMode === 'jsonl' && context.jsonlWriter) {
-        context.jsonlWriter.write(summaryEvent);
+        context.jsonlWriter(summaryEvent);
         return;
     }
     if (context.outputMode === 'json') {

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';
@@ -18,14 +21,15 @@ import { ControlPlaneService } from './services/controlPlaneService.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 { loadPackageConfig, loadUserConfig } from './config/userConfig.js';
 import { RunEventPublisher, snapshotStages } from './events/runEvents.js';
 import { CLI_EXECUTION_MODE_PARSER, resolveRequiresCloudPolicy } from '../utils/executionMode.js';
+const resolveBaseEnvironment = () => normalizeEnvironmentPaths(resolveEnvironmentPaths());
 export class CodexOrchestrator {
     baseEnv;
     controlPlane = new ControlPlaneService();
     scheduler = new SchedulerService();
-    constructor(baseEnv = resolveEnvironment()) {
+    constructor(baseEnv = resolveBaseEnvironment()) {
         this.baseEnv = baseEnv;
     }
     async start(options = {}) {
@@ -77,7 +81,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, {
@@ -196,11 +203,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 +217,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);
     }
@@ -445,7 +454,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 {};