@kbediako/codex-orchestrator 0.1.38 → 0.2.1

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

@@ -1,222 +1,30 @@
-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 { 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 { resolveRuntimeActivitySnapshot } from './run/runtimeActivity.js';
-import { generateRunId } from './utils/runId.js';
-import { runCommandStage } from './services/commandRunner.js';
-import { appendMetricsEntry } from './metrics/metricsRecorder.js';
-import { isoTimestamp } from './utils/time.js';
-import { resolveRunPaths, relativeToRepo } from './run/runPaths.js';
+import { finalizeStatus } from './run/manifest.js';
+import { persistManifest } from './run/manifestPersister.js';
 import { logger } from '../logger.js';
-import { getPrivacyGuard } from './services/execRuntime.js';
-import { PipelineResolver } from './services/pipelineResolver.js';
 import { ControlPlaneService } from './services/controlPlaneService.js';
-import { ControlWatcher } from './control/controlWatcher.js';
 import { SchedulerService } from './services/schedulerService.js';
-import { applyRuntimeToRunSummary, applyHandlesToRunSummary, applyPrivacyToRunSummary, applyCloudExecutionToRunSummary, applyCloudFallbackToRunSummary, applyUsageKpiToRunSummary, persistRunSummary } from './services/runSummaryWriter.js';
-import { prepareRun, resolvePipelineForResume, overrideTaskEnvironment } from './services/runPreparation.js';
-import { loadPackageConfig, loadUserConfig } from './config/userConfig.js';
-import { formatRepoConfigRequiredError, isRepoConfigRequired } from './config/repoConfigPolicy.js';
-import { loadDelegationConfigFiles, computeEffectiveDelegationConfig, parseDelegationConfigOverride, splitDelegationConfigOverrides } from './config/delegationConfig.js';
-import { ControlServer } from './control/controlServer.js';
-import { RunEventEmitter, RunEventPublisher, snapshotStages } from './events/runEvents.js';
-import { RunEventStream, attachRunEventAdapter } from './events/runEventStream.js';
-import { CLI_EXECUTION_MODE_PARSER, resolveRequiresCloudPolicy } from '../utils/executionMode.js';
-import { resolveCodexCliBin } from './utils/codexCli.js';
-import { CodexCloudTaskExecutor } from '../cloud/CodexCloudTaskExecutor.js';
-import { persistPipelineExperience } from './services/pipelineExperience.js';
-import { runCloudPreflight } from './utils/cloudPreflight.js';
-import { writeJsonAtomic } from './utils/fs.js';
-import { resolveRuntimeMode, resolveRuntimeSelection } from './runtime/index.js';
-import { buildAutoScoutEvidence, resolveAdvancedAutopilotDecision } from './utils/advancedAutopilot.js';
+import { recordOrchestratorAutoScoutEvidence } from './services/orchestratorAutoScoutEvidenceRecorder.js';
+import { runOrchestratorRunLifecycle } from './services/orchestratorRunLifecycleOrchestrationShell.js';
+import { executeOrchestratorPipelineRouteEntryShell } from './services/orchestratorExecutionRouteAdapterShell.js';
+import { runOrchestratorControlPlaneLifecycleShell } from './services/orchestratorControlPlaneLifecycleShell.js';
+import { runOrchestratorStartPreparationShell } from './services/orchestratorStartPreparationShell.js';
+import { runOrchestratorResumePreparationShell } from './services/orchestratorResumePreparationShell.js';
+import { runOrchestratorStatusShell } from './services/orchestratorStatusShell.js';
+import { runOrchestratorPlanShell } from './services/orchestratorPlanShell.js';
+import { applyRequestedRuntimeModeToManifest, applyRuntimeSelectionToManifest } from './services/orchestratorRuntimeManifestMutation.js';
+import { validateOrchestratorResumeToken } from './services/orchestratorResumeTokenValidation.js';
 const resolveBaseEnvironment = () => normalizeEnvironmentPaths(resolveEnvironmentPaths());
-const CONFIG_OVERRIDE_ENV_KEYS = ['CODEX_CONFIG_OVERRIDES', 'CODEX_MCP_CONFIG_OVERRIDES'];
-const DEFAULT_CLOUD_POLL_INTERVAL_SECONDS = 10;
-const DEFAULT_CLOUD_TIMEOUT_SECONDS = 1800;
-const DEFAULT_CLOUD_ATTEMPTS = 1;
-const DEFAULT_CLOUD_STATUS_RETRY_LIMIT = 12;
-const DEFAULT_CLOUD_STATUS_RETRY_BACKOFF_MS = 1500;
-const DEFAULT_AUTO_SCOUT_TIMEOUT_MS = 4000;
-const MAX_CLOUD_PROMPT_EXPERIENCES = 3;
-const MAX_CLOUD_PROMPT_EXPERIENCE_CHARS = 320;
-function collectDelegationEnvOverrides(env = process.env) {
-    const layers = [];
-    for (const key of CONFIG_OVERRIDE_ENV_KEYS) {
-        const raw = env[key];
-        if (!raw) {
-            continue;
-        }
-        const values = splitDelegationConfigOverrides(raw);
-        for (const value of values) {
-            try {
-                const layer = parseDelegationConfigOverride(value, 'env');
-                if (layer) {
-                    layers.push(layer);
-                }
-            }
-            catch (error) {
-                logger.warn(`Invalid delegation config override (env): ${error?.message ?? String(error)}`);
-            }
-        }
+const RESUME_PRE_START_FAILURE_STATUS_DETAIL = 'resume-pre-start-failed';
+async function persistResumePreStartFailureState(manifest, paths, persister) {
+    finalizeStatus(manifest, 'failed', RESUME_PRE_START_FAILURE_STATUS_DETAIL);
+    try {
+        await persistManifest(paths, manifest, persister, { force: true });
     }
-    return layers;
-}
-function readCloudString(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
-}
-function readCloudNumber(raw, fallback) {
-    if (!raw) {
-        return fallback;
-    }
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        return fallback;
-    }
-    return parsed;
-}
-function allowCloudFallback(envOverrides) {
-    const raw = readCloudString(envOverrides?.CODEX_ORCHESTRATOR_CLOUD_FALLBACK) ??
-        readCloudString(process.env.CODEX_ORCHESTRATOR_CLOUD_FALLBACK);
-    if (!raw) {
-        return true;
-    }
-    const normalized = raw.toLowerCase();
-    return !['0', 'false', 'off', 'deny', 'disabled', 'never', 'strict'].includes(normalized);
-}
-function normalizeCloudFallbackIssues(issues) {
-    return issues.map((issue) => ({ code: issue.code, message: issue.message }));
-}
-function readCloudFeatureList(raw) {
-    if (!raw) {
-        return [];
-    }
-    const seen = new Set();
-    const features = [];
-    for (const token of raw.split(/[,\s]+/u)) {
-        const feature = token.trim();
-        if (!feature || seen.has(feature)) {
-            continue;
-        }
-        seen.add(feature);
-        features.push(feature);
-    }
-    return features;
-}
-function normalizePromptSnippet(value) {
-    return value.replace(/\s+/gu, ' ').trim();
-}
-function truncatePromptSnippet(value) {
-    if (value.length <= MAX_CLOUD_PROMPT_EXPERIENCE_CHARS) {
-        return value;
-    }
-    return `${value.slice(0, MAX_CLOUD_PROMPT_EXPERIENCE_CHARS - 1).trimEnd()}…`;
-}
-function readPromptPackDomain(value) {
-    if (typeof value !== 'string') {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-function readPromptPackDomainLower(pack) {
-    const domain = readPromptPackDomain(pack.domain);
-    return domain ? domain.toLowerCase() : null;
-}
-function hasPromptPackExperiences(pack) {
-    if (!readPromptPackDomain(pack.domain)) {
-        return false;
-    }
-    return (Array.isArray(pack.experiences) &&
-        pack.experiences.some((entry) => typeof entry === 'string' && normalizePromptSnippet(entry).length > 0));
-}
-function selectPromptPackForCloudPrompt(params) {
-    const candidates = (params.promptPacks ?? []).filter(hasPromptPackExperiences);
-    if (candidates.length === 0) {
-        return null;
-    }
-    const haystack = [
-        params.pipeline.id,
-        params.pipeline.title,
-        (params.pipeline.tags ?? []).join(' '),
-        params.target.id,
-        params.target.description ?? '',
-        params.stage.id,
-        params.stage.title
-    ]
-        .join(' ')
-        .toLowerCase();
-    const directMatch = candidates.find((pack) => {
-        const domainLower = readPromptPackDomainLower(pack);
-        return domainLower !== null && domainLower !== 'implementation' && haystack.includes(domainLower);
-    });
-    if (directMatch) {
-        return directMatch;
+    catch (persistError) {
+        logger.warn(`Failed to persist resume pre-start failure state: ${persistError?.message ?? String(persistError)}`);
     }
-    const broadDirectMatch = candidates.find((pack) => {
-        const domainLower = readPromptPackDomainLower(pack);
-        return domainLower !== null && haystack.includes(domainLower);
-    });
-    if (broadDirectMatch) {
-        return broadDirectMatch;
-    }
-    const implementation = candidates.find((pack) => readPromptPackDomainLower(pack) === 'implementation');
-    if (implementation) {
-        return implementation;
-    }
-    return candidates[0] ?? null;
-}
-function buildCloudExperiencePromptLines(params) {
-    const selectedPack = selectPromptPackForCloudPrompt({
-        promptPacks: params.manifest.prompt_packs,
-        pipeline: params.pipeline,
-        target: params.target,
-        stage: params.stage
-    });
-    if (!selectedPack || !Array.isArray(selectedPack.experiences)) {
-        return [];
-    }
-    const snippets = selectedPack.experiences
-        .filter((entry) => typeof entry === 'string')
-        .map((entry) => normalizePromptSnippet(entry))
-        .filter((entry) => entry.length > 0)
-        .slice(0, MAX_CLOUD_PROMPT_EXPERIENCES)
-        .map((entry) => truncatePromptSnippet(entry));
-    if (snippets.length === 0) {
-        return [];
-    }
-    const domainLabel = readPromptPackDomain(selectedPack.domain) ?? 'unknown';
-    return [
-        '',
-        'Relevant prior experiences (hints, not strict instructions):',
-        `Domain: ${domainLabel}`,
-        ...snippets.map((entry, index) => `${index + 1}. ${entry}`)
-    ];
-}
-function resolveCloudEnvironmentId(task, target, envOverrides) {
-    const metadata = (target.metadata ?? {});
-    const taskMetadata = (task.metadata ?? {});
-    const taskCloud = (taskMetadata.cloud ?? null);
-    const candidates = [
-        readCloudString(metadata.cloudEnvId),
-        readCloudString(metadata.cloud_env_id),
-        readCloudString(metadata.envId),
-        readCloudString(metadata.environmentId),
-        readCloudString(taskCloud?.envId),
-        readCloudString(taskCloud?.environmentId),
-        readCloudString(taskMetadata.cloudEnvId),
-        readCloudString(taskMetadata.cloud_env_id),
-        readCloudString(envOverrides?.CODEX_CLOUD_ENV_ID),
-        readCloudString(process.env.CODEX_CLOUD_ENV_ID)
-    ];
-    return candidates.find((candidate) => candidate !== null) ?? null;
 }
 export class CodexOrchestrator {
     baseEnv;
@@ -226,80 +34,18 @@ export class CodexOrchestrator {
         this.baseEnv = baseEnv;
     }
     async start(options = {}) {
-        const preparation = await prepareRun({
+        const { preparation, runId, runtimeModeResolution, manifest, paths, persister } = await runOrchestratorStartPreparationShell({
             baseEnv: this.baseEnv,
-            taskIdOverride: options.taskId,
-            pipelineId: options.pipelineId,
-            targetStageId: options.targetStageId ?? null,
-            planTargetFallback: null
+            options,
+            applyRequestedRuntimeMode: applyRequestedRuntimeModeToManifest
         });
-        const runId = generateRunId();
-        const runtimeModeResolution = resolveRuntimeMode({
-            flag: options.runtimeMode,
-            env: { ...process.env, ...(preparation.envOverrides ?? {}) },
-            configDefault: preparation.runtimeModeDefault
-        });
-        const { manifest, paths } = await bootstrapManifest(runId, {
-            env: preparation.env,
+        return await runOrchestratorControlPlaneLifecycleShell({
+            repoRoot: preparation.env.repoRoot,
+            paths,
             pipeline: preparation.pipeline,
-            parentRunId: options.parentRunId ?? null,
-            taskSlug: preparation.metadata.slug,
-            approvalPolicy: options.approvalPolicy ?? null,
-            planTargetId: preparation.planPreview?.targetId ?? preparation.plannerTargetId ?? null
-        });
-        this.applyRequestedRuntimeMode(manifest, runtimeModeResolution.mode);
-        if (preparation.configNotice) {
-            appendSummary(manifest, preparation.configNotice);
-        }
-        const persister = new ManifestPersister({
             manifest,
-            paths,
-            persistIntervalMs: Math.max(1000, manifest.heartbeat_interval_seconds * 1000)
-        });
-        const emitter = options.runEvents ?? new RunEventEmitter();
-        let eventStream = null;
-        let controlServer = null;
-        let detachStream = null;
-        let onEventEntry;
-        try {
-            const stream = await RunEventStream.create({
-                paths,
-                taskId: manifest.task_id,
-                runId,
-                pipelineId: preparation.pipeline.id,
-                pipelineTitle: preparation.pipeline.title
-            });
-            eventStream = stream;
-            const configFiles = await loadDelegationConfigFiles({ repoRoot: preparation.env.repoRoot });
-            const envOverrideLayers = collectDelegationEnvOverrides();
-            const layers = [configFiles.global, configFiles.repo, ...envOverrideLayers].filter(Boolean);
-            const effectiveConfig = computeEffectiveDelegationConfig({
-                repoRoot: preparation.env.repoRoot,
-                layers
-            });
-            controlServer = effectiveConfig.ui.controlEnabled
-                ? await ControlServer.start({
-                    paths,
-                    config: effectiveConfig,
-                    eventStream: stream,
-                    runId
-                })
-                : null;
-            onEventEntry = (entry) => {
-                controlServer?.broadcast(entry);
-            };
-            const onStreamError = (error, payload) => {
-                logger.warn(`Failed to append run event ${payload.event}: ${error.message}`);
-            };
-            detachStream = attachRunEventAdapter(emitter, stream, onEventEntry, onStreamError);
-            const runEvents = this.createRunEventPublisher({
-                runId,
-                pipeline: preparation.pipeline,
-                manifest,
-                paths,
-                emitter
-            });
-            return await this.performRunLifecycle({
+            emitter: options.runEvents,
+            runWithLifecycle: ({ runEvents, eventStream, onEventEntry }) => this.performRunLifecycle({
                 env: preparation.env,
                 pipeline: preparation.pipeline,
                 manifest,
@@ -308,1136 +54,80 @@ export class CodexOrchestrator {
                 taskContext: preparation.taskContext,
                 runId,
                 runEvents,
-                eventStream: stream,
+                eventStream,
                 onEventEntry,
                 persister,
                 envOverrides: preparation.envOverrides,
                 runtimeModeRequested: runtimeModeResolution.mode,
                 runtimeModeSource: runtimeModeResolution.source,
                 executionModeOverride: options.executionMode
-            });
-        }
-        finally {
-            if (detachStream) {
-                try {
-                    detachStream();
-                }
-                catch (error) {
-                    logger.warn(`Failed to detach run event stream: ${error?.message ?? String(error)}`);
-                }
-            }
-            if (controlServer) {
-                try {
-                    await controlServer.close();
-                }
-                catch (error) {
-                    logger.warn(`Failed to close control server: ${error?.message ?? String(error)}`);
-                }
-            }
-            if (eventStream) {
-                try {
-                    await eventStream.close();
-                }
-                catch (error) {
-                    logger.warn(`Failed to close run event stream: ${error?.message ?? String(error)}`);
-                }
-            }
-        }
+            })
+        });
     }
     async resume(options) {
-        const env = this.baseEnv;
-        const { manifest, paths } = await loadManifest(env, options.runId);
-        const actualEnv = overrideTaskEnvironment(env, manifest.task_id);
-        const resolver = new PipelineResolver();
-        const designConfig = await resolver.loadDesignConfig(actualEnv.repoRoot);
-        const repoConfigRequired = isRepoConfigRequired(process.env);
-        const userConfig = await loadUserConfig(actualEnv, { allowPackageFallback: !repoConfigRequired });
-        if (repoConfigRequired && userConfig?.source !== 'repo') {
-            throw new Error(formatRepoConfigRequiredError(actualEnv.repoRoot));
-        }
-        const fallbackConfig = !repoConfigRequired && 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, {
-            actor: options.actor ?? 'cli',
-            reason: options.reason ?? 'manual-resume',
-            outcome: 'accepted'
-        });
-        resetForResume(manifest);
-        updateHeartbeat(manifest);
-        const preparation = await prepareRun({
-            baseEnv: actualEnv,
-            pipeline,
-            runtimeModeDefault: userConfig?.runtimeMode ?? null,
-            resolver,
-            taskIdOverride: manifest.task_id,
-            targetStageId: options.targetStageId,
-            planTargetFallback: manifest.plan_target_id ?? null,
-            envOverrides
-        });
-        if (preparation.configNotice && !(manifest.summary ?? '').includes(preparation.configNotice)) {
-            appendSummary(manifest, preparation.configNotice);
-        }
-        const runtimeModeResolution = resolveRuntimeMode({
-            flag: options.runtimeMode,
-            env: { ...process.env, ...(preparation.envOverrides ?? {}) },
-            configDefault: preparation.runtimeModeDefault,
-            manifestMode: manifest.runtime_mode_requested ?? manifest.runtime_mode ?? null,
-            preferManifest: true
+        const { preparation, runtimeModeResolution, manifest, paths, persister } = await runOrchestratorResumePreparationShell({
+            baseEnv: this.baseEnv,
+            options,
+            validateResumeToken: validateOrchestratorResumeToken,
+            applyRequestedRuntimeMode: applyRequestedRuntimeModeToManifest
         });
-        this.applyRequestedRuntimeMode(manifest, runtimeModeResolution.mode);
-        manifest.plan_target_id = preparation.planPreview?.targetId ?? preparation.plannerTargetId ?? null;
-        const persister = new ManifestPersister({
-            manifest,
+        return await runOrchestratorControlPlaneLifecycleShell({
+            repoRoot: preparation.env.repoRoot,
             paths,
-            persistIntervalMs: Math.max(1000, manifest.heartbeat_interval_seconds * 1000)
-        });
-        await persister.schedule({ manifest: true, heartbeat: true, force: true });
-        const emitter = options.runEvents ?? new RunEventEmitter();
-        let eventStream = null;
-        let controlServer = null;
-        let detachStream = null;
-        let onEventEntry;
-        try {
-            const stream = await RunEventStream.create({
-                paths,
-                taskId: manifest.task_id,
-                runId: manifest.run_id,
-                pipelineId: pipeline.id,
-                pipelineTitle: pipeline.title
-            });
-            eventStream = stream;
-            const configFiles = await loadDelegationConfigFiles({ repoRoot: preparation.env.repoRoot });
-            const envOverrideLayers = collectDelegationEnvOverrides();
-            const layers = [configFiles.global, configFiles.repo, ...envOverrideLayers].filter(Boolean);
-            const effectiveConfig = computeEffectiveDelegationConfig({
-                repoRoot: preparation.env.repoRoot,
-                layers
-            });
-            controlServer = effectiveConfig.ui.controlEnabled
-                ? await ControlServer.start({
-                    paths,
-                    config: effectiveConfig,
-                    eventStream: stream,
-                    runId: manifest.run_id
-                })
-                : null;
-            onEventEntry = (entry) => {
-                controlServer?.broadcast(entry);
-            };
-            const onStreamError = (error, payload) => {
-                logger.warn(`Failed to append run event ${payload.event}: ${error.message}`);
-            };
-            detachStream = attachRunEventAdapter(emitter, stream, onEventEntry, onStreamError);
-            const runEvents = this.createRunEventPublisher({
-                runId: manifest.run_id,
-                pipeline,
-                manifest,
-                paths,
-                emitter
-            });
-            return await this.performRunLifecycle({
+            pipeline: preparation.pipeline,
+            manifest,
+            emitter: options.runEvents,
+            onStartFailure: () => persistResumePreStartFailureState(manifest, paths, persister),
+            runWithLifecycle: ({ runEvents, eventStream, onEventEntry }) => this.performRunLifecycle({
                 env: preparation.env,
-                pipeline,
+                pipeline: preparation.pipeline,
                 manifest,
                 paths,
                 planner: preparation.planner,
                 taskContext: preparation.taskContext,
                 runId: manifest.run_id,
                 runEvents,
-                eventStream: stream,
+                eventStream,
                 onEventEntry,
                 persister,
                 envOverrides: preparation.envOverrides,
                 runtimeModeRequested: runtimeModeResolution.mode,
                 runtimeModeSource: runtimeModeResolution.source
-            });
-        }
-        finally {
-            if (detachStream) {
-                try {
-                    detachStream();
-                }
-                catch (error) {
-                    logger.warn(`Failed to detach run event stream: ${error?.message ?? String(error)}`);
-                }
-            }
-            if (controlServer) {
-                try {
-                    await controlServer.close();
-                }
-                catch (error) {
-                    logger.warn(`Failed to close control server: ${error?.message ?? String(error)}`);
-                }
-            }
-            if (eventStream) {
-                try {
-                    await eventStream.close();
-                }
-                catch (error) {
-                    logger.warn(`Failed to close run event stream: ${error?.message ?? String(error)}`);
-                }
-            }
-        }
+            })
+        });
     }
     async status(options) {
-        const env = this.baseEnv;
-        const { manifest, paths } = await loadManifest(env, options.runId);
-        const activity = await resolveRuntimeActivitySnapshot(manifest, paths);
-        if (options.format === 'json') {
-            const payload = this.buildStatusPayload(env, manifest, paths, activity);
-            process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-            return manifest;
-        }
-        this.renderStatus(manifest, activity);
-        return manifest;
-    }
-    async plan(options = {}) {
-        const preparation = await prepareRun({
+        return await runOrchestratorStatusShell({
             baseEnv: this.baseEnv,
-            taskIdOverride: options.taskId,
-            pipelineId: options.pipelineId,
-            targetStageId: options.targetStageId,
-            planTargetFallback: null
-        });
-        const plan = preparation.planPreview ?? (await preparation.planner.plan(preparation.taskContext));
-        const stages = preparation.pipeline.stages.map((stage, index) => {
-            if (stage.kind === 'command') {
-                return {
-                    index: index + 1,
-                    id: stage.id,
-                    title: stage.title,
-                    kind: stage.kind,
-                    command: stage.command,
-                    cwd: stage.cwd ?? null,
-                    env: stage.env ?? null,
-                    allowFailure: Boolean(stage.allowFailure),
-                    summaryHint: stage.summaryHint ?? null
-                };
-            }
-            return {
-                index: index + 1,
-                id: stage.id,
-                title: stage.title,
-                kind: stage.kind,
-                pipeline: stage.pipeline,
-                optional: Boolean(stage.optional)
-            };
+            options
         });
-        const pipelineSource = preparation.pipelineSource === 'user'
-            ? 'user'
-            : preparation.pipelineSource === 'default'
-                ? 'default'
-                : null;
-        return {
-            pipeline: {
-                id: preparation.pipeline.id,
-                title: preparation.pipeline.title,
-                description: preparation.pipeline.description ?? null,
-                source: pipelineSource
-            },
-            stages,
-            plan,
-            targetId: plan.targetId ?? null
-        };
-    }
-    createRunEventPublisher(params) {
-        if (!params.emitter) {
-            return undefined;
-        }
-        return new RunEventPublisher(params.emitter, {
-            taskId: params.manifest.task_id,
-            runId: params.runId,
-            pipelineId: params.pipeline.id,
-            pipelineTitle: params.pipeline.title,
-            manifestPath: params.paths.manifestPath,
-            logPath: params.paths.logPath
-        });
-    }
-    createTaskManager(runId, pipeline, executePipeline, getResult, plannerInstance, env, modeOverride) {
-        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,
-            tester,
-            reviewer,
-            runIdFactory: () => runId,
-            modePolicy: (task, subtask) => this.determineMode(task, subtask, modeOverride),
-            persistence: { autoStart: true, stateStore, manifestWriter }
-        };
-        return new TaskManager(options);
     }
-    determineMode(task, subtask, overrideMode) {
-        if (overrideMode) {
-            return overrideMode;
-        }
-        if (this.requiresCloudExecution(task, subtask)) {
-            return 'cloud';
-        }
-        return 'mcp';
-    }
-    requiresCloudExecution(task, subtask) {
-        const requiresCloudFlag = resolveRequiresCloudPolicy({
-            boolFlags: [subtask.requires_cloud, subtask.requiresCloud],
-            metadata: {
-                executionMode: typeof subtask.metadata?.executionMode === 'string'
-                    ? subtask.metadata.executionMode
-                    : null,
-                mode: typeof subtask.metadata?.mode === 'string' ? subtask.metadata.mode : null
-            },
-            metadataOrder: ['executionMode', 'mode'],
-            parseMode: CLI_EXECUTION_MODE_PARSER
+    async plan(options = {}) {
+        return await runOrchestratorPlanShell({
+            baseEnv: this.baseEnv,
+            options
         });
-        if (requiresCloudFlag !== null) {
-            return requiresCloudFlag;
-        }
-        return Boolean(task.metadata?.execution?.parallel);
     }
     async executePipeline(options) {
-        const baseEnvOverrides = { ...(options.envOverrides ?? {}) };
-        const mergedEnv = { ...process.env, ...baseEnvOverrides };
-        let runtimeSelection;
-        try {
-            runtimeSelection = await resolveRuntimeSelection({
-                requestedMode: options.runtimeModeRequested,
-                source: options.runtimeModeSource,
-                executionMode: options.mode,
-                repoRoot: options.env.repoRoot,
-                env: mergedEnv,
-                runId: options.manifest.run_id
-            });
-        }
-        catch (error) {
-            const detail = `Runtime selection failed: ${error?.message ?? String(error)}`;
-            finalizeStatus(options.manifest, 'failed', 'runtime-selection-failed');
-            appendSummary(options.manifest, detail);
-            logger.error(detail);
-            return {
-                success: false,
-                notes: [detail],
-                manifest: options.manifest,
-                manifestPath: options.paths.manifestPath,
-                logPath: options.paths.logPath
-            };
-        }
-        this.applyRuntimeSelection(options.manifest, runtimeSelection);
-        const effectiveEnvOverrides = {
-            ...baseEnvOverrides,
-            ...runtimeSelection.env_overrides
-        };
-        const effectiveMergedEnv = { ...process.env, ...effectiveEnvOverrides };
-        if (options.mode === 'cloud') {
-            const environmentId = resolveCloudEnvironmentId(options.task, options.target, effectiveEnvOverrides);
-            const branch = readCloudString(effectiveEnvOverrides.CODEX_CLOUD_BRANCH) ??
-                readCloudString(process.env.CODEX_CLOUD_BRANCH);
-            const codexBin = resolveCodexCliBin(effectiveMergedEnv);
-            const preflight = await runCloudPreflight({
-                repoRoot: options.env.repoRoot,
-                codexBin,
-                environmentId,
-                branch,
-                env: effectiveMergedEnv
-            });
-            if (!preflight.ok) {
-                if (!allowCloudFallback(effectiveEnvOverrides)) {
-                    const detail = `Cloud preflight failed and cloud fallback is disabled. ` +
-                        preflight.issues.map((issue) => issue.message).join(' ');
-                    finalizeStatus(options.manifest, 'failed', 'cloud-preflight-failed');
-                    appendSummary(options.manifest, detail);
-                    logger.error(detail);
-                    return {
-                        success: false,
-                        notes: [detail],
-                        manifest: options.manifest,
-                        manifestPath: options.paths.manifestPath,
-                        logPath: options.paths.logPath
-                    };
-                }
-                const detail = `Cloud preflight failed; falling back to mcp. ` +
-                    preflight.issues.map((issue) => issue.message).join(' ');
-                options.manifest.cloud_fallback = {
-                    mode_requested: 'cloud',
-                    mode_used: 'mcp',
-                    reason: detail,
-                    issues: normalizeCloudFallbackIssues(preflight.issues),
-                    checked_at: isoTimestamp()
-                };
-                appendSummary(options.manifest, detail);
-                logger.warn(detail);
-                const fallback = await this.executePipeline({
-                    ...options,
-                    mode: 'mcp',
-                    executionModeOverride: 'mcp',
-                    runtimeModeRequested: runtimeSelection.selected_mode,
-                    runtimeModeSource: runtimeSelection.source,
-                    envOverrides: effectiveEnvOverrides
-                });
-                fallback.notes.unshift(detail);
-                return fallback;
-            }
-            return await this.executeCloudPipeline({ ...options, envOverrides: effectiveEnvOverrides });
-        }
-        const { env, pipeline, manifest, paths, runEvents } = options;
-        const notes = [];
-        let success = true;
-        manifest.guardrail_status = undefined;
-        if (runtimeSelection.fallback.occurred) {
-            const fallbackCode = runtimeSelection.fallback.code ?? 'runtime-fallback';
-            const fallbackReason = runtimeSelection.fallback.reason ?? 'runtime fallback occurred';
-            const fallbackSummary = `Runtime fallback (${fallbackCode}): ${fallbackReason}`;
-            appendSummary(manifest, fallbackSummary);
-            notes.push(fallbackSummary);
-        }
-        const advancedDecision = resolveAdvancedAutopilotDecision({
-            pipelineId: pipeline.id,
-            targetMetadata: (options.target.metadata ?? null),
-            taskMetadata: (options.task.metadata ?? null),
-            env: effectiveMergedEnv
-        });
-        if (advancedDecision.enabled || advancedDecision.source !== 'default') {
-            const advancedSummary = `Advanced mode (${advancedDecision.mode}) ${advancedDecision.enabled ? 'enabled' : 'disabled'}: ${advancedDecision.reason}.`;
-            appendSummary(manifest, advancedSummary);
-            notes.push(advancedSummary);
-        }
-        const persister = options.persister ??
-            new ManifestPersister({
-                manifest,
-                paths,
-                persistIntervalMs: Math.max(1000, manifest.heartbeat_interval_seconds * 1000)
-            });
-        const schedulePersist = (options = {}) => persister.schedule(options);
-        const pushHeartbeat = (forceManifest = false) => {
-            updateHeartbeat(manifest);
-            return schedulePersist({ manifest: forceManifest, heartbeat: true, force: forceManifest });
-        };
-        const controlWatcher = new ControlWatcher({
-            paths,
-            manifest,
-            eventStream: options.eventStream,
-            onEntry: options.onEventEntry,
-            persist: () => schedulePersist({ manifest: true, force: true })
+        return executeOrchestratorPipelineRouteEntryShell({
+            options,
+            applyRuntimeSelection: applyRuntimeSelectionToManifest,
+            runAutoScout: this.runAutoScout.bind(this),
+            startPipeline: this.start.bind(this)
         });
-        manifest.status = 'in_progress';
-        updateHeartbeat(manifest);
-        await schedulePersist({ manifest: true, heartbeat: true, force: true });
-        runEvents?.runStarted(snapshotStages(manifest, pipeline), manifest.status);
-        if (advancedDecision.autoScout) {
-            const scoutOutcome = await this.runAutoScout({
-                env,
-                paths,
-                manifest,
-                mode: options.mode,
-                pipeline,
-                target: options.target,
-                task: options.task,
-                envOverrides: effectiveEnvOverrides,
-                advancedDecision
-            });
-            const scoutMessage = scoutOutcome.status === 'recorded'
-                ? `Auto scout: evidence recorded at ${scoutOutcome.path}.`
-                : `Auto scout: ${scoutOutcome.message} (non-blocking).`;
-            appendSummary(manifest, scoutMessage);
-            notes.push(scoutMessage);
-            await schedulePersist({ manifest: true, force: true });
-        }
-        const heartbeatInterval = setInterval(() => {
-            void pushHeartbeat(false).catch((error) => {
-                logger.warn(`Heartbeat update failed for run ${manifest.run_id}: ${error?.message ?? String(error)}`);
-            });
-        }, manifest.heartbeat_interval_seconds * 1000);
-        try {
-            for (let i = 0; i < pipeline.stages.length; i += 1) {
-                await controlWatcher.sync();
-                await controlWatcher.waitForResume();
-                if (controlWatcher.isCanceled()) {
-                    manifest.status_detail = 'run-canceled';
-                    success = false;
-                    break;
-                }
-                const stage = pipeline.stages[i];
-                const entry = manifest.commands[i];
-                if (!entry) {
-                    continue;
-                }
-                if (entry.status === 'succeeded' || entry.status === 'skipped') {
-                    notes.push(`${stage.title}: ${entry.status}`);
-                    continue;
-                }
-                entry.status = 'pending';
-                entry.started_at = isoTimestamp();
-                void schedulePersist({ manifest: true });
-                if (stage.kind === 'command') {
-                    try {
-                        const result = await runCommandStage({
-                            env,
-                            paths,
-                            manifest,
-                            stage,
-                            index: entry.index,
-                            events: runEvents,
-                            persister,
-                            envOverrides: effectiveEnvOverrides,
-                            runtimeMode: runtimeSelection.selected_mode,
-                            runtimeSessionId: runtimeSelection.runtime_session_id
-                        });
-                        notes.push(`${stage.title}: ${result.summary}`);
-                        const updatedEntry = manifest.commands[i];
-                        if (updatedEntry?.status === 'failed') {
-                            manifest.status_detail = `stage:${stage.id}:failed`;
-                            appendSummary(manifest, `Stage '${stage.title}' failed with exit code ${result.exitCode}.`);
-                            success = false;
-                            await schedulePersist({ manifest: true, force: true });
-                            break;
-                        }
-                    }
-                    catch (error) {
-                        entry.status = 'failed';
-                        entry.completed_at = isoTimestamp();
-                        entry.summary = `Execution error: ${error?.message ?? String(error)}`;
-                        manifest.status_detail = `stage:${stage.id}:error`;
-                        appendSummary(manifest, entry.summary);
-                        await schedulePersist({ manifest: true, force: true });
-                        runEvents?.stageCompleted({
-                            stageId: stage.id,
-                            stageIndex: entry.index,
-                            title: stage.title,
-                            kind: 'command',
-                            status: entry.status,
-                            exitCode: entry.exit_code,
-                            summary: entry.summary,
-                            logPath: entry.log_path
-                        });
-                        success = false;
-                        break;
-                    }
-                }
-                else {
-                    entry.status = 'running';
-                    await schedulePersist({ manifest: true, force: true });
-                    runEvents?.stageStarted({
-                        stageId: stage.id,
-                        stageIndex: entry.index,
-                        title: stage.title,
-                        kind: 'subpipeline',
-                        logPath: entry.log_path,
-                        status: entry.status
-                    });
-                    try {
-                        const child = await this.start({
-                            taskId: env.taskId,
-                            pipelineId: stage.pipeline,
-                            parentRunId: manifest.run_id,
-                            format: 'json',
-                            executionMode: options.executionModeOverride,
-                            runtimeMode: options.runtimeModeRequested
-                        });
-                        entry.completed_at = isoTimestamp();
-                        entry.sub_run_id = child.manifest.run_id;
-                        entry.summary = child.runSummary.review.summary ?? null;
-                        entry.status = child.manifest.status === 'succeeded' ? 'succeeded' : stage.optional ? 'skipped' : 'failed';
-                        entry.command = null;
-                        manifest.child_runs.push({
-                            run_id: child.manifest.run_id,
-                            pipeline_id: stage.pipeline,
-                            status: child.manifest.status,
-                            manifest: relativeToRepo(env, resolveRunPaths(env, child.manifest.run_id).manifestPath)
-                        });
-                        notes.push(`${stage.title}: ${entry.status}`);
-                        await schedulePersist({ manifest: true, force: true });
-                        runEvents?.stageCompleted({
-                            stageId: stage.id,
-                            stageIndex: entry.index,
-                            title: stage.title,
-                            kind: 'subpipeline',
-                            status: entry.status,
-                            exitCode: entry.exit_code,
-                            summary: entry.summary,
-                            logPath: entry.log_path,
-                            subRunId: entry.sub_run_id
-                        });
-                        if (!stage.optional && entry.status === 'failed') {
-                            manifest.status_detail = `subpipeline:${stage.pipeline}:failed`;
-                            appendSummary(manifest, `Sub-pipeline '${stage.pipeline}' failed.`);
-                            await schedulePersist({ manifest: true, force: true });
-                            success = false;
-                            break;
-                        }
-                    }
-                    catch (error) {
-                        entry.completed_at = isoTimestamp();
-                        entry.summary = `Sub-pipeline error: ${error?.message ?? String(error)}`;
-                        entry.status = stage.optional ? 'skipped' : 'failed';
-                        entry.command = null;
-                        manifest.status_detail = `subpipeline:${stage.pipeline}:error`;
-                        appendSummary(manifest, entry.summary);
-                        notes.push(`${stage.title}: ${entry.status}`);
-                        await schedulePersist({ manifest: true, force: true });
-                        runEvents?.stageCompleted({
-                            stageId: stage.id,
-                            stageIndex: entry.index,
-                            title: stage.title,
-                            kind: 'subpipeline',
-                            status: entry.status,
-                            exitCode: entry.exit_code,
-                            summary: entry.summary,
-                            logPath: entry.log_path,
-                            subRunId: entry.sub_run_id
-                        });
-                        if (!stage.optional) {
-                            success = false;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        finally {
-            clearInterval(heartbeatInterval);
-            await schedulePersist({ force: true });
-        }
-        await controlWatcher.sync();
-        if (controlWatcher.isCanceled()) {
-            finalizeStatus(manifest, 'cancelled', manifest.status_detail ?? 'run-canceled');
-        }
-        else if (success) {
-            finalizeStatus(manifest, 'succeeded');
-        }
-        else {
-            finalizeStatus(manifest, 'failed', manifest.status_detail ?? 'pipeline-failed');
-        }
-        const guardrailStatus = ensureGuardrailStatus(manifest);
-        if (guardrailStatus.recommendation) {
-            appendSummary(manifest, guardrailStatus.recommendation);
-        }
-        updateHeartbeat(manifest);
-        await schedulePersist({ manifest: true, heartbeat: true, force: true }).catch((error) => {
-            logger.warn(`Heartbeat update failed for run ${manifest.run_id}: ${error?.message ?? String(error)}`);
-        });
-        await persistPipelineExperience({ env, pipeline, manifest, paths });
-        await schedulePersist({ force: true });
-        await appendMetricsEntry(env, paths, manifest, persister);
-        return {
-            success,
-            notes,
-            manifest,
-            manifestPath: relativeToRepo(env, paths.manifestPath),
-            logPath: relativeToRepo(env, paths.logPath)
-        };
-    }
-    async executeCloudPipeline(options) {
-        const { env, pipeline, manifest, paths, runEvents, target, task, envOverrides } = options;
-        const notes = [];
-        let success = true;
-        manifest.guardrail_status = undefined;
-        const persister = options.persister ??
-            new ManifestPersister({
-                manifest,
-                paths,
-                persistIntervalMs: Math.max(1000, manifest.heartbeat_interval_seconds * 1000)
-            });
-        const schedulePersist = (persistOptions = {}) => persister.schedule(persistOptions);
-        const pushHeartbeat = (forceManifest = false) => {
-            updateHeartbeat(manifest);
-            return schedulePersist({ manifest: forceManifest, heartbeat: true, force: forceManifest });
-        };
-        const controlWatcher = new ControlWatcher({
-            paths,
-            manifest,
-            eventStream: options.eventStream,
-            onEntry: options.onEventEntry,
-            persist: () => schedulePersist({ manifest: true, force: true })
-        });
-        manifest.status = 'in_progress';
-        updateHeartbeat(manifest);
-        await schedulePersist({ manifest: true, heartbeat: true, force: true });
-        runEvents?.runStarted(snapshotStages(manifest, pipeline), manifest.status);
-        const advancedDecision = resolveAdvancedAutopilotDecision({
-            pipelineId: pipeline.id,
-            targetMetadata: (target.metadata ?? null),
-            taskMetadata: (task.metadata ?? null),
-            env: { ...process.env, ...(envOverrides ?? {}) }
-        });
-        if (advancedDecision.enabled || advancedDecision.source !== 'default') {
-            const advancedSummary = `Advanced mode (${advancedDecision.mode}) ${advancedDecision.enabled ? 'enabled' : 'disabled'}: ${advancedDecision.reason}.`;
-            appendSummary(manifest, advancedSummary);
-            notes.push(advancedSummary);
-            await schedulePersist({ manifest: true, force: true });
-        }
-        if (advancedDecision.autoScout) {
-            const scoutOutcome = await this.runAutoScout({
-                env,
-                paths,
-                manifest,
-                mode: options.mode,
-                pipeline,
-                target,
-                task,
-                envOverrides,
-                advancedDecision
-            });
-            const scoutMessage = scoutOutcome.status === 'recorded'
-                ? `Auto scout: evidence recorded at ${scoutOutcome.path}.`
-                : `Auto scout: ${scoutOutcome.message} (non-blocking).`;
-            appendSummary(manifest, scoutMessage);
-            notes.push(scoutMessage);
-            await schedulePersist({ manifest: true, force: true });
-        }
-        const heartbeatInterval = setInterval(() => {
-            void pushHeartbeat(false).catch((error) => {
-                logger.warn(`Heartbeat update failed for run ${manifest.run_id}: ${error?.message ?? String(error)}`);
-            });
-        }, manifest.heartbeat_interval_seconds * 1000);
-        const targetStageId = this.resolveTargetStageId(target, pipeline);
-        const targetStage = targetStageId
-            ? pipeline.stages.find((stage) => stage.id === targetStageId)
-            : undefined;
-        const targetEntry = targetStageId
-            ? manifest.commands.find((command) => command.id === targetStageId)
-            : undefined;
-        try {
-            await controlWatcher.sync();
-            await controlWatcher.waitForResume();
-            if (controlWatcher.isCanceled()) {
-                manifest.status_detail = 'run-canceled';
-                success = false;
-            }
-            else if (!targetStage || targetStage.kind !== 'command' || !targetEntry) {
-                success = false;
-                manifest.status_detail = 'cloud-target-missing';
-                const detail = targetStageId
-                    ? `Cloud execution target "${targetStageId}" could not be resolved to a command stage.`
-                    : `Cloud execution target "${target.id}" could not be resolved.`;
-                appendSummary(manifest, detail);
-                notes.push(detail);
-            }
-            else {
-                for (let i = 0; i < manifest.commands.length; i += 1) {
-                    const entry = manifest.commands[i];
-                    if (!entry || entry.id === targetStageId) {
-                        continue;
-                    }
-                    entry.status = 'skipped';
-                    entry.started_at = entry.started_at ?? isoTimestamp();
-                    entry.completed_at = isoTimestamp();
-                    entry.summary = `Skipped in cloud mode (target stage: ${targetStageId}).`;
-                }
-                const environmentId = resolveCloudEnvironmentId(task, target, envOverrides);
-                if (!environmentId) {
-                    success = false;
-                    manifest.status_detail = 'cloud-env-missing';
-                    const detail = 'Cloud execution requested but no environment id is configured. Set CODEX_CLOUD_ENV_ID or provide target metadata.cloudEnvId.';
-                    manifest.cloud_execution = {
-                        task_id: null,
-                        environment_id: null,
-                        status: 'failed',
-                        status_url: null,
-                        submitted_at: null,
-                        completed_at: isoTimestamp(),
-                        last_polled_at: null,
-                        poll_count: 0,
-                        poll_interval_seconds: DEFAULT_CLOUD_POLL_INTERVAL_SECONDS,
-                        timeout_seconds: DEFAULT_CLOUD_TIMEOUT_SECONDS,
-                        attempts: DEFAULT_CLOUD_ATTEMPTS,
-                        diff_path: null,
-                        diff_url: null,
-                        diff_status: 'unavailable',
-                        apply_status: 'not_requested',
-                        log_path: null,
-                        error: detail
-                    };
-                    appendSummary(manifest, detail);
-                    notes.push(detail);
-                    targetEntry.status = 'failed';
-                    targetEntry.started_at = targetEntry.started_at ?? isoTimestamp();
-                    targetEntry.completed_at = isoTimestamp();
-                    targetEntry.exit_code = 1;
-                    targetEntry.summary = detail;
-                }
-                else {
-                    targetEntry.status = 'running';
-                    targetEntry.started_at = isoTimestamp();
-                    await schedulePersist({ manifest: true, force: true });
-                    runEvents?.stageStarted({
-                        stageId: targetStage.id,
-                        stageIndex: targetEntry.index,
-                        title: targetStage.title,
-                        kind: 'command',
-                        logPath: targetEntry.log_path,
-                        status: targetEntry.status
-                    });
-                    const executor = new CodexCloudTaskExecutor();
-                    const prompt = this.buildCloudPrompt(task, target, pipeline, targetStage, manifest);
-                    const pollIntervalSeconds = readCloudNumber(envOverrides?.CODEX_CLOUD_POLL_INTERVAL_SECONDS ?? process.env.CODEX_CLOUD_POLL_INTERVAL_SECONDS, DEFAULT_CLOUD_POLL_INTERVAL_SECONDS);
-                    const timeoutSeconds = readCloudNumber(envOverrides?.CODEX_CLOUD_TIMEOUT_SECONDS ?? process.env.CODEX_CLOUD_TIMEOUT_SECONDS, DEFAULT_CLOUD_TIMEOUT_SECONDS);
-                    const attempts = readCloudNumber(envOverrides?.CODEX_CLOUD_EXEC_ATTEMPTS ?? process.env.CODEX_CLOUD_EXEC_ATTEMPTS, DEFAULT_CLOUD_ATTEMPTS);
-                    const statusRetryLimit = readCloudNumber(envOverrides?.CODEX_CLOUD_STATUS_RETRY_LIMIT ?? process.env.CODEX_CLOUD_STATUS_RETRY_LIMIT, DEFAULT_CLOUD_STATUS_RETRY_LIMIT);
-                    const statusRetryBackoffMs = readCloudNumber(envOverrides?.CODEX_CLOUD_STATUS_RETRY_BACKOFF_MS ?? process.env.CODEX_CLOUD_STATUS_RETRY_BACKOFF_MS, DEFAULT_CLOUD_STATUS_RETRY_BACKOFF_MS);
-                    const branch = readCloudString(envOverrides?.CODEX_CLOUD_BRANCH) ??
-                        readCloudString(process.env.CODEX_CLOUD_BRANCH);
-                    const enableFeatures = readCloudFeatureList(readCloudString(envOverrides?.CODEX_CLOUD_ENABLE_FEATURES) ??
-                        readCloudString(process.env.CODEX_CLOUD_ENABLE_FEATURES));
-                    const disableFeatures = readCloudFeatureList(readCloudString(envOverrides?.CODEX_CLOUD_DISABLE_FEATURES) ??
-                        readCloudString(process.env.CODEX_CLOUD_DISABLE_FEATURES));
-                    const codexBin = resolveCodexCliBin({ ...process.env, ...(envOverrides ?? {}) });
-                    const cloudEnvOverrides = {
-                        ...(envOverrides ?? {}),
-                        CODEX_NON_INTERACTIVE: envOverrides?.CODEX_NON_INTERACTIVE ?? process.env.CODEX_NON_INTERACTIVE ?? '1',
-                        CODEX_NO_INTERACTIVE: envOverrides?.CODEX_NO_INTERACTIVE ?? process.env.CODEX_NO_INTERACTIVE ?? '1',
-                        CODEX_INTERACTIVE: envOverrides?.CODEX_INTERACTIVE ?? process.env.CODEX_INTERACTIVE ?? '0'
-                    };
-                    const cloudResult = await executor.execute({
-                        codexBin,
-                        prompt,
-                        environmentId,
-                        repoRoot: env.repoRoot,
-                        runDir: paths.runDir,
-                        pollIntervalSeconds,
-                        timeoutSeconds,
-                        attempts,
-                        statusRetryLimit,
-                        statusRetryBackoffMs,
-                        branch,
-                        enableFeatures,
-                        disableFeatures,
-                        env: cloudEnvOverrides,
-                        onUpdate: async (cloudExecution) => {
-                            manifest.cloud_execution = cloudExecution;
-                            targetEntry.log_path = cloudExecution.log_path;
-                            await schedulePersist({ manifest: true, force: true });
-                        }
-                    });
-                    success = cloudResult.success;
-                    notes.push(...cloudResult.notes);
-                    manifest.cloud_execution = cloudResult.cloudExecution;
-                    targetEntry.log_path = cloudResult.cloudExecution.log_path;
-                    targetEntry.completed_at = isoTimestamp();
-                    targetEntry.exit_code = cloudResult.success ? 0 : 1;
-                    targetEntry.status = cloudResult.success ? 'succeeded' : 'failed';
-                    targetEntry.summary = cloudResult.summary;
-                    if (!cloudResult.success) {
-                        manifest.status_detail = `cloud:${targetStage.id}:failed`;
-                        appendSummary(manifest, cloudResult.summary);
-                    }
-                    await schedulePersist({ manifest: true, force: true });
-                    runEvents?.stageCompleted({
-                        stageId: targetStage.id,
-                        stageIndex: targetEntry.index,
-                        title: targetStage.title,
-                        kind: 'command',
-                        status: targetEntry.status,
-                        exitCode: targetEntry.exit_code,
-                        summary: targetEntry.summary,
-                        logPath: targetEntry.log_path
-                    });
-                }
-            }
-        }
-        finally {
-            clearInterval(heartbeatInterval);
-            await schedulePersist({ force: true });
-        }
-        await controlWatcher.sync();
-        if (controlWatcher.isCanceled()) {
-            finalizeStatus(manifest, 'cancelled', manifest.status_detail ?? 'run-canceled');
-        }
-        else if (success) {
-            finalizeStatus(manifest, 'succeeded');
-        }
-        else {
-            finalizeStatus(manifest, 'failed', manifest.status_detail ?? 'cloud-execution-failed');
-        }
-        updateHeartbeat(manifest);
-        await schedulePersist({ manifest: true, heartbeat: true, force: true }).catch((error) => {
-            logger.warn(`Heartbeat update failed for run ${manifest.run_id}: ${error?.message ?? String(error)}`);
-        });
-        await persistPipelineExperience({ env, pipeline, manifest, paths });
-        await schedulePersist({ force: true });
-        await appendMetricsEntry(env, paths, manifest, persister);
-        return {
-            success,
-            notes,
-            manifest,
-            manifestPath: relativeToRepo(env, paths.manifestPath),
-            logPath: relativeToRepo(env, paths.logPath)
-        };
-    }
-    resolveTargetStageId(target, pipeline) {
-        const metadataStageId = typeof target.metadata?.stageId === 'string' ? target.metadata.stageId : null;
-        if (metadataStageId && pipeline.stages.some((stage) => stage.id === metadataStageId)) {
-            return metadataStageId;
-        }
-        if (target.id.includes(':')) {
-            const suffix = target.id.split(':').pop() ?? null;
-            if (suffix && pipeline.stages.some((stage) => stage.id === suffix)) {
-                return suffix;
-            }
-        }
-        if (pipeline.stages.some((stage) => stage.id === target.id)) {
-            return target.id;
-        }
-        return null;
-    }
-    buildCloudPrompt(task, target, pipeline, stage, manifest) {
-        const lines = [
-            `Task ID: ${task.id}`,
-            `Task title: ${task.title}`,
-            task.description ? `Task description: ${task.description}` : null,
-            `Pipeline: ${pipeline.id}`,
-            `Target stage: ${stage.id} (${target.description})`,
-            '',
-            'Apply the required repository changes for this target stage and produce a diff.'
-        ].filter((line) => Boolean(line));
-        lines.push(...buildCloudExperiencePromptLines({ manifest, pipeline, target, stage }));
-        return lines.join('\n');
     }
     async runAutoScout(params) {
-        const mergedEnv = { ...process.env, ...(params.envOverrides ?? {}) };
-        const timeoutMs = readCloudNumber(mergedEnv.CODEX_ORCHESTRATOR_AUTO_SCOUT_TIMEOUT_MS, DEFAULT_AUTO_SCOUT_TIMEOUT_MS);
-        const work = async () => {
-            const cloudEnvironmentId = resolveCloudEnvironmentId(params.task, params.target, params.envOverrides);
-            const cloudBranch = readCloudString(params.envOverrides?.CODEX_CLOUD_BRANCH) ??
-                readCloudString(process.env.CODEX_CLOUD_BRANCH);
-            const cloudRequested = params.mode === 'cloud' || params.manifest.cloud_fallback?.mode_requested === 'cloud';
-            const evidence = buildAutoScoutEvidence({
-                taskId: params.manifest.task_id,
-                pipelineId: params.pipeline.id,
-                targetId: params.target.id,
-                targetDescription: params.target.description,
-                executionMode: params.mode,
-                cloudRequested,
-                advanced: params.advancedDecision,
-                cloudEnvironmentId,
-                cloudBranch,
-                env: mergedEnv,
-                generatedAt: isoTimestamp()
-            });
-            const evidencePath = join(params.paths.runDir, 'auto-scout.json');
-            await writeJsonAtomic(evidencePath, evidence);
-            return { status: 'recorded', path: relativeToRepo(params.env, evidencePath) };
-        };
-        try {
-            let timeoutHandle = null;
-            const timeoutPromise = new Promise((resolve) => {
-                timeoutHandle = setTimeout(() => {
-                    resolve({
-                        status: 'timeout',
-                        message: `timed out after ${Math.round(timeoutMs / 1000)}s`
-                    });
-                }, timeoutMs);
-                timeoutHandle.unref?.();
-            });
-            const workPromise = work().catch((error) => ({
-                status: 'error',
-                message: error?.message ?? String(error)
-            }));
-            const result = await Promise.race([workPromise, timeoutPromise]);
-            if (timeoutHandle) {
-                clearTimeout(timeoutHandle);
-            }
-            return result;
-        }
-        catch (error) {
-            return {
-                status: 'error',
-                message: error?.message ?? String(error)
-            };
-        }
+        return await recordOrchestratorAutoScoutEvidence(params);
     }
     async performRunLifecycle(context) {
-        const { env, pipeline, manifest, paths, planner, taskContext, runId, persister, envOverrides, runtimeModeRequested, runtimeModeSource, executionModeOverride } = context;
-        let latestPipelineResult = null;
-        const executingByKey = new Map();
-        const executePipeline = async (input) => {
-            const key = `${input.mode}:${input.target.id}`;
-            const existing = executingByKey.get(key);
-            if (existing) {
-                return existing;
-            }
-            const executing = this.executePipeline({
-                env,
-                pipeline,
-                manifest,
-                paths,
-                mode: input.mode,
-                runtimeModeRequested,
-                runtimeModeSource,
-                executionModeOverride,
-                target: input.target,
-                task: taskContext,
-                runEvents: context.runEvents,
-                eventStream: context.eventStream,
-                onEventEntry: context.onEventEntry,
-                persister,
-                envOverrides
-            }).then((result) => {
-                latestPipelineResult = result;
-                return result;
-            });
-            executingByKey.set(key, executing);
-            return executing;
-        };
-        const getResult = () => latestPipelineResult;
-        const manager = this.createTaskManager(runId, pipeline, executePipeline, getResult, planner, env, executionModeOverride);
-        this.attachPlanTargetTracker(manager, manifest, paths, persister);
-        getPrivacyGuard().reset();
-        const controlPlaneResult = await this.controlPlane.guard({
-            env,
-            manifest,
-            paths,
-            pipeline,
-            task: taskContext,
-            runId,
-            requestedBy: { actorId: 'codex-cli', channel: 'cli', name: 'Codex CLI' },
-            persister
+        return await runOrchestratorRunLifecycle({
+            ...context,
+            executePipeline: (options) => this.executePipeline(options),
+            controlPlaneGuard: (options) => this.controlPlane.guard(options),
+            createSchedulerPlan: (options) => this.scheduler.createPlanForRun(options),
+            finalizePlan: (options) => this.scheduler.finalizePlan(options),
+            applySchedulerToRunSummary: (summary, plan) => this.scheduler.applySchedulerToRunSummary(summary, plan),
+            applyControlPlaneToRunSummary: (summary, result) => this.controlPlane.applyControlPlaneToRunSummary(summary, result)
         });
-        const schedulerPlan = await this.scheduler.createPlanForRun({
-            env,
-            manifest,
-            paths,
-            controlPlaneResult,
-            persister
-        });
-        let runSummary;
-        try {
-            runSummary = await manager.execute(taskContext);
-        }
-        catch (error) {
-            context.runEvents?.runError({
-                pipelineId: pipeline.id,
-                message: error?.message ?? String(error),
-                stageId: null
-            });
-            throw error;
-        }
-        await this.scheduler.finalizePlan({
-            manifest,
-            paths,
-            plan: schedulerPlan,
-            persister
-        });
-        this.scheduler.applySchedulerToRunSummary(runSummary, schedulerPlan);
-        applyRuntimeToRunSummary(runSummary, manifest);
-        applyHandlesToRunSummary(runSummary, manifest);
-        applyPrivacyToRunSummary(runSummary, manifest);
-        applyCloudExecutionToRunSummary(runSummary, manifest);
-        applyCloudFallbackToRunSummary(runSummary, manifest);
-        applyUsageKpiToRunSummary(runSummary, manifest);
-        this.controlPlane.applyControlPlaneToRunSummary(runSummary, controlPlaneResult);
-        await persistRunSummary(env, paths, manifest, runSummary, persister);
-        context.runEvents?.runCompleted({
-            pipelineId: pipeline.id,
-            status: manifest.status,
-            manifestPath: paths.manifestPath,
-            runSummaryPath: manifest.run_summary_path,
-            metricsPath: join(env.runsRoot, env.taskId, 'metrics.json'),
-            summary: manifest.summary ?? null
-        });
-        return { manifest, runSummary };
-    }
-    attachPlanTargetTracker(manager, manifest, paths, persister) {
-        manager.bus.on('plan:completed', (event) => {
-            const targetId = event.payload.plan.targetId ?? null;
-            if (manifest.plan_target_id === targetId) {
-                return;
-            }
-            manifest.plan_target_id = targetId;
-            void persistManifest(paths, manifest, persister, { force: true }).catch((error) => {
-                logger.warn(`Failed to persist plan target for run ${manifest.run_id}: ${error?.message ?? String(error)}`);
-            });
-        });
-    }
-    applyRequestedRuntimeMode(manifest, mode) {
-        manifest.runtime_mode_requested = mode;
-        manifest.runtime_mode = mode;
-        manifest.runtime_provider = mode === 'appserver' ? 'AppServerRuntimeProvider' : 'CliRuntimeProvider';
-        manifest.runtime_fallback = {
-            occurred: false,
-            code: null,
-            reason: null,
-            from_mode: null,
-            to_mode: null,
-            checked_at: isoTimestamp()
-        };
-    }
-    applyRuntimeSelection(manifest, selection) {
-        manifest.runtime_mode_requested = selection.requested_mode;
-        manifest.runtime_mode = selection.selected_mode;
-        manifest.runtime_provider = selection.provider;
-        manifest.runtime_fallback = selection.fallback;
-    }
-    async validateResumeToken(paths, manifest, provided) {
-        let stored = manifest.resume_token;
-        if (!stored) {
-            try {
-                stored = (await readFile(paths.resumeTokenPath, 'utf8')).trim();
-            }
-            catch (error) {
-                throw new Error(`Resume token missing for run ${manifest.run_id}: ${error?.message ?? String(error)}`);
-            }
-        }
-        if (provided && stored !== provided) {
-            throw new Error('Resume token mismatch.');
-        }
-    }
-    buildStatusPayload(env, manifest, paths, activity) {
-        return {
-            run_id: manifest.run_id,
-            status: manifest.status,
-            status_detail: manifest.status_detail,
-            started_at: manifest.started_at,
-            completed_at: manifest.completed_at,
-            manifest: relativeToRepo(env, paths.manifestPath),
-            artifact_root: manifest.artifact_root,
-            log_path: manifest.log_path,
-            heartbeat_at: manifest.heartbeat_at,
-            activity,
-            commands: manifest.commands,
-            child_runs: manifest.child_runs,
-            runtime_mode_requested: manifest.runtime_mode_requested,
-            runtime_mode: manifest.runtime_mode,
-            runtime_provider: manifest.runtime_provider,
-            runtime_fallback: manifest.runtime_fallback ?? null,
-            cloud_execution: manifest.cloud_execution ?? null,
-            cloud_fallback: manifest.cloud_fallback ?? null
-        };
-    }
-    renderStatus(manifest, activity) {
-        logger.info(`Run: ${manifest.run_id}`);
-        logger.info(`Status: ${manifest.status}${manifest.status_detail ? ` (${manifest.status_detail})` : ''}`);
-        logger.info(`Started: ${manifest.started_at}`);
-        logger.info(`Completed: ${manifest.completed_at ?? 'in-progress'}`);
-        logger.info(`Manifest: ${manifest.artifact_root}/manifest.json`);
-        if (manifest.runtime_mode || manifest.runtime_mode_requested || manifest.runtime_provider) {
-            const selectedMode = manifest.runtime_mode ?? 'unknown';
-            logger.info(`Runtime: ${selectedMode}${manifest.runtime_mode_requested ? ` (requested ${manifest.runtime_mode_requested})` : ''}` +
-                (manifest.runtime_provider ? ` via ${manifest.runtime_provider}` : ''));
-        }
-        if (manifest.runtime_fallback?.occurred) {
-            const fallbackCode = manifest.runtime_fallback.code ?? 'runtime-fallback';
-            logger.info(`Runtime fallback: ${fallbackCode} — ${manifest.runtime_fallback.reason ?? 'n/a'}`);
-        }
-        if (activity.observed_at) {
-            const staleSuffix = activity.stale === null ? '' : activity.stale ? ' [stale]' : ' [active]';
-            const sourceLabel = activity.observed_source ? ` via ${activity.observed_source}` : '';
-            const ageLabel = activity.age_seconds === null ? '' : ` age=${activity.age_seconds}s`;
-            logger.info(`Activity: ${activity.observed_at}${sourceLabel}${ageLabel}${staleSuffix}`);
-        }
-        if (manifest.cloud_execution?.task_id) {
-            logger.info(`Cloud: ${manifest.cloud_execution.task_id} [${manifest.cloud_execution.status}]` +
-                (manifest.cloud_execution.status_url ? ` ${manifest.cloud_execution.status_url}` : ''));
-        }
-        logger.info('Commands:');
-        for (const command of manifest.commands) {
-            const summary = command.summary ? ` — ${command.summary}` : '';
-            logger.info(`  [${command.status}] ${command.title}${summary}`);
-        }
     }
 }