@kbediako/codex-orchestrator 0.1.36 → 0.1.38

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

@@ -21,7 +21,7 @@ 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 { applyHandlesToRunSummary, applyPrivacyToRunSummary, applyCloudExecutionToRunSummary, applyCloudFallbackToRunSummary, applyUsageKpiToRunSummary, persistRunSummary } from './services/runSummaryWriter.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';
@@ -35,6 +35,7 @@ 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';
 const resolveBaseEnvironment = () => normalizeEnvironmentPaths(resolveEnvironmentPaths());
 const CONFIG_OVERRIDE_ENV_KEYS = ['CODEX_CONFIG_OVERRIDES', 'CODEX_MCP_CONFIG_OVERRIDES'];
@@ -233,6 +234,11 @@ export class CodexOrchestrator {
             planTargetFallback: null
         });
         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,
             pipeline: preparation.pipeline,
@@ -241,6 +247,7 @@ export class CodexOrchestrator {
             approvalPolicy: options.approvalPolicy ?? null,
             planTargetId: preparation.planPreview?.targetId ?? preparation.plannerTargetId ?? null
         });
+        this.applyRequestedRuntimeMode(manifest, runtimeModeResolution.mode);
         if (preparation.configNotice) {
             appendSummary(manifest, preparation.configNotice);
         }
@@ -305,6 +312,8 @@ export class CodexOrchestrator {
                 onEventEntry,
                 persister,
                 envOverrides: preparation.envOverrides,
+                runtimeModeRequested: runtimeModeResolution.mode,
+                runtimeModeSource: runtimeModeResolution.source,
                 executionModeOverride: options.executionMode
             });
         }
@@ -362,6 +371,7 @@ export class CodexOrchestrator {
         const preparation = await prepareRun({
             baseEnv: actualEnv,
             pipeline,
+            runtimeModeDefault: userConfig?.runtimeMode ?? null,
             resolver,
             taskIdOverride: manifest.task_id,
             targetStageId: options.targetStageId,
@@ -371,6 +381,14 @@ export class CodexOrchestrator {
         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
+        });
+        this.applyRequestedRuntimeMode(manifest, runtimeModeResolution.mode);
         manifest.plan_target_id = preparation.planPreview?.targetId ?? preparation.plannerTargetId ?? null;
         const persister = new ManifestPersister({
             manifest,
@@ -433,7 +451,9 @@ export class CodexOrchestrator {
                 eventStream: stream,
                 onEventEntry,
                 persister,
-                envOverrides: preparation.envOverrides
+                envOverrides: preparation.envOverrides,
+                runtimeModeRequested: runtimeModeResolution.mode,
+                runtimeModeSource: runtimeModeResolution.source
             });
         }
         finally {
@@ -582,21 +602,52 @@ export class CodexOrchestrator {
         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, options.envOverrides);
-            const branch = readCloudString(options.envOverrides?.CODEX_CLOUD_BRANCH) ??
+            const environmentId = resolveCloudEnvironmentId(options.task, options.target, effectiveEnvOverrides);
+            const branch = readCloudString(effectiveEnvOverrides.CODEX_CLOUD_BRANCH) ??
                 readCloudString(process.env.CODEX_CLOUD_BRANCH);
-            const mergedEnv = { ...process.env, ...(options.envOverrides ?? {}) };
-            const codexBin = resolveCodexCliBin(mergedEnv);
+            const codexBin = resolveCodexCliBin(effectiveMergedEnv);
             const preflight = await runCloudPreflight({
                 repoRoot: options.env.repoRoot,
                 codexBin,
                 environmentId,
                 branch,
-                env: mergedEnv
+                env: effectiveMergedEnv
             });
             if (!preflight.ok) {
-                if (!allowCloudFallback(options.envOverrides)) {
+                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');
@@ -621,21 +672,35 @@ export class CodexOrchestrator {
                 };
                 appendSummary(options.manifest, detail);
                 logger.warn(detail);
-                const fallback = await this.executePipeline({ ...options, mode: 'mcp', executionModeOverride: 'mcp' });
+                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);
+            return await this.executeCloudPipeline({ ...options, envOverrides: effectiveEnvOverrides });
         }
-        const { env, pipeline, manifest, paths, runEvents, envOverrides } = options;
+        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: { ...process.env, ...(envOverrides ?? {}) }
+            env: effectiveMergedEnv
         });
         if (advancedDecision.enabled || advancedDecision.source !== 'default') {
             const advancedSummary = `Advanced mode (${advancedDecision.mode}) ${advancedDecision.enabled ? 'enabled' : 'disabled'}: ${advancedDecision.reason}.`;
@@ -673,7 +738,7 @@ export class CodexOrchestrator {
                 pipeline,
                 target: options.target,
                 task: options.task,
-                envOverrides,
+                envOverrides: effectiveEnvOverrides,
                 advancedDecision
             });
             const scoutMessage = scoutOutcome.status === 'recorded'
@@ -719,7 +784,9 @@ export class CodexOrchestrator {
                             index: entry.index,
                             events: runEvents,
                             persister,
-                            envOverrides
+                            envOverrides: effectiveEnvOverrides,
+                            runtimeMode: runtimeSelection.selected_mode,
+                            runtimeSessionId: runtimeSelection.runtime_session_id
                         });
                         notes.push(`${stage.title}: ${result.summary}`);
                         const updatedEntry = manifest.commands[i];
@@ -769,7 +836,8 @@ export class CodexOrchestrator {
                             pipelineId: stage.pipeline,
                             parentRunId: manifest.run_id,
                             format: 'json',
-                            executionMode: options.executionModeOverride
+                            executionMode: options.executionModeOverride,
+                            runtimeMode: options.runtimeModeRequested
                         });
                         entry.completed_at = isoTimestamp();
                         entry.sub_run_id = child.manifest.run_id;
@@ -1184,7 +1252,7 @@ export class CodexOrchestrator {
         }
     }
     async performRunLifecycle(context) {
-        const { env, pipeline, manifest, paths, planner, taskContext, runId, persister, envOverrides, executionModeOverride } = 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) => {
@@ -1199,6 +1267,8 @@ export class CodexOrchestrator {
                 manifest,
                 paths,
                 mode: input.mode,
+                runtimeModeRequested,
+                runtimeModeSource,
                 executionModeOverride,
                 target: input.target,
                 task: taskContext,
@@ -1254,6 +1324,7 @@ export class CodexOrchestrator {
             persister
         });
         this.scheduler.applySchedulerToRunSummary(runSummary, schedulerPlan);
+        applyRuntimeToRunSummary(runSummary, manifest);
         applyHandlesToRunSummary(runSummary, manifest);
         applyPrivacyToRunSummary(runSummary, manifest);
         applyCloudExecutionToRunSummary(runSummary, manifest);
@@ -1283,6 +1354,25 @@ export class CodexOrchestrator {
             });
         });
     }
+    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) {
@@ -1311,6 +1401,10 @@ export class CodexOrchestrator {
             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
         };
@@ -1321,6 +1415,15 @@ export class CodexOrchestrator {
         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}` : '';

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

@@ -7,7 +7,7 @@ import { promisify } from 'node:util';
 import { createInterface } from 'node:readline/promises';
 import { fileURLToPath } from 'node:url';
 import { logger } from '../logger.js';
-import { resolveCodexCommand } from './utils/devtools.js';
+import { createRuntimeCodexCommandContext, formatRuntimeSelectionSummary, parseRuntimeMode, resolveRuntimeCodexCommand } from './runtime/index.js';
 import { detectValidator } from './rlm/validator.js';
 import { buildRlmPrompt } from './rlm/prompt.js';
 import { runRlmLoop } from './rlm/runner.js';
@@ -57,6 +57,8 @@ const COLLAB_FEATURE_CANONICAL = 'multi_agent';
 const COLLAB_FEATURE_LEGACY = 'collab';
 const COLLAB_ROLE_TAG_PATTERN = /^\s*\[(?:agent_type|role)\s*:\s*([a-z0-9._-]+)\]/i;
 const COLLAB_ROLE_TOKEN_PATTERN = /^[a-z0-9._-]+$/;
+let runtimeCodexContextPromise = null;
+let runtimeCodexContextLogged = false;
 function parseArgs(argv) {
     const parsed = {};
     for (let i = 0; i < argv.length; i += 1) {
@@ -332,8 +334,9 @@ async function runCodexAgent(input, env, repoRoot, nonInteractive, subagentsEnab
     return { output };
 }
 async function runCodexExec(args, env, repoRoot, nonInteractive, subagentsEnabled, mirrorOutput) {
-    const { command, args: resolvedArgs } = resolveCodexCommand(args, env);
-    const childEnv = { ...process.env, ...env };
+    const runtimeContext = await resolveRlmRuntimeCodexContext(env, repoRoot);
+    const { command, args: resolvedArgs } = resolveRuntimeCodexCommand(args, runtimeContext);
+    const childEnv = { ...process.env, ...env, ...runtimeContext.env };
     if (nonInteractive) {
         childEnv.CODEX_NON_INTERACTIVE = childEnv.CODEX_NON_INTERACTIVE ?? '1';
         childEnv.CODEX_NO_INTERACTIVE = childEnv.CODEX_NO_INTERACTIVE ?? '1';
@@ -370,6 +373,27 @@ async function runCodexExec(args, env, repoRoot, nonInteractive, subagentsEnable
     });
     return { stdout, stderr };
 }
+async function resolveRlmRuntimeCodexContext(env, repoRoot) {
+    if (!runtimeCodexContextPromise) {
+        const requestedMode = parseRuntimeMode(env.CODEX_ORCHESTRATOR_RUNTIME_MODE_ACTIVE ?? env.CODEX_ORCHESTRATOR_RUNTIME_MODE ?? null);
+        const runId = typeof env.CODEX_ORCHESTRATOR_RUN_ID === 'string' && env.CODEX_ORCHESTRATOR_RUN_ID.trim().length > 0
+            ? env.CODEX_ORCHESTRATOR_RUN_ID.trim()
+            : `rlm-${Date.now()}`;
+        runtimeCodexContextPromise = createRuntimeCodexCommandContext({
+            requestedMode,
+            executionMode: 'mcp',
+            repoRoot,
+            env: { ...process.env, ...env },
+            runId
+        });
+    }
+    const runtimeContext = await runtimeCodexContextPromise;
+    if (!runtimeCodexContextLogged) {
+        logger.info(`[rlm-runtime] ${formatRuntimeSelectionSummary(runtimeContext.runtime)}`);
+        runtimeCodexContextLogged = true;
+    }
+    return runtimeContext;
+}
 async function runCodexCompletion(prompt, env, repoRoot, nonInteractive, subagentsEnabled, mirrorOutput) {
     const { stdout, stderr } = await runCodexExec(['exec', prompt], env, repoRoot, nonInteractive, subagentsEnabled, mirrorOutput);
     return [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');

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

@@ -13,6 +13,19 @@ const HEARTBEAT_INTERVAL_SECONDS = 5;
 const HEARTBEAT_STALE_AFTER_SECONDS = 30;
 const MAX_ERROR_DETAIL_CHARS = 8 * 1024;
 const DEFAULT_MIN_EXPERIENCE_REWARD = 0.1;
+function createDefaultRuntimeFallback() {
+    return {
+        occurred: false,
+        code: null,
+        reason: null,
+        from_mode: null,
+        to_mode: null,
+        checked_at: isoTimestamp()
+    };
+}
+function runtimeProviderForMode(mode) {
+    return mode === 'appserver' ? 'AppServerRuntimeProvider' : 'CliRuntimeProvider';
+}
 export async function bootstrapManifest(runId, options) {
     const { env, pipeline, parentRunId = null, taskSlug, approvalPolicy = null } = options;
     const paths = resolveRunPaths(env, runId);
@@ -57,6 +70,10 @@ export async function bootstrapManifest(runId, options) {
         instructions_sources: [],
         prompt_packs: [],
         guardrails_required: pipeline.guardrailsRequired !== false,
+        runtime_mode_requested: 'appserver',
+        runtime_mode: 'appserver',
+        runtime_provider: runtimeProviderForMode('appserver'),
+        runtime_fallback: createDefaultRuntimeFallback(),
         cloud_execution: null,
         cloud_fallback: null,
         learning: {
@@ -192,6 +209,8 @@ export function resetForResume(manifest) {
     manifest.status = 'in_progress';
     manifest.status_detail = 'resuming';
     manifest.guardrail_status = undefined;
+    manifest.runtime_provider = runtimeProviderForMode(manifest.runtime_mode);
+    manifest.runtime_fallback = createDefaultRuntimeFallback();
     manifest.cloud_execution = null;
     manifest.cloud_fallback = null;
 }

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

@@ -0,0 +1,39 @@
+import { resolveCodexCommand } from '../utils/devtools.js';
+import { resolveRuntimeMode } from './mode.js';
+import { resolveRuntimeSelection } from './provider.js';
+export async function createRuntimeCodexCommandContext(options) {
+    const runtimeEnv = options.env ?? process.env;
+    const modeResolution = resolveRuntimeMode({
+        flag: options.requestedMode,
+        env: runtimeEnv,
+        configDefault: options.configDefault
+    });
+    const runtime = await resolveRuntimeSelection({
+        requestedMode: modeResolution.mode,
+        source: modeResolution.source,
+        executionMode: options.executionMode ?? 'mcp',
+        repoRoot: options.repoRoot,
+        env: runtimeEnv,
+        runId: options.runId,
+        allowFallback: options.allowFallback
+    });
+    return {
+        runtime,
+        env: {
+            ...runtimeEnv,
+            ...runtime.env_overrides
+        }
+    };
+}
+export function resolveRuntimeCodexCommand(args, context) {
+    return resolveCodexCommand(args, context.env);
+}
+export function formatRuntimeSelectionSummary(selection) {
+    const base = `runtime requested=${selection.requested_mode} selected=${selection.selected_mode} provider=${selection.provider}`;
+    if (!selection.fallback.occurred) {
+        return base;
+    }
+    const code = selection.fallback.code ?? 'unknown';
+    const reason = selection.fallback.reason ?? 'fallback occurred';
+    return `${base} fallback=${code} (${reason})`;
+}

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

@@ -0,0 +1,3 @@
+export { parseRuntimeMode, resolveRuntimeMode, DEFAULT_RUNTIME_MODE, DEFAULT_RUNTIME_MODE_ENV_KEY } from './mode.js';
+export { resolveRuntimeSelection } from './provider.js';
+export { createRuntimeCodexCommandContext, resolveRuntimeCodexCommand, formatRuntimeSelectionSummary } from './codexCommand.js';

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

@@ -0,0 +1,53 @@
+const RUNTIME_MODES = new Set(['cli', 'appserver']);
+const DEFAULT_RUNTIME_MODE = 'appserver';
+const DEFAULT_RUNTIME_MODE_ENV_KEY = 'CODEX_ORCHESTRATOR_RUNTIME_MODE';
+function normalizeRuntimeMode(value) {
+    const normalized = value.trim().toLowerCase();
+    return RUNTIME_MODES.has(normalized) ? normalized : null;
+}
+function parseRuntimeModeFromSource(value, sourceLabel) {
+    const parsed = normalizeRuntimeMode(value);
+    if (!parsed) {
+        throw new Error(`Invalid runtime mode "${value}" from ${sourceLabel}. Expected one of: cli, appserver.`);
+    }
+    return parsed;
+}
+export function parseRuntimeMode(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return null;
+    }
+    return normalizeRuntimeMode(value);
+}
+export function resolveRuntimeMode(options = {}) {
+    if (typeof options.flag === 'string' && options.flag.trim().length > 0) {
+        return {
+            mode: parseRuntimeModeFromSource(options.flag, 'CLI flag'),
+            source: 'flag'
+        };
+    }
+    const envKey = options.envKey ?? DEFAULT_RUNTIME_MODE_ENV_KEY;
+    const envValue = options.env?.[envKey] ?? process.env[envKey];
+    if (typeof envValue === 'string' && envValue.trim().length > 0) {
+        return {
+            mode: parseRuntimeModeFromSource(envValue, `env ${envKey}`),
+            source: 'env'
+        };
+    }
+    if (typeof options.configDefault === 'string' && options.configDefault.trim().length > 0) {
+        return {
+            mode: parseRuntimeModeFromSource(options.configDefault, 'config default'),
+            source: 'config'
+        };
+    }
+    if (options.preferManifest && typeof options.manifestMode === 'string' && options.manifestMode.trim().length > 0) {
+        return {
+            mode: parseRuntimeModeFromSource(options.manifestMode, 'manifest'),
+            source: 'manifest'
+        };
+    }
+    return {
+        mode: DEFAULT_RUNTIME_MODE,
+        source: 'default'
+    };
+}
+export { DEFAULT_RUNTIME_MODE, DEFAULT_RUNTIME_MODE_ENV_KEY };