@kbediako/codex-orchestrator 0.1.12 → 0.1.14-alpha.1

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

@@ -274,8 +274,8 @@ async function runCodexAgent(input, env, repoRoot, nonInteractive, subagentsEnab
     const output = await runCodexCompletion(prompt, env, repoRoot, nonInteractive, subagentsEnabled, true);
     return { output };
 }
-async function runCodexCompletion(prompt, env, repoRoot, nonInteractive, subagentsEnabled, mirrorOutput) {
-    const { command, args } = resolveCodexCommand(['exec', prompt], env);
+async function runCodexExec(args, env, repoRoot, nonInteractive, subagentsEnabled, mirrorOutput) {
+    const { command, args: resolvedArgs } = resolveCodexCommand(args, env);
     const childEnv = { ...process.env, ...env };
     if (nonInteractive) {
         childEnv.CODEX_NON_INTERACTIVE = childEnv.CODEX_NON_INTERACTIVE ?? '1';
@@ -283,7 +283,7 @@ async function runCodexCompletion(prompt, env, repoRoot, nonInteractive, subagen
         childEnv.CODEX_INTERACTIVE = childEnv.CODEX_INTERACTIVE ?? '0';
     }
     childEnv.CODEX_SUBAGENTS = subagentsEnabled ? '1' : '0';
-    const child = spawn(command, args, { cwd: repoRoot, env: childEnv, stdio: ['ignore', 'pipe', 'pipe'] });
+    const child = spawn(command, resolvedArgs, { cwd: repoRoot, env: childEnv, stdio: ['ignore', 'pipe', 'pipe'] });
     let stdout = '';
     let stderr = '';
     child.stdout?.on('data', (chunk) => {
@@ -311,8 +311,52 @@ async function runCodexCompletion(prompt, env, repoRoot, nonInteractive, subagen
             }
         });
     });
+    return { stdout, stderr };
+}
+async function runCodexCompletion(prompt, env, repoRoot, nonInteractive, subagentsEnabled, mirrorOutput) {
+    const { stdout, stderr } = await runCodexExec(['exec', prompt], env, repoRoot, nonInteractive, subagentsEnabled, mirrorOutput);
+    return [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
+}
+async function runCodexJsonlCompletion(prompt, env, repoRoot, nonInteractive, mirrorOutput, extraArgs = []) {
+    const { stdout, stderr } = await runCodexExec(['exec', '--json', ...extraArgs, prompt], env, repoRoot, nonInteractive, false, mirrorOutput);
+    const message = extractAgentMessageFromJsonl(stdout);
+    if (message) {
+        return message;
+    }
     return [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
 }
+function extractAgentMessageFromJsonl(raw) {
+    let lastMessage = null;
+    const lines = raw.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{')) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if ((parsed.type === 'item.completed' || parsed.type === 'item.updated') &&
+                parsed.item?.type === 'agent_message' &&
+                typeof parsed.item.text === 'string') {
+                lastMessage = parsed.item.text;
+            }
+        }
+        catch {
+            // ignore parse errors for non-json lines
+        }
+    }
+    return lastMessage;
+}
+function buildCollabSubcallPrompt(prompt) {
+    return [
+        'Use collab tools to spawn a sub-agent with the prompt below.',
+        'Wait for the sub-agent, then close it.',
+        'Return only the sub-agent response text and nothing else.',
+        '',
+        'Sub-agent prompt:',
+        prompt
+    ].join('\n');
+}
 function normalizeExitCode(code) {
     if (typeof code === 'number' && Number.isInteger(code)) {
         return code;
@@ -571,6 +615,7 @@ async function main() {
         console.log(`Validator: ${validatorCommand}`);
     }
     const subagentsEnabled = envFlagEnabled(env.CODEX_SUBAGENTS) || envFlagEnabled(env.RLM_SUBAGENTS);
+    const symbolicCollabEnabled = envFlagEnabled(env.RLM_SYMBOLIC_COLLAB);
     const nonInteractive = shouldForceNonInteractive(env);
     if (mode === 'symbolic') {
         const budgets = {
@@ -622,11 +667,20 @@ async function main() {
             budgets,
             runPlanner: (prompt, _attempt) => {
                 void _attempt;
-                return runCodexCompletion(prompt, env, repoRoot, nonInteractive, false, false);
+                return runCodexJsonlCompletion(prompt, env, repoRoot, nonInteractive, false);
             },
             runSubcall: (prompt, _meta) => {
                 void _meta;
-                return runCodexCompletion(prompt, env, repoRoot, nonInteractive, false, false);
+                if (!symbolicCollabEnabled) {
+                    return runCodexCompletion(prompt, env, repoRoot, nonInteractive, false, false);
+                }
+                const collabPrompt = buildCollabSubcallPrompt(prompt);
+                return runCodexJsonlCompletion(collabPrompt, env, repoRoot, nonInteractive, true, [
+                    '--enable',
+                    'collab',
+                    '--sandbox',
+                    'read-only'
+                ]);
             },
             logger: (line) => logger.info(line)
         });

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

@@ -47,6 +47,7 @@ export async function bootstrapManifest(runId, options) {
         resume_events: [],
         approvals: [],
         commands,
+        collab_tool_calls: [],
         child_runs: [],
         run_summary_path: null,
         plan_target_id: options.planTargetId ?? null,
@@ -54,6 +55,7 @@ export async function bootstrapManifest(runId, options) {
         instructions_sources: [],
         prompt_packs: [],
         guardrails_required: pipeline.guardrailsRequired !== false,
+        cloud_execution: null,
         learning: {
             validation: {
                 mode: 'per-task',
@@ -169,6 +171,7 @@ export function resetForResume(manifest) {
     manifest.status = 'in_progress';
     manifest.status_detail = 'resuming';
     manifest.guardrail_status = undefined;
+    manifest.cloud_execution = null;
 }
 export function recordResumeEvent(manifest, event) {
     manifest.resume_events.push({ ...event, timestamp: isoTimestamp() });

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

@@ -13,6 +13,7 @@ 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);
 export const MAX_CAPTURED_CHUNK_EVENTS = EnvUtils.getInt('CODEX_ORCHESTRATOR_EXEC_EVENT_MAX_CHUNKS', 500);
+const MAX_COLLAB_TOOL_CALLS = EnvUtils.getInt('CODEX_ORCHESTRATOR_COLLAB_MAX_EVENTS', 200);
 const PACKAGE_ROOT = findPackageRoot();
 export async function runCommandStage(context, hooks = {}) {
     const { env, paths, manifest, stage, index, events, persister, envOverrides } = context;
@@ -50,6 +51,33 @@ export async function runCommandStage(context, hooks = {}) {
     let stderrBytes = 0;
     let stdoutTruncated = false;
     let stderrTruncated = false;
+    let collabBuffer = '';
+    let collabCount = manifest.collab_tool_calls?.length ?? 0;
+    const recordCollabToolCall = (record) => {
+        if (MAX_COLLAB_TOOL_CALLS <= 0) {
+            return;
+        }
+        if (collabCount >= MAX_COLLAB_TOOL_CALLS) {
+            return;
+        }
+        if (!manifest.collab_tool_calls) {
+            manifest.collab_tool_calls = [];
+        }
+        manifest.collab_tool_calls.push(record);
+        collabCount += 1;
+        void persister?.schedule({ manifest: true });
+    };
+    const ingestCollabStdout = (data) => {
+        collabBuffer += data;
+        const lines = collabBuffer.split('\n');
+        collabBuffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const record = parseCollabToolCallLine(line, stage.id, entry.index);
+            if (record) {
+                recordCollabToolCall(record);
+            }
+        }
+    };
     const handleEvent = (event) => {
         if (!activeCorrelationId) {
             activeCorrelationId = event.correlationId;
@@ -87,6 +115,9 @@ export async function runCommandStage(context, hooks = {}) {
                     message: event.payload.data,
                     source: event.payload.stream
                 });
+                if (event.payload.stream === 'stdout') {
+                    ingestCollabStdout(event.payload.data);
+                }
                 break;
             case 'exec:retry':
                 events?.toolCall({
@@ -192,6 +223,13 @@ export async function runCommandStage(context, hooks = {}) {
         entry.exit_code = normalizedExitCode;
         entry.summary = summary;
         entry.status = result.status === 'succeeded' ? 'succeeded' : stage.allowFailure ? 'skipped' : 'failed';
+        if (collabBuffer.trim()) {
+            const record = parseCollabToolCallLine(collabBuffer, stage.id, entry.index);
+            if (record) {
+                recordCollabToolCall(record);
+            }
+            collabBuffer = '';
+        }
         if (entry.status === 'failed') {
             const errorDetails = {
                 exit_code: normalizedExitCode,
@@ -418,3 +456,52 @@ function truncate(value, length = 240) {
     }
     return `${value.slice(0, length)}…`;
 }
+function parseCollabToolCallLine(line, stageId, commandIndex) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.includes('"collab_tool_call"')) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return null;
+    }
+    const record = parsed;
+    const eventType = record.type;
+    if (eventType !== 'item.started' && eventType !== 'item.completed' && eventType !== 'item.updated') {
+        return null;
+    }
+    const item = record.item;
+    if (!item || item.type !== 'collab_tool_call') {
+        return null;
+    }
+    const receiverThreadIds = Array.isArray(item.receiver_thread_ids)
+        ? item.receiver_thread_ids.filter((entry) => typeof entry === 'string')
+        : [];
+    return {
+        observed_at: isoTimestamp(),
+        stage_id: stageId,
+        command_index: commandIndex,
+        event_type: eventType,
+        item_id: typeof item.id === 'string' ? item.id : 'unknown',
+        tool: typeof item.tool === 'string' ? item.tool : 'unknown',
+        status: normalizeCollabStatus(item.status),
+        sender_thread_id: typeof item.sender_thread_id === 'string' ? item.sender_thread_id : 'unknown',
+        receiver_thread_ids: receiverThreadIds,
+        prompt: typeof item.prompt === 'string' ? item.prompt : null,
+        agents_states: item.agents_states && typeof item.agents_states === 'object'
+            ? item.agents_states
+            : null
+    };
+}
+function normalizeCollabStatus(value) {
+    if (value === 'completed' || value === 'failed' || value === 'in_progress') {
+        return value;
+    }
+    return 'in_progress';
+}

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

@@ -27,6 +27,30 @@ export function applyPrivacyToRunSummary(runSummary, manifest) {
         allowedFrames: manifest.privacy.totals.allowed_frames
     };
 }
+export function applyCloudExecutionToRunSummary(runSummary, manifest) {
+    if (!manifest.cloud_execution) {
+        return;
+    }
+    runSummary.cloudExecution = {
+        taskId: manifest.cloud_execution.task_id,
+        environmentId: manifest.cloud_execution.environment_id,
+        status: manifest.cloud_execution.status,
+        statusUrl: manifest.cloud_execution.status_url,
+        submittedAt: manifest.cloud_execution.submitted_at,
+        completedAt: manifest.cloud_execution.completed_at,
+        lastPolledAt: manifest.cloud_execution.last_polled_at,
+        pollCount: manifest.cloud_execution.poll_count,
+        pollIntervalSeconds: manifest.cloud_execution.poll_interval_seconds,
+        timeoutSeconds: manifest.cloud_execution.timeout_seconds,
+        attempts: manifest.cloud_execution.attempts,
+        diffPath: manifest.cloud_execution.diff_path,
+        diffUrl: manifest.cloud_execution.diff_url,
+        diffStatus: manifest.cloud_execution.diff_status,
+        applyStatus: manifest.cloud_execution.apply_status,
+        logPath: manifest.cloud_execution.log_path,
+        error: manifest.cloud_execution.error
+    };
+}
 export async function persistRunSummary(env, paths, manifest, runSummary, persister) {
     const summaryPath = join(paths.runDir, 'run-summary.json');
     await writeJsonAtomic(summaryPath, runSummary);

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

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs';
 import { copyFile, mkdir, readdir, stat } from 'node:fs/promises';
 import { dirname, join, relative, resolve } from 'node:path';
 import process from 'node:process';
-import { resolveCodexHome } from './utils/devtools.js';
+import { resolveCodexHome } from './utils/codexPaths.js';
 import { findPackageRoot } from './utils/packageInfo.js';
 export async function installSkills(options = {}) {
     const pkgRoot = findPackageRoot();

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

@@ -0,0 +1,94 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+import { resolveCodexOrchestratorHome } from './codexPaths.js';
+const CONFIG_FILENAME = 'codex-cli.json';
+export function resolveCodexCliRoot(env = process.env) {
+    return join(resolveCodexOrchestratorHome(env), 'codex-cli');
+}
+export function resolveCodexCliConfigPath(env = process.env) {
+    return join(resolveCodexCliRoot(env), CONFIG_FILENAME);
+}
+export function resolveCodexCliBinPath(env = process.env) {
+    return join(resolveCodexCliRoot(env), 'bin', codexBinaryName());
+}
+export function resolveCodexCliBin(env = process.env) {
+    const override = env.CODEX_CLI_BIN?.trim();
+    if (override) {
+        return override;
+    }
+    const { config } = readCodexCliConfig(env);
+    if (config?.binary_path) {
+        return config.binary_path;
+    }
+    return 'codex';
+}
+export function resolveCodexCliReadiness(env = process.env) {
+    const configPath = resolveCodexCliConfigPath(env);
+    if (!existsSync(configPath)) {
+        return {
+            status: 'missing',
+            config: { status: 'missing', path: configPath },
+            binary: { status: 'missing', path: resolveCodexCliBinPath(env) }
+        };
+    }
+    const { config, error } = readCodexCliConfig(env);
+    if (error || !config) {
+        return {
+            status: 'invalid',
+            config: { status: 'invalid', path: configPath, error: error ?? 'Invalid config JSON.' },
+            binary: { status: 'missing', path: resolveCodexCliBinPath(env) }
+        };
+    }
+    const binaryPath = config.binary_path;
+    const binaryExists = binaryPath ? existsSync(binaryPath) : false;
+    const binaryStatus = binaryExists ? 'ok' : 'missing';
+    if (binaryExists && config.sha256) {
+        const actualSha256 = sha256FileSync(binaryPath);
+        if (actualSha256 !== config.sha256) {
+            return {
+                status: 'invalid',
+                config: {
+                    status: 'invalid',
+                    path: configPath,
+                    error: `codex-cli sha256 mismatch (expected ${config.sha256}, got ${actualSha256})`
+                },
+                binary: { status: binaryStatus, path: binaryPath },
+                install: config
+            };
+        }
+    }
+    const status = binaryStatus === 'ok' ? 'ok' : 'missing';
+    return {
+        status,
+        config: { status: 'ok', path: configPath },
+        binary: { status: binaryStatus, path: binaryPath },
+        install: config
+    };
+}
+export function readCodexCliConfig(env = process.env) {
+    const configPath = resolveCodexCliConfigPath(env);
+    if (!existsSync(configPath)) {
+        return { config: null };
+    }
+    try {
+        const raw = readFileSync(configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed.binary_path !== 'string') {
+            return { config: null, error: 'codex-cli.json missing binary_path.' };
+        }
+        return { config: parsed };
+    }
+    catch (error) {
+        return { config: null, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function codexBinaryName() {
+    return process.platform === 'win32' ? 'codex.exe' : 'codex';
+}
+function sha256FileSync(path) {
+    const hash = createHash('sha256');
+    hash.update(readFileSync(path));
+    return hash.digest('hex');
+}

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

@@ -0,0 +1,13 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import process from 'node:process';
+export function resolveCodexHome(env = process.env) {
+    const override = env.CODEX_HOME?.trim();
+    if (override) {
+        return override;
+    }
+    return join(homedir(), '.codex');
+}
+export function resolveCodexOrchestratorHome(env = process.env) {
+    return join(resolveCodexHome(env), 'orchestrator');
+}

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

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import process from 'node:process';
 import { EnvUtils } from '../../../../packages/shared/config/env.js';
+import { resolveCodexCliBin } from './codexCli.js';
+import { resolveCodexHome } from './codexPaths.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'];
@@ -32,13 +33,6 @@ export function isDevtoolsEnabled(env = process.env) {
     }
     return EnvUtils.isTrue(raw.trim().toLowerCase());
 }
-export function resolveCodexHome(env = process.env) {
-    const override = env.CODEX_HOME?.trim();
-    if (override) {
-        return override;
-    }
-    return join(homedir(), '.codex');
-}
 export function resolveCodexConfigPath(env = process.env) {
     return join(resolveCodexHome(env), DEVTOOLS_CONFIG_FILENAME);
 }
@@ -76,28 +70,31 @@ export function resolveDevtoolsReadiness(env = process.env) {
 export function buildDevtoolsSetupPlan(env = process.env) {
     const codexHome = resolveCodexHome(env);
     const configPath = resolveCodexConfigPath(env);
+    const command = resolveCodexCliBin(env);
     const args = [...DEVTOOLS_MCP_COMMAND];
     return {
         codexHome,
         configPath,
-        command: 'codex',
+        command,
         args,
-        commandLine: ['codex', ...args].join(' '),
+        commandLine: [command, ...args].join(' '),
         configSnippet: DEVTOOLS_CONFIG_SNIPPET
     };
 }
 export function resolveCodexCommand(args, env = process.env) {
     const overrides = parseConfigOverrides(env);
     if (!isDevtoolsEnabled(env)) {
-        return { command: 'codex', args: applyConfigOverrides(overrides, args) };
+        const command = resolveCodexCliBin(env);
+        return { command, args: applyConfigOverrides(overrides, args) };
     }
     const readiness = resolveDevtoolsReadiness(env);
     if (readiness.status !== 'ok') {
         throw new Error(formatDevtoolsPreflightError(readiness));
     }
     const mergedOverrides = dedupeOverrides([DEVTOOLS_CONFIG_OVERRIDE, ...overrides]);
+    const command = resolveCodexCliBin(env);
     return {
-        command: 'codex',
+        command,
         args: applyConfigOverrides(mergedOverrides, args)
     };
 }