@kbediako/codex-orchestrator 0.1.38 → 0.2.0

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

@@ -0,0 +1,98 @@
+import process from 'node:process';
+import { logger } from '../../logger.js';
+import { loadDelegationConfigFiles, computeEffectiveDelegationConfig, parseDelegationConfigOverride, splitDelegationConfigOverrides } from '../config/delegationConfig.js';
+import { ControlServer } from '../control/controlServer.js';
+import { RunEventStream, attachRunEventAdapter } from '../events/runEventStream.js';
+const CONFIG_OVERRIDE_ENV_KEYS = ['CODEX_CONFIG_OVERRIDES', 'CODEX_MCP_CONFIG_OVERRIDES'];
+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)}`);
+            }
+        }
+    }
+    return layers;
+}
+export async function startOrchestratorControlPlaneLifecycle(options) {
+    const eventStream = await RunEventStream.create({
+        paths: options.paths,
+        taskId: options.taskId,
+        runId: options.runId,
+        pipelineId: options.pipeline.id,
+        pipelineTitle: options.pipeline.title
+    });
+    let controlServer = null;
+    let detachStream = null;
+    const onEventEntry = (entry) => {
+        controlServer?.broadcast(entry);
+    };
+    const close = async () => {
+        if (detachStream) {
+            try {
+                detachStream();
+            }
+            catch (error) {
+                logger.warn(`Failed to detach run event stream: ${error?.message ?? String(error)}`);
+            }
+            detachStream = null;
+        }
+        if (controlServer) {
+            try {
+                await controlServer.close();
+            }
+            catch (error) {
+                logger.warn(`Failed to close control server: ${error?.message ?? String(error)}`);
+            }
+            controlServer = null;
+        }
+        try {
+            await eventStream.close();
+        }
+        catch (error) {
+            logger.warn(`Failed to close run event stream: ${error?.message ?? String(error)}`);
+        }
+    };
+    try {
+        const configFiles = await loadDelegationConfigFiles({ repoRoot: options.repoRoot });
+        const envOverrideLayers = collectDelegationEnvOverrides();
+        const layers = [configFiles.global, configFiles.repo, ...envOverrideLayers].filter(Boolean);
+        const effectiveConfig = computeEffectiveDelegationConfig({
+            repoRoot: options.repoRoot,
+            layers
+        });
+        controlServer = effectiveConfig.ui.controlEnabled
+            ? await ControlServer.start({
+                paths: options.paths,
+                config: effectiveConfig,
+                eventStream,
+                runId: options.runId
+            })
+            : null;
+        const onStreamError = (error, payload) => {
+            logger.warn(`Failed to append run event ${payload.event}: ${error.message}`);
+        };
+        detachStream = attachRunEventAdapter(options.emitter, eventStream, onEventEntry, onStreamError);
+        return {
+            eventStream,
+            onEventEntry,
+            close
+        };
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+}

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

@@ -0,0 +1,54 @@
+import { RunEventEmitter, RunEventPublisher } from '../events/runEvents.js';
+import { startOrchestratorControlPlaneLifecycle } from './orchestratorControlPlaneLifecycle.js';
+function createOrchestratorRunEventPublisher(params) {
+    if (!params.emitter) {
+        return undefined;
+    }
+    return new RunEventPublisher(params.emitter, {
+        taskId: params.manifest.task_id,
+        runId: params.manifest.run_id,
+        pipelineId: params.pipeline.id,
+        pipelineTitle: params.pipeline.title,
+        manifestPath: params.paths.manifestPath,
+        logPath: params.paths.logPath
+    });
+}
+export async function runOrchestratorControlPlaneLifecycleShell(params) {
+    const emitter = params.emitter ?? new RunEventEmitter();
+    const startLifecycle = params.startLifecycle ?? startOrchestratorControlPlaneLifecycle;
+    let controlPlaneLifecycle = null;
+    try {
+        try {
+            controlPlaneLifecycle = await startLifecycle({
+                repoRoot: params.repoRoot,
+                paths: params.paths,
+                taskId: params.manifest.task_id,
+                runId: params.manifest.run_id,
+                pipeline: params.pipeline,
+                emitter
+            });
+        }
+        catch (error) {
+            if (params.onStartFailure) {
+                await params.onStartFailure();
+            }
+            throw error;
+        }
+        const runEvents = createOrchestratorRunEventPublisher({
+            pipeline: params.pipeline,
+            manifest: params.manifest,
+            paths: params.paths,
+            emitter
+        });
+        return await params.runWithLifecycle({
+            runEvents,
+            eventStream: controlPlaneLifecycle.eventStream,
+            onEventEntry: controlPlaneLifecycle.onEventEntry
+        });
+    }
+    finally {
+        if (controlPlaneLifecycle) {
+            await controlPlaneLifecycle.close();
+        }
+    }
+}

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

@@ -0,0 +1,112 @@
+import { logger } from '../../logger.js';
+import { ControlWatcher } from '../control/controlWatcher.js';
+import { snapshotStages } from '../events/runEvents.js';
+import { appendMetricsEntry } from '../metrics/metricsRecorder.js';
+import { appendSummary, finalizeStatus, updateHeartbeat } from '../run/manifest.js';
+import { ManifestPersister } from '../run/manifestPersister.js';
+import { relativeToRepo } from '../run/runPaths.js';
+import { persistPipelineExperience } from './pipelineExperience.js';
+import { resolveAdvancedAutopilotDecision } from '../utils/advancedAutopilot.js';
+export async function runOrchestratorExecutionLifecycle(options) {
+    const { env, pipeline, manifest, paths, runEvents } = options;
+    const notes = [];
+    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);
+        // Keep manifest.json current during long-running stages so raw manifest
+        // readers do not misclassify active runs as stale while only the sidecar
+        // heartbeat file advances.
+        return schedulePersist({ manifest: true, heartbeat: true, force: forceManifest });
+    };
+    const controlWatcher = new ControlWatcher({
+        paths,
+        manifest,
+        eventStream: options.eventStream,
+        onEntry: options.onEventEntry,
+        persist: () => schedulePersist({ manifest: true, force: true })
+    });
+    const context = { notes, persister, controlWatcher, schedulePersist };
+    await options.beforeStart?.(context);
+    manifest.status = 'in_progress';
+    updateHeartbeat(manifest);
+    const advancedDecision = resolveAdvancedAutopilotDecision({
+        pipelineId: pipeline.id,
+        targetMetadata: (options.target.metadata ?? null),
+        taskMetadata: (options.task.metadata ?? null),
+        env: options.advancedDecisionEnv
+    });
+    if (advancedDecision.enabled || advancedDecision.source !== 'default') {
+        const advancedSummary = `Advanced mode (${advancedDecision.mode}) ${advancedDecision.enabled ? 'enabled' : 'disabled'}: ${advancedDecision.reason}.`;
+        appendSummary(manifest, advancedSummary);
+        notes.push(advancedSummary);
+        if (options.mode === 'cloud') {
+            await schedulePersist({ manifest: true, force: true });
+        }
+    }
+    await schedulePersist({ manifest: true, heartbeat: true, force: true });
+    runEvents?.runStarted(snapshotStages(manifest, pipeline), manifest.status);
+    if (advancedDecision.autoScout) {
+        const scoutOutcome = await options.runAutoScout({
+            env,
+            paths,
+            manifest,
+            mode: options.mode,
+            pipeline,
+            target: options.target,
+            task: options.task,
+            envOverrides: options.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);
+    let success = true;
+    try {
+        success = await options.executeBody(context);
+    }
+    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 ?? options.defaultFailureStatusDetail);
+    }
+    await options.afterFinalize?.(context);
+    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)
+    };
+}

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

@@ -0,0 +1,27 @@
+import { CLI_EXECUTION_MODE_PARSER, resolveRequiresCloudPolicy } from '../../utils/executionMode.js';
+export function requiresCloudOrchestratorExecution(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
+    });
+    if (requiresCloudFlag !== null) {
+        return requiresCloudFlag;
+    }
+    return Boolean(task.metadata?.execution?.parallel);
+}
+export function determineOrchestratorExecutionMode(task, subtask, overrideMode) {
+    if (overrideMode) {
+        return overrideMode;
+    }
+    if (requiresCloudOrchestratorExecution(task, subtask)) {
+        return 'cloud';
+    }
+    return 'mcp';
+}

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

@@ -0,0 +1,59 @@
+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 { determineOrchestratorExecutionMode } from './orchestratorExecutionModePolicy.js';
+import { routeOrchestratorExecution } from './orchestratorExecutionRouter.js';
+import { runOrchestratorCloudExecutionLifecycleShell } from './orchestratorCloudExecutionLifecycleShell.js';
+export function buildOrchestratorTaskManagerOptions(params) {
+    const planner = params.plannerInstance ?? new CommandPlanner(params.pipeline);
+    const builder = new CommandBuilder(params.executePipeline);
+    const tester = new CommandTester(params.getResult);
+    const reviewer = new CommandReviewer(params.getResult);
+    const stateStore = new TaskStateStore({ outDir: params.env.outRoot, runsDir: params.env.runsRoot });
+    const manifestWriter = new RunManifestWriter({ runsDir: params.env.runsRoot });
+    return {
+        planner,
+        builder,
+        tester,
+        reviewer,
+        runIdFactory: () => params.runId,
+        modePolicy: (task, subtask) => determineOrchestratorExecutionMode(task, subtask, params.modeOverride),
+        persistence: { autoStart: true, stateStore, manifestWriter }
+    };
+}
+export function createOrchestratorTaskManager(params) {
+    return new TaskManager(buildOrchestratorTaskManagerOptions(params));
+}
+export async function executeOrchestratorPipelineWithRouteAdapter(params) {
+    const routeExecution = params.routeExecution ?? routeOrchestratorExecution;
+    return routeExecution({
+        ...params.options,
+        applyRuntimeSelection: params.applyRuntimeSelection,
+        executeCloudPipeline: (options) => params.executeCloudPipeline(options),
+        runAutoScout: params.runAutoScout,
+        startSubpipeline: params.startSubpipeline
+    });
+}
+export async function executeOrchestratorPipelineRouteEntryShell(params) {
+    const executePipelineWithRouteAdapter = params.executePipelineWithRouteAdapter ?? executeOrchestratorPipelineWithRouteAdapter;
+    const runCloudExecutionLifecycle = params.runCloudExecutionLifecycleShell ?? runOrchestratorCloudExecutionLifecycleShell;
+    return executePipelineWithRouteAdapter({
+        options: params.options,
+        applyRuntimeSelection: params.applyRuntimeSelection,
+        executeCloudPipeline: (options) => runCloudExecutionLifecycle({
+            ...options,
+            runAutoScout: params.runAutoScout
+        }),
+        runAutoScout: params.runAutoScout,
+        startSubpipeline: ({ pipelineId, executionModeOverride, runtimeModeRequested }) => params.startPipeline({
+            taskId: params.options.env.taskId,
+            pipelineId,
+            parentRunId: params.options.manifest.run_id,
+            format: 'json',
+            executionMode: executionModeOverride,
+            runtimeMode: runtimeModeRequested
+        }),
+        routeExecution: params.routeExecution
+    });
+}

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

@@ -0,0 +1,57 @@
+import { logger } from '../../logger.js';
+import { appendSummary, finalizeStatus } from '../run/manifest.js';
+import { executeOrchestratorCloudRouteShell } from './orchestratorCloudRouteShell.js';
+import { resolveOrchestratorExecutionRouteState } from './orchestratorExecutionRouteState.js';
+import { executeOrchestratorLocalRouteShell } from './orchestratorLocalRouteShell.js';
+function failExecutionRoute(options, statusDetail, detail) {
+    finalizeStatus(options.manifest, 'failed', statusDetail);
+    appendSummary(options.manifest, detail);
+    logger.error(detail);
+    return {
+        success: false,
+        notes: [detail],
+        manifest: options.manifest,
+        manifestPath: options.paths.manifestPath,
+        logPath: options.paths.logPath
+    };
+}
+async function executeCloudRoute(options, state) {
+    return await executeOrchestratorCloudRouteShell({
+        repoRoot: options.env.repoRoot,
+        task: options.task,
+        target: options.target,
+        manifest: options.manifest,
+        state,
+        executeCloudPipeline: (envOverrides) => options.executeCloudPipeline({ ...options, envOverrides }),
+        reroute: (reroute) => routeOrchestratorExecution({
+            ...options,
+            ...reroute
+        }),
+        failExecutionRoute: (statusDetail, detail) => failExecutionRoute(options, statusDetail, detail)
+    });
+}
+async function executeLocalRoute(options, state) {
+    return executeOrchestratorLocalRouteShell({ ...options, state });
+}
+export async function routeOrchestratorExecution(options) {
+    let state;
+    try {
+        state = await resolveOrchestratorExecutionRouteState({
+            repoRoot: options.env.repoRoot,
+            manifest: options.manifest,
+            mode: options.mode,
+            runtimeModeRequested: options.runtimeModeRequested,
+            runtimeModeSource: options.runtimeModeSource,
+            envOverrides: options.envOverrides,
+            applyRuntimeSelection: options.applyRuntimeSelection
+        });
+    }
+    catch (error) {
+        const detail = `Runtime selection failed: ${error?.message ?? String(error)}`;
+        return failExecutionRoute(options, 'runtime-selection-failed', detail);
+    }
+    if (options.mode === 'cloud') {
+        return await executeCloudRoute(options, state);
+    }
+    return await executeLocalRoute(options, state);
+}

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

@@ -0,0 +1,21 @@
+import process from 'node:process';
+import { resolveRuntimeSelection } from '../runtime/index.js';
+export async function resolveOrchestratorExecutionRouteState(options) {
+    const baseEnvOverrides = { ...(options.envOverrides ?? {}) };
+    const mergedEnv = { ...process.env, ...baseEnvOverrides };
+    const runtimeSelection = await resolveRuntimeSelection({
+        requestedMode: options.runtimeModeRequested,
+        source: options.runtimeModeSource,
+        executionMode: options.mode,
+        repoRoot: options.repoRoot,
+        env: mergedEnv,
+        runId: options.manifest.run_id
+    });
+    options.applyRuntimeSelection(options.manifest, runtimeSelection);
+    const effectiveEnvOverrides = {
+        ...baseEnvOverrides,
+        ...runtimeSelection.env_overrides
+    };
+    const effectiveMergedEnv = { ...process.env, ...effectiveEnvOverrides };
+    return { runtimeSelection, effectiveEnvOverrides, effectiveMergedEnv };
+}

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

@@ -0,0 +1,2 @@
+export { routeOrchestratorExecution } from './orchestratorExecutionRouteDecisionShell.js';
+export { determineOrchestratorExecutionMode, requiresCloudOrchestratorExecution } from './orchestratorExecutionModePolicy.js';

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

@@ -0,0 +1,149 @@
+import { runCommandStage } from './commandRunner.js';
+import { appendSummary, removeStageFailureSummary, removeSubpipelineFailureSummary } from '../run/manifest.js';
+import { relativeToRepo, resolveRunPaths } from '../run/runPaths.js';
+import { isoTimestamp } from '../utils/time.js';
+export async function executeOrchestratorLocalPipeline(options) {
+    const notes = [];
+    const { env, pipeline, manifest, paths, persister, envOverrides, runtimeMode, runtimeSessionId, runEvents, controlWatcher, schedulePersist, startSubpipeline } = options;
+    let success = true;
+    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,
+                    runtimeMode,
+                    runtimeSessionId
+                });
+                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;
+                }
+                removeStageFailureSummary(manifest, stage.title);
+            }
+            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;
+            }
+            continue;
+        }
+        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 startSubpipeline(stage.pipeline);
+            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;
+            }
+            removeSubpipelineFailureSummary(manifest, stage.pipeline);
+        }
+        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;
+            }
+        }
+    }
+    return { success, notes };
+}

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

@@ -0,0 +1,63 @@
+import { appendSummary, ensureGuardrailStatus } from '../run/manifest.js';
+import { runOrchestratorExecutionLifecycle } from './orchestratorExecutionLifecycle.js';
+import { executeOrchestratorLocalPipeline } from './orchestratorLocalPipelineExecutor.js';
+export async function executeOrchestratorLocalRouteShell(options) {
+    const { env, pipeline, manifest, paths, runEvents, state } = options;
+    return runOrchestratorExecutionLifecycle({
+        env,
+        pipeline,
+        manifest,
+        paths,
+        mode: options.mode,
+        target: options.target,
+        task: options.task,
+        runEvents,
+        eventStream: options.eventStream,
+        onEventEntry: options.onEventEntry,
+        persister: options.persister,
+        envOverrides: state.effectiveEnvOverrides,
+        advancedDecisionEnv: state.effectiveMergedEnv,
+        defaultFailureStatusDetail: 'pipeline-failed',
+        beforeStart: ({ notes }) => {
+            if (state.runtimeSelection.fallback.occurred) {
+                const fallbackCode = state.runtimeSelection.fallback.code ?? 'runtime-fallback';
+                const fallbackReason = state.runtimeSelection.fallback.reason ?? 'runtime fallback occurred';
+                const fallbackSummary = `Runtime fallback (${fallbackCode}): ${fallbackReason}`;
+                appendSummary(manifest, fallbackSummary);
+                notes.push(fallbackSummary);
+            }
+        },
+        runAutoScout: (autoScoutOptions) => options.runAutoScout({
+            ...autoScoutOptions,
+            envOverrides: state.effectiveEnvOverrides
+        }),
+        executeBody: async ({ notes, persister, controlWatcher, schedulePersist }) => {
+            const localResult = await executeOrchestratorLocalPipeline({
+                env,
+                pipeline,
+                manifest,
+                paths,
+                persister,
+                envOverrides: state.effectiveEnvOverrides,
+                runtimeMode: state.runtimeSelection.selected_mode,
+                runtimeSessionId: state.runtimeSelection.runtime_session_id,
+                runEvents,
+                controlWatcher,
+                schedulePersist,
+                startSubpipeline: (pipelineId) => options.startSubpipeline({
+                    pipelineId,
+                    executionModeOverride: options.executionModeOverride,
+                    runtimeModeRequested: state.runtimeSelection.selected_mode
+                })
+            });
+            notes.push(...localResult.notes);
+            return localResult.success;
+        },
+        afterFinalize: () => {
+            const guardrailStatus = ensureGuardrailStatus(manifest);
+            if (guardrailStatus.recommendation) {
+                appendSummary(manifest, guardrailStatus.recommendation);
+            }
+        }
+    });
+}