@kbediako/codex-orchestrator 0.1.2 → 0.1.3

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 {};

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

@@ -0,0 +1,159 @@
+import { access, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const NODE_PACKAGE_MANAGER_MAP = {
+    pnpm: 'pnpm test',
+    yarn: 'yarn test',
+    npm: 'npm test',
+    bun: 'bun test'
+};
+const NODE_LOCKFILES = [
+    { file: 'pnpm-lock.yaml', command: 'pnpm test' },
+    { file: 'yarn.lock', command: 'yarn test' },
+    { file: 'package-lock.json', command: 'npm test' },
+    { file: 'bun.lockb', command: 'bun test' }
+];
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ecosystemReason(ecosystem, reason) {
+    return `${ecosystem}: ${reason}`;
+}
+async function detectNodeCandidates(repoRoot) {
+    const candidates = [];
+    const packageJsonPath = join(repoRoot, 'package.json');
+    if (await fileExists(packageJsonPath)) {
+        try {
+            const raw = await readFile(packageJsonPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            const packageManager = parsed.packageManager?.trim();
+            if (packageManager) {
+                const tool = packageManager.split('@')[0]?.trim();
+                const command = tool ? NODE_PACKAGE_MANAGER_MAP[tool] : undefined;
+                if (command) {
+                    candidates.push({
+                        command,
+                        reason: ecosystemReason('node', `packageManager=${packageManager}`),
+                        ecosystem: 'node'
+                    });
+                }
+            }
+        }
+        catch {
+            // Ignore invalid package.json for auto-detection.
+        }
+    }
+    for (const lockfile of NODE_LOCKFILES) {
+        const lockPath = join(repoRoot, lockfile.file);
+        if (await fileExists(lockPath)) {
+            candidates.push({
+                command: lockfile.command,
+                reason: ecosystemReason('node', lockfile.file),
+                ecosystem: 'node'
+            });
+        }
+    }
+    return candidates;
+}
+async function detectPythonCandidates(repoRoot) {
+    const candidates = [];
+    const pyprojectPath = join(repoRoot, 'pyproject.toml');
+    if (await fileExists(pyprojectPath)) {
+        candidates.push({
+            command: 'python -m pytest',
+            reason: ecosystemReason('python', 'pyproject.toml'),
+            ecosystem: 'python'
+        });
+    }
+    const pytestIni = join(repoRoot, 'pytest.ini');
+    if (await fileExists(pytestIni)) {
+        candidates.push({
+            command: 'pytest',
+            reason: ecosystemReason('python', 'pytest.ini'),
+            ecosystem: 'python'
+        });
+    }
+    const requirements = join(repoRoot, 'requirements.txt');
+    if (await fileExists(requirements)) {
+        candidates.push({
+            command: 'pytest',
+            reason: ecosystemReason('python', 'requirements.txt'),
+            ecosystem: 'python'
+        });
+    }
+    return candidates;
+}
+async function detectGoCandidates(repoRoot) {
+    const goModPath = join(repoRoot, 'go.mod');
+    if (await fileExists(goModPath)) {
+        return [
+            {
+                command: 'go test ./...',
+                reason: ecosystemReason('go', 'go.mod'),
+                ecosystem: 'go'
+            }
+        ];
+    }
+    return [];
+}
+async function detectRustCandidates(repoRoot) {
+    const cargoPath = join(repoRoot, 'Cargo.toml');
+    if (await fileExists(cargoPath)) {
+        return [
+            {
+                command: 'cargo test',
+                reason: ecosystemReason('rust', 'Cargo.toml'),
+                ecosystem: 'rust'
+            }
+        ];
+    }
+    return [];
+}
+export async function detectValidatorCandidates(repoRoot) {
+    const [node, python, go, rust] = await Promise.all([
+        detectNodeCandidates(repoRoot),
+        detectPythonCandidates(repoRoot),
+        detectGoCandidates(repoRoot),
+        detectRustCandidates(repoRoot)
+    ]);
+    return [...node, ...python, ...go, ...rust];
+}
+export async function detectValidator(repoRoot) {
+    const rawCandidates = await detectValidatorCandidates(repoRoot);
+    if (rawCandidates.length === 0) {
+        return { status: 'missing', command: null, candidates: [] };
+    }
+    const grouped = new Map();
+    for (const candidate of rawCandidates) {
+        const entry = grouped.get(candidate.command);
+        if (entry) {
+            entry.reasons.push(candidate.reason);
+        }
+        else {
+            grouped.set(candidate.command, {
+                command: candidate.command,
+                reasons: [candidate.reason],
+                ecosystem: candidate.ecosystem
+            });
+        }
+    }
+    const candidates = Array.from(grouped.values()).map((entry) => ({
+        command: entry.command,
+        reason: entry.reasons.join('; '),
+        ecosystem: entry.ecosystem
+    }));
+    if (candidates.length === 1) {
+        return {
+            status: 'selected',
+            command: candidates[0]?.command ?? null,
+            reason: candidates[0]?.reason,
+            candidates
+        };
+    }
+    return { status: 'ambiguous', command: null, candidates };
+}