@kbediako/codex-orchestrator 0.1.38 → 0.2.1

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

@@ -0,0 +1,546 @@
+import { spawn } from 'node:child_process';
+import process from 'node:process';
+import { logger } from '../../logger.js';
+import { createRuntimeCodexCommandContext, formatRuntimeSelectionSummary, parseRuntimeMode, resolveRuntimeCodexCommand } from '../runtime/index.js';
+export const COLLAB_FEATURE_CANONICAL = 'multi_agent';
+export const COLLAB_FEATURE_LEGACY = 'collab';
+const DEFAULT_COLLAB_ROLE_POLICY = 'enforce';
+export const COLLAB_ROLE_POLICY_ENV_CANONICAL = 'RLM_SYMBOLIC_MULTI_AGENT_ROLE_POLICY';
+// Keep the legacy env aliases during the multi_agent migration window; the canonical
+// settings win when both are present so existing lanes can upgrade without silent drift.
+export const COLLAB_ROLE_POLICY_ENV_LEGACY = 'RLM_COLLAB_ROLE_POLICY';
+export const COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL = 'RLM_SYMBOLIC_MULTI_AGENT_ALLOW_DEFAULT_ROLE';
+export const COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY = 'RLM_COLLAB_ALLOW_DEFAULT_ROLE';
+const COLLAB_ROLE_TAG_PATTERN = /^\s*\[(?:agent_type|role)\s*:\s*([a-z0-9._-]+)\]/i;
+const COLLAB_ROLE_TOKEN_PATTERN = /^[a-z0-9._-]+$/;
+function defaultExecRunner(request) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn(request.command, request.args, {
+            cwd: request.cwd,
+            env: request.env,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            if (request.mirrorOutput) {
+                process.stdout.write(chunk);
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            if (request.mirrorOutput) {
+                process.stderr.write(chunk);
+            }
+        });
+        child.once('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolvePromise({ stdout, stderr });
+            }
+            else {
+                reject(new Error(`codex exec exited with code ${code ?? 'unknown'}`));
+            }
+        });
+    });
+}
+function envFlagEnabled(value) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function readNonEmptyEnvValue(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+export function createRlmCodexRuntimeShell(options) {
+    const createRuntimeContextImpl = options.createRuntimeContextImpl ?? createRuntimeCodexCommandContext;
+    const resolveRuntimeCommandImpl = options.resolveRuntimeCommandImpl ?? resolveRuntimeCodexCommand;
+    const formatRuntimeSelectionSummaryImpl = options.formatRuntimeSelectionSummaryImpl ?? formatRuntimeSelectionSummary;
+    const execRunner = options.execRunner ?? defaultExecRunner;
+    const log = options.log ?? logger;
+    let runtimeCodexContextPromise = null;
+    let runtimeCodexContextLogged = false;
+    async function resolveRlmRuntimeCodexContext() {
+        if (!runtimeCodexContextPromise) {
+            const requestedMode = parseRuntimeMode(options.env.CODEX_ORCHESTRATOR_RUNTIME_MODE_ACTIVE ??
+                options.env.CODEX_ORCHESTRATOR_RUNTIME_MODE ??
+                null);
+            const runId = typeof options.env.CODEX_ORCHESTRATOR_RUN_ID === 'string' &&
+                options.env.CODEX_ORCHESTRATOR_RUN_ID.trim().length > 0
+                ? options.env.CODEX_ORCHESTRATOR_RUN_ID.trim()
+                : `rlm-${Date.now()}`;
+            runtimeCodexContextPromise = createRuntimeContextImpl({
+                requestedMode,
+                executionMode: 'mcp',
+                repoRoot: options.repoRoot,
+                env: { ...process.env, ...options.env },
+                runId
+            });
+        }
+        const runtimeContext = await runtimeCodexContextPromise;
+        if (!runtimeCodexContextLogged) {
+            log.info(`[rlm-runtime] ${formatRuntimeSelectionSummaryImpl(runtimeContext.runtime)}`);
+            runtimeCodexContextLogged = true;
+        }
+        return runtimeContext;
+    }
+    async function runCodexExec(args, execOptions) {
+        const runtimeContext = await resolveRlmRuntimeCodexContext();
+        const { command, args: resolvedArgs } = resolveRuntimeCommandImpl(args, runtimeContext);
+        const childEnv = {
+            ...process.env,
+            ...options.env,
+            ...runtimeContext.env
+        };
+        if (execOptions.nonInteractive) {
+            childEnv.CODEX_NON_INTERACTIVE = readNonEmptyEnvValue(childEnv.CODEX_NON_INTERACTIVE) ?? '1';
+            childEnv.CODEX_NO_INTERACTIVE = readNonEmptyEnvValue(childEnv.CODEX_NO_INTERACTIVE) ?? '1';
+            childEnv.CODEX_INTERACTIVE = readNonEmptyEnvValue(childEnv.CODEX_INTERACTIVE) ?? '0';
+        }
+        childEnv.CODEX_SUBAGENTS = execOptions.subagentsEnabled ? '1' : '0';
+        return execRunner({
+            command,
+            args: resolvedArgs,
+            cwd: options.repoRoot,
+            env: childEnv,
+            mirrorOutput: execOptions.mirrorOutput
+        });
+    }
+    return {
+        async runCompletion(prompt, execOptions) {
+            const { stdout, stderr } = await runCodexExec(['exec', prompt], execOptions);
+            return [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
+        },
+        async runJsonlCompletion(prompt, completionOptions) {
+            const { stdout, stderr } = await runCodexExec(['exec', '--json', ...(completionOptions.extraArgs ?? []), prompt], {
+                nonInteractive: completionOptions.nonInteractive,
+                subagentsEnabled: false,
+                mirrorOutput: completionOptions.mirrorOutput
+            });
+            if (completionOptions.validateCollabLifecycle) {
+                const rolePolicy = completionOptions.collabRolePolicy ?? DEFAULT_COLLAB_ROLE_POLICY;
+                const validation = validateCollabLifecycle(stdout, {
+                    requireSpawnRole: rolePolicy !== 'off',
+                    allowDefaultRole: completionOptions.collabAllowDefaultRole ?? false
+                });
+                if (!validation.ok) {
+                    const rolePolicyFailure = isRolePolicyValidationReason(validation.reasonCode);
+                    if (rolePolicy === 'warn' && rolePolicyFailure) {
+                        log.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');
+        },
+        async runSymbolicPrompt(prompt, options) {
+            if (!options.symbolicCollabEnabled) {
+                return this.runCompletion(prompt, {
+                    nonInteractive: options.nonInteractive,
+                    subagentsEnabled: false,
+                    mirrorOutput: false
+                });
+            }
+            return this.runJsonlCompletion(buildCollabSubcallPrompt(prompt), {
+                nonInteractive: options.nonInteractive,
+                mirrorOutput: true,
+                extraArgs: ['--enable', options.collabFeatureKey, '--sandbox', 'read-only'],
+                validateCollabLifecycle: true,
+                collabRolePolicy: options.collabRolePolicy,
+                collabAllowDefaultRole: options.collabAllowDefaultRole
+            });
+        },
+        async resolveCollabFeatureKey(nonInteractive) {
+            try {
+                const { stdout } = await runCodexExec(['features', 'list'], {
+                    nonInteractive,
+                    subagentsEnabled: false,
+                    mirrorOutput: false
+                });
+                return resolveCollabFeatureKeyFromFlags(parseFeatureFlagsFromText(stdout));
+            }
+            catch (error) {
+                log.debug(`Unable to resolve Codex collab feature key via \`codex features list\`: ${error instanceof Error ? error.message : String(error)}`);
+                return COLLAB_FEATURE_LEGACY;
+            }
+        }
+    };
+}
+export 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;
+}
+export 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;
+}
+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';
+}
+export 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]);
+}
+export 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;
+}
+export function resolveCollabRolePolicyConfig(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 };
+}
+export function resolveCollabAllowDefaultRoleConfig(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 };
+}
+export 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;
+}
+export 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 };
+}
+export 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');
+}

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

@@ -524,7 +524,7 @@ async function resolveReadExcerpt(params) {
     return null;
 }
 function buildPlannerPrompt(params) {
-    const { goal, contextStore, budgets, priorReads, priorSearches, priorSubcalls, deliberationBrief } = params;
+    const { goal, contextStore, budgets, runMemoryPromptLines, priorReads, priorSearches, priorSubcalls, deliberationBrief } = params;
     const baseLines = [
         'You are a symbolic RLM planner. Return JSON only (no prose).',
         `Goal: ${goal}`,
@@ -550,7 +550,8 @@ function buildPlannerPrompt(params) {
         '- Do not include full context; use pointers.',
         '- Prefer prior subcall pointers for recursive chaining.',
         '- Request at least one subcall before intent=final.',
-        ''
+        '',
+        ...(runMemoryPromptLines && runMemoryPromptLines.length > 0 ? [...runMemoryPromptLines, ''] : [])
     ];
     const sections = [];
     if (priorSearches.length > 0) {
@@ -923,6 +924,7 @@ export async function runSymbolicLoop(options) {
                 goal: options.goal,
                 contextStore: options.contextStore,
                 budgets: options.budgets,
+                runMemoryPromptLines: options.runMemoryPromptLines,
                 priorReads,
                 priorSearches,
                 priorSubcalls,

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

@@ -0,0 +1,42 @@
+import { runRlmLaunchCliShell } from './rlmLaunchCliShell.js';
+const DEFAULT_DEPENDENCIES = {
+    runRlmLaunchCliShell
+};
+export async function runRlmCliRequestShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const runtimeMode = params.resolveRuntimeModeFlag(params.flags);
+    params.applyRepoConfigRequiredPolicy(params.flags);
+    const goalFromArgs = params.positionals.length > 0 ? params.positionals.join(' ') : undefined;
+    const collabUserChoice = params.flags['collab'] !== undefined ||
+        params.flags['multi-agent'] !== undefined ||
+        params.env.RLM_SYMBOLIC_COLLAB !== undefined ||
+        params.env.RLM_SYMBOLIC_MULTI_AGENT !== undefined;
+    await dependencies.runRlmLaunchCliShell({
+        orchestrator: params.orchestrator,
+        runtimeMode,
+        goalFromArgs,
+        goalFlag: params.readStringFlag(params.flags, 'goal') ?? undefined,
+        goalEnv: params.env.RLM_GOAL,
+        taskIdOverride: readRawStringFlagValue(params.flags['task']),
+        parentRunId: readRawStringFlagValue(params.flags['parent-run']),
+        approvalPolicy: readRawStringFlagValue(params.flags['approval-policy']),
+        collabUserChoice,
+        runWithUi: params.runWithUi,
+        emitRunOutput: params.emitRunOutput,
+        applyRlmEnvOverrides: (goal) => params.applyRlmEnvOverrides(params.flags, goal),
+        shouldWarnLegacyEnvAlias: () => params.shouldWarnLegacyEnvAlias(params.flags, params.env),
+        resolveRlmTaskId: params.resolveRlmTaskId,
+        setTaskEnvironment: params.setTaskEnvironment,
+        runDoctor: params.runDoctor,
+        resolveRepoRoot: params.resolveRepoRoot,
+        runCompletionShell: params.runCompletionShell,
+        log: params.log,
+        warn: params.warn
+    });
+}
+function readRawStringFlagValue(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    return value;
+}

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

@@ -0,0 +1,46 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const DEFAULT_DEPENDENCIES = {
+    readFile,
+    delay: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    terminalStatuses: new Set(['succeeded', 'failed', 'cancelled']),
+    missingStateExitCode: 10
+};
+async function waitForManifestCompletion(manifestPath, dependencies, intervalMs = 2000) {
+    for (;;) {
+        const raw = await dependencies.readFile(manifestPath, 'utf8');
+        const manifest = JSON.parse(raw);
+        if (dependencies.terminalStatuses.has(manifest.status)) {
+            return manifest;
+        }
+        await dependencies.delay(intervalMs);
+    }
+}
+async function readRlmState(statePath, dependencies) {
+    try {
+        const raw = await dependencies.readFile(statePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.final) {
+            return null;
+        }
+        return parsed.final;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runRlmCompletionCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const manifestPath = join(params.repoRoot, params.artifactRoot, 'manifest.json');
+    const manifest = await waitForManifestCompletion(manifestPath, dependencies);
+    const statePath = join(params.repoRoot, params.artifactRoot, 'rlm', 'state.json');
+    const rlmState = await readRlmState(statePath, dependencies);
+    if (rlmState) {
+        params.log(`RLM status: ${rlmState.status}`);
+        params.setExitCode(rlmState.exitCode);
+        return;
+    }
+    params.log(`RLM status: ${manifest.status}`);
+    params.error('RLM state file missing; treating as internal error.');
+    params.setExitCode(dependencies.missingStateExitCode);
+}