@kbediako/codex-orchestrator 0.1.37 → 0.2.0

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

@@ -1,5 +1,4 @@
 import { exec } from 'node:child_process';
-import { spawn } from 'node:child_process';
 import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { join, relative, resolve } from 'node:path';
 import process from 'node:process';
@@ -7,12 +6,15 @@ import { promisify } from 'node:util';
 import { createInterface } from 'node:readline/promises';
 import { fileURLToPath } from 'node:url';
 import { logger } from '../logger.js';
-import { createRuntimeCodexCommandContext, formatRuntimeSelectionSummary, parseRuntimeMode, resolveRuntimeCodexCommand } from './runtime/index.js';
 import { detectValidator } from './rlm/validator.js';
 import { buildRlmPrompt } from './rlm/prompt.js';
 import { runRlmLoop } from './rlm/runner.js';
 import { buildContextObject, ContextStore } from './rlm/context.js';
+import { hasRunSource0Artifacts, readRunSource0Descriptor, resolveRunSource0Paths } from './run/source0.js';
+import { buildRunMemoryPromptLines, selectRunMemoryForRole } from './run/runMemoryController.js';
 import { runSymbolicLoop } from './rlm/symbolic.js';
+import { COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL, COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY, COLLAB_FEATURE_LEGACY, COLLAB_ROLE_POLICY_ENV_CANONICAL, COLLAB_ROLE_POLICY_ENV_LEGACY, createRlmCodexRuntimeShell, resolveCollabAllowDefaultRoleConfig, resolveCollabRolePolicyConfig } from './rlm/rlmCodexRuntimeShell.js';
+import { DEFAULT_ALIGNMENT_POLICY } from './rlm/alignment.js';
 const execAsync = promisify(exec);
 const DEFAULT_MAX_ITERATIONS = 88;
 const DEFAULT_MAX_MINUTES = 48 * 60;
@@ -43,22 +45,11 @@ const DEFAULT_ALIGNMENT_COOLDOWN_TURNS = 2;
 const DEFAULT_ALIGNMENT_CONSENSUS_TOP_SCORE_MIN = 0.7;
 const DEFAULT_ALIGNMENT_CONSENSUS_MARGIN_MIN = 0.15;
 const DEFAULT_ALIGNMENT_CONSENSUS_REQUIRED_VOTES = 2;
-const DEFAULT_ALIGNMENT_SENTINEL_MODEL = 'gpt-5.3-spark';
-const DEFAULT_ALIGNMENT_HIGH_REASONING_MODEL = 'gpt-5.3-codex';
-const DEFAULT_ALIGNMENT_ARBITRATION_MODEL = 'gpt-5.3-codex';
-const DEFAULT_ALIGNMENT_HIGH_REASONING_AVAILABLE = true;
-const DEFAULT_COLLAB_ROLE_POLICY = 'enforce';
-const COLLAB_ROLE_POLICY_ENV_CANONICAL = 'RLM_SYMBOLIC_MULTI_AGENT_ROLE_POLICY';
-const COLLAB_ROLE_POLICY_ENV_LEGACY = 'RLM_COLLAB_ROLE_POLICY';
-const COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL = 'RLM_SYMBOLIC_MULTI_AGENT_ALLOW_DEFAULT_ROLE';
-const COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY = 'RLM_COLLAB_ALLOW_DEFAULT_ROLE';
+const DEFAULT_ALIGNMENT_SENTINEL_MODEL = DEFAULT_ALIGNMENT_POLICY.route.sentinel_model;
+const DEFAULT_ALIGNMENT_HIGH_REASONING_MODEL = DEFAULT_ALIGNMENT_POLICY.route.high_reasoning_model;
+const DEFAULT_ALIGNMENT_ARBITRATION_MODEL = DEFAULT_ALIGNMENT_POLICY.route.arbitration_model;
+const DEFAULT_ALIGNMENT_HIGH_REASONING_AVAILABLE = DEFAULT_ALIGNMENT_POLICY.route.high_reasoning_available;
 const UNBOUNDED_ITERATION_ALIASES = new Set(['unbounded', 'unlimited', 'infinite', 'infinity']);
-const COLLAB_FEATURE_CANONICAL = 'multi_agent';
-const COLLAB_FEATURE_LEGACY = 'collab';
-const COLLAB_ROLE_TAG_PATTERN = /^\s*\[(?:agent_type|role)\s*:\s*([a-z0-9._-]+)\]/i;
-const COLLAB_ROLE_TOKEN_PATTERN = /^[a-z0-9._-]+$/;
-let runtimeCodexContextPromise = null;
-let runtimeCodexContextLogged = false;
 function parseArgs(argv) {
     const parsed = {};
     for (let i = 0; i < argv.length; i += 1) {
@@ -259,7 +250,7 @@ function resolveRlmMode(rawMode, options) {
     }
     return 'iterative';
 }
-async function resolveContextSource(env, fallbackText) {
+async function resolveContextSource(env, repoRoot, fallbackText) {
     const rawPath = env.RLM_CONTEXT_PATH?.trim();
     if (rawPath) {
         const resolvedPath = resolve(rawPath);
@@ -274,20 +265,61 @@ async function resolveContextSource(env, fallbackText) {
                 : (await stat(sourcePath)).size;
             return {
                 source: { type: 'dir', value: resolvedPath },
-                bytes: byteLength
+                bytes: byteLength,
+                explicit: true
             };
         }
         if (info.isFile()) {
-            return { source: { type: 'file', value: resolvedPath }, bytes: info.size };
+            return { source: { type: 'file', value: resolvedPath }, bytes: info.size, explicit: true };
         }
         throw new Error('context_source invalid');
     }
+    const manifestPath = env.CODEX_ORCHESTRATOR_MANIFEST_PATH?.trim();
+    if (manifestPath) {
+        const rawManifestPath = resolve(repoRoot, manifestPath);
+        const rawManifest = JSON.parse(await readFile(rawManifestPath, 'utf8'));
+        const descriptor = readRunSource0Descriptor(rawManifest);
+        if (descriptor && (await hasRunSource0Artifacts(repoRoot, descriptor))) {
+            return {
+                source: { type: 'dir', value: resolveRunSource0Paths(repoRoot, descriptor).dirPath },
+                bytes: descriptor.byte_length,
+                explicit: true
+            };
+        }
+    }
     const text = fallbackText ?? '';
     return {
         source: { type: 'text', value: text },
-        bytes: Buffer.byteLength(text, 'utf8')
+        bytes: Buffer.byteLength(text, 'utf8'),
+        explicit: false
     };
 }
+async function resolvePlannerRunMemoryPromptLines(env, repoRoot, goal) {
+    const manifestPath = env.CODEX_ORCHESTRATOR_MANIFEST_PATH?.trim();
+    if (!manifestPath) {
+        return [];
+    }
+    try {
+        const rawManifestPath = resolve(repoRoot, manifestPath);
+        const rawManifest = JSON.parse(await readFile(rawManifestPath, 'utf8'));
+        const source0Descriptor = readRunSource0Descriptor(rawManifest);
+        const includeSource0 = !source0Descriptor || (await hasRunSource0Artifacts(repoRoot, source0Descriptor));
+        const selection = selectRunMemoryForRole({
+            role: 'planner',
+            manifest: rawManifest,
+            hints: [goal]
+        });
+        return buildRunMemoryPromptLines(includeSource0
+            ? selection
+            : {
+                ...selection,
+                refs: selection.refs.filter((ref) => ref.kind !== 'source_0')
+            });
+    }
+    catch {
+        return [];
+    }
+}
 async function promptForValidator(candidates) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     try {
@@ -328,471 +360,14 @@ async function writeTerminalState(runDir, state) {
     await mkdir(rlmDir, { recursive: true });
     await writeFile(join(rlmDir, 'state.json'), JSON.stringify(state, null, 2), 'utf8');
 }
-async function runCodexAgent(input, env, repoRoot, nonInteractive, subagentsEnabled) {
+async function runCodexAgent(input, codexRuntimeShell, nonInteractive, subagentsEnabled) {
     const prompt = buildRlmPrompt(input);
-    const output = await runCodexCompletion(prompt, env, repoRoot, nonInteractive, subagentsEnabled, true);
-    return { output };
-}
-async function runCodexExec(args, env, repoRoot, nonInteractive, subagentsEnabled, mirrorOutput) {
-    const runtimeContext = await resolveRlmRuntimeCodexContext(env, repoRoot);
-    const { command, args: resolvedArgs } = resolveRuntimeCodexCommand(args, runtimeContext);
-    const childEnv = { ...process.env, ...env, ...runtimeContext.env };
-    if (nonInteractive) {
-        childEnv.CODEX_NON_INTERACTIVE = childEnv.CODEX_NON_INTERACTIVE ?? '1';
-        childEnv.CODEX_NO_INTERACTIVE = childEnv.CODEX_NO_INTERACTIVE ?? '1';
-        childEnv.CODEX_INTERACTIVE = childEnv.CODEX_INTERACTIVE ?? '0';
-    }
-    childEnv.CODEX_SUBAGENTS = subagentsEnabled ? '1' : '0';
-    const child = spawn(command, resolvedArgs, { cwd: repoRoot, env: childEnv, stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-    child.stdout?.on('data', (chunk) => {
-        const text = chunk.toString();
-        stdout += text;
-        if (mirrorOutput) {
-            process.stdout.write(chunk);
-        }
-    });
-    child.stderr?.on('data', (chunk) => {
-        const text = chunk.toString();
-        stderr += text;
-        if (mirrorOutput) {
-            process.stderr.write(chunk);
-        }
-    });
-    await new Promise((resolvePromise, reject) => {
-        child.once('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
-        child.once('exit', (code) => {
-            if (code === 0) {
-                resolvePromise();
-            }
-            else {
-                reject(new Error(`codex exec exited with code ${code ?? 'unknown'}`));
-            }
-        });
+    const output = await codexRuntimeShell.runCompletion(prompt, {
+        nonInteractive,
+        subagentsEnabled,
+        mirrorOutput: true
     });
-    return { stdout, stderr };
-}
-async function resolveRlmRuntimeCodexContext(env, repoRoot) {
-    if (!runtimeCodexContextPromise) {
-        const requestedMode = parseRuntimeMode(env.CODEX_ORCHESTRATOR_RUNTIME_MODE_ACTIVE ?? env.CODEX_ORCHESTRATOR_RUNTIME_MODE ?? null);
-        const runId = typeof env.CODEX_ORCHESTRATOR_RUN_ID === 'string' && env.CODEX_ORCHESTRATOR_RUN_ID.trim().length > 0
-            ? env.CODEX_ORCHESTRATOR_RUN_ID.trim()
-            : `rlm-${Date.now()}`;
-        runtimeCodexContextPromise = createRuntimeCodexCommandContext({
-            requestedMode,
-            executionMode: 'mcp',
-            repoRoot,
-            env: { ...process.env, ...env },
-            runId
-        });
-    }
-    const runtimeContext = await runtimeCodexContextPromise;
-    if (!runtimeCodexContextLogged) {
-        logger.info(`[rlm-runtime] ${formatRuntimeSelectionSummary(runtimeContext.runtime)}`);
-        runtimeCodexContextLogged = true;
-    }
-    return runtimeContext;
-}
-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 = [], options = {}) {
-    const { stdout, stderr } = await runCodexExec(['exec', '--json', ...extraArgs, prompt], env, repoRoot, nonInteractive, false, mirrorOutput);
-    if (options.validateCollabLifecycle) {
-        const rolePolicy = options.collabRolePolicy ?? DEFAULT_COLLAB_ROLE_POLICY;
-        const validation = validateCollabLifecycle(stdout, {
-            requireSpawnRole: rolePolicy !== 'off',
-            allowDefaultRole: options.collabAllowDefaultRole ?? false
-        });
-        if (!validation.ok) {
-            const rolePolicyFailure = isRolePolicyValidationReason(validation.reasonCode);
-            if (rolePolicy === 'warn' && rolePolicyFailure) {
-                logger.warn(`Collab lifecycle validation warning: ${validation.reason}`);
-            }
-            else {
-                throw new Error(`Collab lifecycle validation failed: ${validation.reason}`);
-            }
-        }
-    }
-    const message = extractAgentMessageFromJsonl(stdout);
-    if (message) {
-        return message;
-    }
-    return [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
-}
-function parseFeatureFlagsFromText(raw) {
-    const flags = {};
-    for (const line of raw.split(/\r?\n/u)) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            continue;
-        }
-        const tokens = trimmed.split(/\s+/u);
-        if (tokens.length < 2) {
-            continue;
-        }
-        const name = tokens[0] ?? '';
-        const enabledToken = tokens[tokens.length - 1] ?? '';
-        if (!name) {
-            continue;
-        }
-        if (enabledToken === 'true') {
-            flags[name] = true;
-        }
-        else if (enabledToken === 'false') {
-            flags[name] = false;
-        }
-    }
-    return flags;
-}
-function resolveCollabFeatureKeyFromFlags(flags) {
-    if (Object.prototype.hasOwnProperty.call(flags, COLLAB_FEATURE_CANONICAL)) {
-        return COLLAB_FEATURE_CANONICAL;
-    }
-    if (Object.prototype.hasOwnProperty.call(flags, COLLAB_FEATURE_LEGACY)) {
-        return COLLAB_FEATURE_LEGACY;
-    }
-    return COLLAB_FEATURE_LEGACY;
-}
-async function resolveCollabFeatureKey(env, repoRoot, nonInteractive) {
-    try {
-        const { stdout } = await runCodexExec(['features', 'list'], env, repoRoot, nonInteractive, false, false);
-        return resolveCollabFeatureKeyFromFlags(parseFeatureFlagsFromText(stdout));
-    }
-    catch (error) {
-        logger.debug(`Unable to resolve Codex collab feature key via \`codex features list\`: ${error instanceof Error ? error.message : String(error)}`);
-        return COLLAB_FEATURE_LEGACY;
-    }
-}
-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 normalizeCollabStatus(value) {
-    if (value === 'in_progress' || value === 'completed' || value === 'failed') {
-        return value;
-    }
-    return 'unknown';
-}
-function parseCollabToolCallsFromJsonl(raw) {
-    const lines = raw.split(/\r?\n/);
-    const calls = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index]?.trim();
-        if (!line || !line.startsWith('{') || !line.includes('"collab_tool_call"')) {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(line);
-            if ((parsed.type !== 'item.started' && parsed.type !== 'item.updated' && parsed.type !== 'item.completed') ||
-                parsed.item?.type !== 'collab_tool_call' ||
-                typeof parsed.item.tool !== 'string') {
-                continue;
-            }
-            const receiverThreadIds = Array.isArray(parsed.item.receiver_thread_ids)
-                ? parsed.item.receiver_thread_ids.filter((entry) => typeof entry === 'string')
-                : [];
-            const prompt = typeof parsed.item.prompt === 'string' ? parsed.item.prompt : null;
-            calls.push({
-                sequence: index,
-                eventType: parsed.type,
-                tool: parsed.item.tool,
-                status: normalizeCollabStatus(parsed.item.status),
-                receiverThreadIds,
-                prompt,
-                agentType: normalizeCollabRoleToken(parsed.item.agent_type),
-                promptRole: resolveCollabRoleFromPrompt(prompt)
-            });
-        }
-        catch {
-            continue;
-        }
-    }
-    return calls;
-}
-function formatLifecycleIds(ids) {
-    return ids.slice(0, 3).join(', ');
-}
-function normalizeCollabRoleToken(value) {
-    if (typeof value !== 'string') {
-        return null;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (!normalized || !COLLAB_ROLE_TOKEN_PATTERN.test(normalized)) {
-        return null;
-    }
-    return normalized;
-}
-function resolveCollabRoleFromPrompt(value) {
-    if (typeof value !== 'string') {
-        return null;
-    }
-    const match = value.match(COLLAB_ROLE_TAG_PATTERN);
-    if (!match || typeof match[1] !== 'string') {
-        return null;
-    }
-    return normalizeCollabRoleToken(match[1]);
-}
-function resolveCollabRolePolicy(value) {
-    const normalized = (value ?? '').trim().toLowerCase();
-    if (!normalized) {
-        return DEFAULT_COLLAB_ROLE_POLICY;
-    }
-    if (normalized === 'off' ||
-        normalized === 'disabled' ||
-        normalized === 'none' ||
-        normalized === '0' ||
-        normalized === 'false') {
-        return 'off';
-    }
-    if (normalized === 'warn' || normalized === 'warning' || normalized === 'soft') {
-        return 'warn';
-    }
-    if (normalized === 'enforce' || normalized === 'strict' || normalized === 'on' || normalized === 'true' || normalized === '1') {
-        return 'enforce';
-    }
-    logger.warn(`Invalid multi-agent role policy value "${value}". Using "${DEFAULT_COLLAB_ROLE_POLICY}" ` +
-        `(expected: enforce|warn|off; canonical env ${COLLAB_ROLE_POLICY_ENV_CANONICAL}, ` +
-        `legacy alias ${COLLAB_ROLE_POLICY_ENV_LEGACY}).`);
-    return DEFAULT_COLLAB_ROLE_POLICY;
-}
-function resolveSymbolicMultiAgentRolePolicyConfig(env) {
-    const canonical = env[COLLAB_ROLE_POLICY_ENV_CANONICAL];
-    const legacy = env[COLLAB_ROLE_POLICY_ENV_LEGACY];
-    if (canonical !== undefined) {
-        if (legacy !== undefined && legacy.trim().toLowerCase() !== canonical.trim().toLowerCase()) {
-            logger.warn(`${COLLAB_ROLE_POLICY_ENV_LEGACY} is ignored because ${COLLAB_ROLE_POLICY_ENV_CANONICAL} is set.`);
-        }
-        return { value: resolveCollabRolePolicy(canonical), source: 'canonical' };
-    }
-    if (legacy !== undefined) {
-        return { value: resolveCollabRolePolicy(legacy), source: 'legacy' };
-    }
-    return { value: resolveCollabRolePolicy(undefined), source: null };
-}
-function resolveSymbolicMultiAgentAllowDefaultRoleConfig(env) {
-    const canonical = env[COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL];
-    const legacy = env[COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY];
-    if (canonical !== undefined) {
-        if (legacy !== undefined && envFlagEnabled(legacy) !== envFlagEnabled(canonical)) {
-            logger.warn(`${COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY} is ignored because ${COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL} is set.`);
-        }
-        return { value: envFlagEnabled(canonical), source: 'canonical' };
-    }
-    if (legacy !== undefined) {
-        return { value: envFlagEnabled(legacy), source: 'legacy' };
-    }
-    return { value: false, source: null };
-}
-function isRolePolicyValidationReason(reasonCode) {
-    return (reasonCode === 'missing_role' ||
-        reasonCode === 'default_role_disallowed' ||
-        reasonCode === 'role_mismatch');
-}
-function includesThreadLimit(text) {
-    return text.toLowerCase().includes('agent thread limit reached');
-}
-function hasCollabSpawnThreadLimitError(raw) {
-    const lines = raw.split('\n');
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith('{')) {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(trimmed);
-            const item = parsed.item;
-            if (!item ||
-                item.type !== 'collab_tool_call' ||
-                item.tool !== 'spawn_agent') {
-                continue;
-            }
-            const candidates = [];
-            if (typeof item.error === 'string') {
-                candidates.push(item.error);
-            }
-            if (typeof item.message === 'string') {
-                candidates.push(item.message);
-            }
-            if (typeof item.output === 'string') {
-                candidates.push(item.output);
-            }
-            if (typeof parsed.error?.message === 'string') {
-                candidates.push(parsed.error.message);
-            }
-            if (candidates.some((entry) => includesThreadLimit(entry))) {
-                return true;
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    return false;
-}
-function validateCollabLifecycle(raw, options = {}) {
-    const requireSpawnRole = options.requireSpawnRole !== false;
-    const allowDefaultRole = options.allowDefaultRole === true;
-    if (hasCollabSpawnThreadLimitError(raw)) {
-        return { ok: false, reason: 'collab spawn hit thread limit', reasonCode: 'thread_limit' };
-    }
-    const calls = parseCollabToolCallsFromJsonl(raw);
-    if (calls.length === 0) {
-        return { ok: true };
-    }
-    const spawnedAt = new Map();
-    const waitedAt = new Map();
-    const closedAt = new Map();
-    const missingRoleIds = new Set();
-    const disallowedDefaultRoleIds = new Set();
-    const mismatchedRoleIds = new Set();
-    const roleByThread = new Map();
-    for (const call of calls) {
-        const isCompleted = call.status === 'completed' || (call.status === 'unknown' && call.eventType === 'item.completed');
-        if (!isCompleted) {
-            continue;
-        }
-        if (call.tool === 'spawn_agent') {
-            const explicitRole = call.agentType;
-            const promptRole = call.promptRole;
-            const effectiveRole = explicitRole ?? promptRole;
-            const roleTargets = call.receiverThreadIds.length > 0 ? call.receiverThreadIds : [`spawn@${call.sequence}`];
-            if (requireSpawnRole && !effectiveRole) {
-                for (const target of roleTargets) {
-                    missingRoleIds.add(target);
-                }
-            }
-            else if (effectiveRole === 'default' && !allowDefaultRole) {
-                for (const target of roleTargets) {
-                    disallowedDefaultRoleIds.add(target);
-                }
-            }
-            if (explicitRole && promptRole && explicitRole !== promptRole) {
-                for (const target of roleTargets) {
-                    mismatchedRoleIds.add(target);
-                }
-            }
-            for (const threadId of call.receiverThreadIds) {
-                if (!spawnedAt.has(threadId)) {
-                    spawnedAt.set(threadId, call.sequence);
-                }
-                if (!effectiveRole) {
-                    continue;
-                }
-                const previous = roleByThread.get(threadId);
-                if (previous && previous !== effectiveRole) {
-                    mismatchedRoleIds.add(threadId);
-                    continue;
-                }
-                roleByThread.set(threadId, effectiveRole);
-            }
-            continue;
-        }
-        for (const threadId of call.receiverThreadIds) {
-            if (call.tool === 'wait') {
-                waitedAt.set(threadId, call.sequence);
-            }
-            else if (call.tool === 'close_agent') {
-                closedAt.set(threadId, call.sequence);
-            }
-        }
-    }
-    const spawnedIds = Array.from(spawnedAt.keys());
-    if (spawnedIds.length > 0) {
-        const missingWait = spawnedIds.filter((threadId) => !waitedAt.has(threadId));
-        if (missingWait.length > 0) {
-            return {
-                ok: false,
-                reason: `missing wait for spawned agent(s): ${formatLifecycleIds(missingWait)}`,
-                reasonCode: 'missing_wait'
-            };
-        }
-        const missingClose = spawnedIds.filter((threadId) => !closedAt.has(threadId));
-        if (missingClose.length > 0) {
-            return {
-                ok: false,
-                reason: `missing close_agent for spawned agent(s): ${formatLifecycleIds(missingClose)}`,
-                reasonCode: 'missing_close'
-            };
-        }
-        const invalidOrder = spawnedIds.filter((threadId) => {
-            const waitSequence = waitedAt.get(threadId);
-            const closeSequence = closedAt.get(threadId);
-            if (waitSequence === undefined || closeSequence === undefined) {
-                return false;
-            }
-            return closeSequence < waitSequence;
-        });
-        if (invalidOrder.length > 0) {
-            return {
-                ok: false,
-                reason: `close_agent before wait for agent(s): ${formatLifecycleIds(invalidOrder)}`,
-                reasonCode: 'close_before_wait'
-            };
-        }
-    }
-    if (!requireSpawnRole) {
-        return { ok: true };
-    }
-    if (missingRoleIds.size > 0) {
-        return {
-            ok: false,
-            reason: `missing explicit role for spawn_agent call(s): ${formatLifecycleIds(Array.from(missingRoleIds))}. ` +
-                'Prefix prompts with [agent_type:<role>] and set spawn_agent.agent_type when supported.',
-            reasonCode: 'missing_role'
-        };
-    }
-    if (disallowedDefaultRoleIds.size > 0) {
-        return {
-            ok: false,
-            reason: `spawn_agent used disallowed default role for: ${formatLifecycleIds(Array.from(disallowedDefaultRoleIds))}. ` +
-                'Set a non-default agent_type explicitly.',
-            reasonCode: 'default_role_disallowed'
-        };
-    }
-    if (mismatchedRoleIds.size > 0) {
-        return {
-            ok: false,
-            reason: `spawn_agent role mismatch for agent(s): ${formatLifecycleIds(Array.from(mismatchedRoleIds))}`,
-            reasonCode: 'role_mismatch'
-        };
-    }
-    return { ok: true };
-}
-function buildCollabSubcallPrompt(prompt) {
-    return [
-        'Use collab tools to run the sub-agent prompt below.',
-        'For every spawned agent id, execute this lifecycle in order:',
-        '1) spawn_agent with explicit agent_type (never omit it; omission defaults to `default`),',
-        '   and prefix the spawned prompt with [agent_type:<same-role>] on the first line',
-        '2) wait (for that same id)',
-        '3) close_agent (for that same id)',
-        'Never leave spawned agents unclosed, including timeout or error paths.',
-        'Return only the sub-agent response text and nothing else.',
-        '',
-        'Sub-agent prompt:',
-        prompt
-    ].join('\n');
+    return { output };
 }
 function normalizeExitCode(code) {
     if (typeof code === 'number' && Number.isInteger(code)) {
@@ -901,13 +476,15 @@ async function main() {
     }
     let contextSource;
     let contextBytes;
+    let hasExplicitContextSource = false;
     try {
-        const resolved = await resolveContextSource(env, goal);
+        const resolved = await resolveContextSource(env, repoRoot, goal);
         contextSource = resolved.source;
         contextBytes = resolved.bytes;
+        hasExplicitContextSource = resolved.explicit;
     }
     catch (error) {
-        await writeStateAndExit('invalid_config', 5, `Invalid RLM_CONTEXT_PATH (${error instanceof Error ? error.message : String(error)}).`, {
+        await writeStateAndExit('invalid_config', 5, `Invalid RLM context source (${error instanceof Error ? error.message : String(error)}).`, {
             goal,
             roles,
             maxIterations,
@@ -916,7 +493,7 @@ async function main() {
         return;
     }
     const delegated = Boolean(env.CODEX_DELEGATION_PARENT_MANIFEST_PATH?.trim());
-    const hasContextPath = Boolean(env.RLM_CONTEXT_PATH?.trim());
+    const hasContextPath = hasExplicitContextSource;
     const mode = resolveRlmMode(env.RLM_MODE, {
         delegated,
         contextBytes,
@@ -1055,9 +632,9 @@ async function main() {
     const subagentsEnabled = envFlagEnabled(env.CODEX_SUBAGENTS) || envFlagEnabled(env.RLM_SUBAGENTS);
     const symbolicMultiAgent = resolveSymbolicMultiAgentConfig(env);
     const symbolicCollabEnabled = symbolicMultiAgent.enabled;
-    const collabRolePolicyConfig = resolveSymbolicMultiAgentRolePolicyConfig(env);
+    const collabRolePolicyConfig = resolveCollabRolePolicyConfig(env);
     const collabRolePolicy = collabRolePolicyConfig.value;
-    const collabAllowDefaultRoleConfig = resolveSymbolicMultiAgentAllowDefaultRoleConfig(env);
+    const collabAllowDefaultRoleConfig = resolveCollabAllowDefaultRoleConfig(env);
     const collabAllowDefaultRole = collabAllowDefaultRoleConfig.value;
     const symbolicDeliberationEnabled = env.RLM_SYMBOLIC_DELIBERATION === undefined
         ? true
@@ -1067,6 +644,7 @@ async function main() {
         : envFlagEnabled(env.RLM_SYMBOLIC_DELIBERATION_INCLUDE_IN_PLANNER);
     const symbolicDeliberationLogArtifacts = envFlagEnabled(env.RLM_SYMBOLIC_DELIBERATION_LOG);
     const nonInteractive = shouldForceNonInteractive(env);
+    const codexRuntimeShell = createRlmCodexRuntimeShell({ env, repoRoot });
     if (mode === 'symbolic') {
         if (symbolicMultiAgent.source === 'legacy') {
             logger.warn('RLM_SYMBOLIC_COLLAB is a legacy alias; prefer RLM_SYMBOLIC_MULTI_AGENT.');
@@ -1078,7 +656,7 @@ async function main() {
             logger.warn(`${COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY} is a legacy alias; prefer ${COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL}.`);
         }
         const collabFeatureKey = symbolicCollabEnabled
-            ? await resolveCollabFeatureKey(env, repoRoot, nonInteractive)
+            ? await codexRuntimeShell.resolveCollabFeatureKey(nonInteractive)
             : COLLAB_FEATURE_LEGACY;
         if (symbolicCollabEnabled) {
             logger.info(`Symbolic collab feature key: ${collabFeatureKey}`);
@@ -1255,6 +833,7 @@ async function main() {
             context: contextInfo
         });
         const contextStore = new ContextStore(contextObject);
+        const runMemoryPromptLines = mode === 'symbolic' ? await resolvePlannerRunMemoryPromptLines(env, repoRoot, goal) : [];
         const result = await runSymbolicLoop({
             goal,
             baseState,
@@ -1264,6 +843,7 @@ async function main() {
             runDir: rlmRoot,
             contextStore,
             budgets,
+            runMemoryPromptLines,
             alignment: alignmentCheckerEnabled
                 ? {
                     enabled: true,
@@ -1278,21 +858,17 @@ async function main() {
                 : undefined,
             runPlanner: (prompt, _attempt) => {
                 void _attempt;
-                return runCodexJsonlCompletion(prompt, env, repoRoot, nonInteractive, false);
+                return codexRuntimeShell.runJsonlCompletion(prompt, {
+                    nonInteractive,
+                    mirrorOutput: false
+                });
             },
             runSubcall: (prompt, _meta) => {
                 void _meta;
-                if (!symbolicCollabEnabled) {
-                    return runCodexCompletion(prompt, env, repoRoot, nonInteractive, false, false);
-                }
-                const collabPrompt = buildCollabSubcallPrompt(prompt);
-                return runCodexJsonlCompletion(collabPrompt, env, repoRoot, nonInteractive, true, [
-                    '--enable',
+                return codexRuntimeShell.runSymbolicPrompt(prompt, {
+                    nonInteractive,
+                    symbolicCollabEnabled,
                     collabFeatureKey,
-                    '--sandbox',
-                    'read-only'
-                ], {
-                    validateCollabLifecycle: true,
                     collabRolePolicy,
                     collabAllowDefaultRole
                 });
@@ -1307,17 +883,10 @@ async function main() {
                 logArtifacts: symbolicDeliberationLogArtifacts,
                 run: (prompt, _meta) => {
                     void _meta;
-                    if (!symbolicCollabEnabled) {
-                        return runCodexCompletion(prompt, env, repoRoot, nonInteractive, false, false);
-                    }
-                    const collabPrompt = buildCollabSubcallPrompt(prompt);
-                    return runCodexJsonlCompletion(collabPrompt, env, repoRoot, nonInteractive, true, [
-                        '--enable',
+                    return codexRuntimeShell.runSymbolicPrompt(prompt, {
+                        nonInteractive,
+                        symbolicCollabEnabled,
                         collabFeatureKey,
-                        '--sandbox',
-                        'read-only'
-                    ], {
-                        validateCollabLifecycle: true,
                         collabRolePolicy,
                         collabAllowDefaultRole
                     });
@@ -1342,7 +911,7 @@ async function main() {
         subagentsEnabled,
         repoRoot,
         runDir: rlmRoot,
-        runAgent: (input) => runCodexAgent(input, env, repoRoot, nonInteractive, subagentsEnabled),
+        runAgent: (input) => runCodexAgent(input, codexRuntimeShell, nonInteractive, subagentsEnabled),
         runValidator: (command) => runValidatorCommand(command, repoRoot),
         logger: (line) => logger.info(line)
     });
@@ -1371,18 +940,9 @@ export const __test__ = {
     resolveAlignmentCheckerEnabled,
     resolveAlignmentCheckerEnforce,
     resolveSymbolicMultiAgentConfig,
-    resolveSymbolicMultiAgentRolePolicyConfig,
-    resolveSymbolicMultiAgentAllowDefaultRoleConfig,
-    parseFeatureFlagsFromText,
-    resolveCollabFeatureKeyFromFlags,
-    resolveCollabRolePolicy,
-    isRolePolicyValidationReason,
+    resolveContextSource,
+    resolvePlannerRunMemoryPromptLines,
     resolveRlmMode,
-    parseCollabToolCallsFromJsonl,
-    validateCollabLifecycle,
-    buildCollabSubcallPrompt,
-    COLLAB_FEATURE_CANONICAL,
-    COLLAB_FEATURE_LEGACY,
     DEFAULT_MAX_ITERATIONS,
     DEFAULT_MAX_MINUTES,
     DEFAULT_SYMBOLIC_MIN_BYTES,