@kbediako/codex-orchestrator 0.1.37 → 0.2.0

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

@@ -0,0 +1,54 @@
+import { prepareRun } from './runPreparation.js';
+export function buildOrchestratorPlanPreview(preparation, plan) {
+    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)
+        };
+    });
+    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
+    };
+}
+export async function runOrchestratorPlanShell(params) {
+    const prepareRunImpl = params.prepareRunImpl ?? prepareRun;
+    const preparation = await prepareRunImpl({
+        baseEnv: params.baseEnv,
+        taskIdOverride: params.options.taskId,
+        pipelineId: params.options.pipelineId,
+        targetStageId: params.options.targetStageId,
+        planTargetFallback: null
+    });
+    const plan = preparation.planPreview ?? (await preparation.planner.plan(preparation.taskContext));
+    return buildOrchestratorPlanPreview(preparation, plan);
+}

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

@@ -0,0 +1,16 @@
+import { logger } from '../../logger.js';
+import { persistManifest } from '../run/manifestPersister.js';
+export function attachOrchestratorPlanTargetTracker(params) {
+    const persist = params.persistManifestImpl ?? persistManifest;
+    const warn = params.warn ?? ((message) => logger.warn(message));
+    params.manager.bus.on('plan:completed', (event) => {
+        const targetId = event.payload.plan.targetId ?? null;
+        if (params.manifest.plan_target_id === targetId) {
+            return;
+        }
+        params.manifest.plan_target_id = targetId;
+        void persist(params.paths, params.manifest, params.persister, { force: true }).catch((error) => {
+            warn(`Failed to persist plan target for run ${params.manifest.run_id}: ${error?.message ?? String(error)}`);
+        });
+    });
+}

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

@@ -0,0 +1,84 @@
+import process from 'node:process';
+import { loadManifest, appendSummary, backfillProviderControlHostLocatorFromEnv, updateHeartbeat, resetForResume, recordResumeEvent } from '../run/manifest.js';
+import { ManifestPersister } from '../run/manifestPersister.js';
+import { resolveRuntimeMode } from '../runtime/index.js';
+import { prepareRun, resolvePipelineForResume, overrideTaskEnvironment } from './runPreparation.js';
+import { PipelineResolver } from './pipelineResolver.js';
+import { formatRepoConfigRequiredError, isRepoConfigRequired } from '../config/repoConfigPolicy.js';
+import { loadPackageConfig, loadUserConfig, resolveRepoConfigPath } from '../config/userConfig.js';
+export async function runOrchestratorResumePreparationShell(params) {
+    const loadManifestImpl = params.loadManifestImpl ?? loadManifest;
+    const overrideTaskEnvironmentImpl = params.overrideTaskEnvironmentImpl ?? overrideTaskEnvironment;
+    const createResolver = params.createResolver ?? (() => new PipelineResolver());
+    const isRepoConfigRequiredImpl = params.isRepoConfigRequiredImpl ?? isRepoConfigRequired;
+    const loadUserConfigImpl = params.loadUserConfigImpl ?? loadUserConfig;
+    const loadPackageConfigImpl = params.loadPackageConfigImpl ?? loadPackageConfig;
+    const resolveRepoConfigPathImpl = params.resolveRepoConfigPathImpl ?? resolveRepoConfigPath;
+    const formatRepoConfigRequiredErrorImpl = params.formatRepoConfigRequiredErrorImpl ?? formatRepoConfigRequiredError;
+    const resolvePipelineForResumeImpl = params.resolvePipelineForResumeImpl ?? resolvePipelineForResume;
+    const recordResumeEventImpl = params.recordResumeEventImpl ?? recordResumeEvent;
+    const resetForResumeImpl = params.resetForResumeImpl ?? resetForResume;
+    const updateHeartbeatImpl = params.updateHeartbeatImpl ?? updateHeartbeat;
+    const prepareRunImpl = params.prepareRunImpl ?? prepareRun;
+    const resolveRuntimeModeImpl = params.resolveRuntimeModeImpl ?? resolveRuntimeMode;
+    const appendSummaryImpl = params.appendSummaryImpl ?? appendSummary;
+    const createPersister = params.createPersister ?? ((options) => new ManifestPersister(options));
+    const { manifest, paths } = await loadManifestImpl(params.baseEnv, params.options.runId);
+    const actualEnv = overrideTaskEnvironmentImpl(params.baseEnv, manifest.task_id);
+    const resolver = createResolver();
+    const designConfig = await resolver.loadDesignConfig(actualEnv.repoRoot);
+    const repoConfigRequired = isRepoConfigRequiredImpl(process.env);
+    const userConfig = await loadUserConfigImpl(actualEnv, { allowPackageFallback: !repoConfigRequired });
+    if (repoConfigRequired && userConfig?.source !== 'repo') {
+        throw new Error(formatRepoConfigRequiredErrorImpl(resolveRepoConfigPathImpl(actualEnv, process.env)));
+    }
+    const fallbackConfig = !repoConfigRequired && manifest.pipeline_id === 'rlm' && userConfig?.source === 'repo'
+        ? await loadPackageConfigImpl(actualEnv)
+        : null;
+    const pipeline = resolvePipelineForResumeImpl(actualEnv, manifest, userConfig, fallbackConfig);
+    const envOverrides = resolver.resolveDesignEnvOverrides(designConfig, pipeline.id);
+    await params.validateResumeToken(paths, manifest, params.options.resumeToken ?? null);
+    backfillProviderControlHostLocatorFromEnv(manifest, process.env, { overwriteConflicts: true });
+    recordResumeEventImpl(manifest, {
+        actor: params.options.actor ?? 'cli',
+        reason: params.options.reason ?? 'manual-resume',
+        outcome: 'accepted'
+    });
+    resetForResumeImpl(manifest);
+    updateHeartbeatImpl(manifest);
+    const preparation = await prepareRunImpl({
+        baseEnv: actualEnv,
+        pipeline,
+        runtimeModeDefault: userConfig?.runtimeMode ?? null,
+        resolver,
+        taskIdOverride: manifest.task_id,
+        targetStageId: params.options.targetStageId,
+        planTargetFallback: manifest.plan_target_id ?? null,
+        envOverrides
+    });
+    if (preparation.configNotice && !(manifest.summary ?? '').includes(preparation.configNotice)) {
+        appendSummaryImpl(manifest, preparation.configNotice);
+    }
+    const runtimeModeResolution = resolveRuntimeModeImpl({
+        flag: params.options.runtimeMode,
+        env: { ...process.env, ...(preparation.envOverrides ?? {}) },
+        configDefault: preparation.runtimeModeDefault,
+        manifestMode: manifest.runtime_mode_requested ?? manifest.runtime_mode ?? null,
+        preferManifest: true
+    });
+    params.applyRequestedRuntimeMode(manifest, runtimeModeResolution.mode);
+    manifest.plan_target_id = preparation.planPreview?.targetId ?? preparation.plannerTargetId ?? null;
+    const persister = createPersister({
+        manifest,
+        paths,
+        persistIntervalMs: Math.max(1000, manifest.heartbeat_interval_seconds * 1000)
+    });
+    await persister.schedule({ manifest: true, heartbeat: true, force: true });
+    return {
+        preparation,
+        runtimeModeResolution,
+        manifest,
+        paths,
+        persister
+    };
+}

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

@@ -0,0 +1,15 @@
+import { readFile } from 'node:fs/promises';
+export async function validateOrchestratorResumeToken(paths, manifest, provided, readFileImpl = readFile) {
+    let stored = manifest.resume_token;
+    if (!stored) {
+        try {
+            stored = (await readFileImpl(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.');
+    }
+}

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

@@ -0,0 +1,31 @@
+import { join } from 'node:path';
+import { applyCloudExecutionToRunSummary, applyCloudFallbackToRunSummary, applyHandlesToRunSummary, applyPrivacyToRunSummary, applyRuntimeToRunSummary, applyUsageKpiToRunSummary, persistRunSummary } from './runSummaryWriter.js';
+export async function completeOrchestratorRunLifecycle(options) {
+    await options.finalizePlan({
+        manifest: options.manifest,
+        paths: options.paths,
+        plan: options.schedulerPlan,
+        persister: options.persister
+    });
+    options.applySchedulerToRunSummary(options.runSummary, options.schedulerPlan);
+    applyRuntimeToRunSummary(options.runSummary, options.manifest);
+    applyHandlesToRunSummary(options.runSummary, options.manifest);
+    applyPrivacyToRunSummary(options.runSummary, options.manifest);
+    applyCloudExecutionToRunSummary(options.runSummary, options.manifest);
+    applyCloudFallbackToRunSummary(options.runSummary, options.manifest);
+    applyUsageKpiToRunSummary(options.runSummary, options.manifest);
+    options.applyControlPlaneToRunSummary(options.runSummary, options.controlPlaneResult);
+    await persistRunSummary(options.env, options.paths, options.manifest, options.runSummary, options.persister);
+    options.runEvents?.runCompleted({
+        pipelineId: options.pipeline.id,
+        status: options.manifest.status,
+        manifestPath: options.paths.manifestPath,
+        runSummaryPath: options.manifest.run_summary_path,
+        metricsPath: join(options.env.runsRoot, options.env.taskId, 'metrics.json'),
+        summary: options.manifest.summary ?? null
+    });
+    return {
+        manifest: options.manifest,
+        runSummary: options.runSummary
+    };
+}

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

@@ -0,0 +1,37 @@
+export function createOrchestratorRunLifecycleExecutionRegistration(options) {
+    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 = options
+            .executePipeline({
+            env: options.env,
+            pipeline: options.pipeline,
+            manifest: options.manifest,
+            paths: options.paths,
+            mode: input.mode,
+            runtimeModeRequested: options.runtimeModeRequested,
+            runtimeModeSource: options.runtimeModeSource,
+            executionModeOverride: options.executionModeOverride,
+            target: input.target,
+            task: options.taskContext,
+            runEvents: options.runEvents,
+            eventStream: options.eventStream,
+            onEventEntry: options.onEventEntry,
+            persister: options.persister,
+            envOverrides: options.envOverrides
+        })
+            .then((result) => {
+            latestPipelineResult = result;
+            return result;
+        });
+        executingByKey.set(key, executing);
+        return executing;
+    };
+    const getResult = () => latestPipelineResult;
+    return { executePipeline, getResult };
+}

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

@@ -0,0 +1,83 @@
+import { getPrivacyGuard } from './execRuntime.js';
+import { completeOrchestratorRunLifecycle } from './orchestratorRunLifecycleCompletion.js';
+import { createOrchestratorRunLifecycleTaskManager } from './orchestratorRunLifecycleTaskManagerShell.js';
+export async function executeOrchestratorRunLifecycleTask(manager, taskContext, pipelineId, runEvents) {
+    try {
+        return await manager.execute(taskContext);
+    }
+    catch (error) {
+        runEvents?.runError({
+            pipelineId,
+            message: error?.message ?? String(error),
+            stageId: null
+        });
+        throw error;
+    }
+}
+export async function runOrchestratorRunLifecycleGuardAndPlanning(options) {
+    const controlPlaneResult = await options.controlPlaneGuard({
+        env: options.env,
+        manifest: options.manifest,
+        paths: options.paths,
+        pipeline: options.pipeline,
+        task: options.taskContext,
+        runId: options.runId,
+        requestedBy: { actorId: 'codex-cli', channel: 'cli', name: 'Codex CLI' },
+        persister: options.persister
+    });
+    const schedulerPlan = await options.createSchedulerPlan({
+        env: options.env,
+        manifest: options.manifest,
+        paths: options.paths,
+        controlPlaneResult,
+        persister: options.persister
+    });
+    return { controlPlaneResult, schedulerPlan };
+}
+export async function runOrchestratorRunLifecycle(options) {
+    const manager = createOrchestratorRunLifecycleTaskManager({
+        runId: options.runId,
+        env: options.env,
+        pipeline: options.pipeline,
+        manifest: options.manifest,
+        paths: options.paths,
+        planner: options.planner,
+        taskContext: options.taskContext,
+        runEvents: options.runEvents,
+        eventStream: options.eventStream,
+        onEventEntry: options.onEventEntry,
+        persister: options.persister,
+        envOverrides: options.envOverrides,
+        runtimeModeRequested: options.runtimeModeRequested,
+        runtimeModeSource: options.runtimeModeSource,
+        executionModeOverride: options.executionModeOverride,
+        executePipeline: options.executePipeline
+    });
+    getPrivacyGuard().reset();
+    const { controlPlaneResult, schedulerPlan } = await runOrchestratorRunLifecycleGuardAndPlanning({
+        env: options.env,
+        pipeline: options.pipeline,
+        manifest: options.manifest,
+        paths: options.paths,
+        taskContext: options.taskContext,
+        runId: options.runId,
+        persister: options.persister,
+        controlPlaneGuard: options.controlPlaneGuard,
+        createSchedulerPlan: options.createSchedulerPlan
+    });
+    const runSummary = await executeOrchestratorRunLifecycleTask(manager, options.taskContext, options.pipeline.id, options.runEvents);
+    return await completeOrchestratorRunLifecycle({
+        env: options.env,
+        pipeline: options.pipeline,
+        manifest: options.manifest,
+        paths: options.paths,
+        runSummary,
+        schedulerPlan,
+        controlPlaneResult,
+        runEvents: options.runEvents,
+        persister: options.persister,
+        finalizePlan: options.finalizePlan,
+        applySchedulerToRunSummary: options.applySchedulerToRunSummary,
+        applyControlPlaneToRunSummary: options.applyControlPlaneToRunSummary
+    });
+}

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

@@ -0,0 +1,37 @@
+import { createOrchestratorTaskManager } from './orchestratorExecutionRouteAdapterShell.js';
+import { attachOrchestratorPlanTargetTracker } from './orchestratorPlanTargetTracker.js';
+import { createOrchestratorRunLifecycleExecutionRegistration } from './orchestratorRunLifecycleExecutionRegistration.js';
+export function createOrchestratorRunLifecycleTaskManager(params) {
+    const registration = createOrchestratorRunLifecycleExecutionRegistration({
+        env: params.env,
+        pipeline: params.pipeline,
+        manifest: params.manifest,
+        paths: params.paths,
+        taskContext: params.taskContext,
+        runEvents: params.runEvents,
+        eventStream: params.eventStream,
+        onEventEntry: params.onEventEntry,
+        persister: params.persister,
+        envOverrides: params.envOverrides,
+        runtimeModeRequested: params.runtimeModeRequested,
+        runtimeModeSource: params.runtimeModeSource,
+        executionModeOverride: params.executionModeOverride,
+        executePipeline: params.executePipeline
+    });
+    const manager = createOrchestratorTaskManager({
+        runId: params.runId,
+        pipeline: params.pipeline,
+        executePipeline: registration.executePipeline,
+        getResult: registration.getResult,
+        plannerInstance: params.planner,
+        env: params.env,
+        modeOverride: params.executionModeOverride
+    });
+    attachOrchestratorPlanTargetTracker({
+        manager,
+        manifest: params.manifest,
+        paths: params.paths,
+        persister: params.persister
+    });
+    return manager;
+}

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

@@ -0,0 +1,20 @@
+import { isoTimestamp } from '../utils/time.js';
+export function applyRequestedRuntimeModeToManifest(manifest, mode, isoTimestampImpl = isoTimestamp) {
+    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: isoTimestampImpl()
+    };
+}
+export function applyRuntimeSelectionToManifest(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;
+}

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

@@ -0,0 +1,56 @@
+import process from 'node:process';
+import { bootstrapManifest, appendSummary } from '../run/manifest.js';
+import { ManifestPersister } from '../run/manifestPersister.js';
+import { resolveRuntimeMode } from '../runtime/index.js';
+import { prepareRun } from './runPreparation.js';
+import { generateRunId } from '../utils/runId.js';
+export async function runOrchestratorStartPreparationShell(params) {
+    const prepareRunImpl = params.prepareRunImpl ?? prepareRun;
+    const generateRunIdImpl = params.generateRunIdImpl ?? generateRunId;
+    const resolveRuntimeModeImpl = params.resolveRuntimeModeImpl ?? resolveRuntimeMode;
+    const bootstrapManifestImpl = params.bootstrapManifestImpl ?? bootstrapManifest;
+    const appendSummaryImpl = params.appendSummaryImpl ?? appendSummary;
+    const createPersister = params.createPersister ?? ((options) => new ManifestPersister(options));
+    const preparation = await prepareRunImpl({
+        baseEnv: params.baseEnv,
+        taskIdOverride: params.options.taskId,
+        pipelineId: params.options.pipelineId,
+        targetStageId: params.options.targetStageId ?? null,
+        planTargetFallback: null
+    });
+    const runId = generateRunIdImpl();
+    const runtimeModeResolution = resolveRuntimeModeImpl({
+        flag: params.options.runtimeMode,
+        env: { ...process.env, ...(preparation.envOverrides ?? {}) },
+        configDefault: preparation.runtimeModeDefault
+    });
+    const { manifest, paths } = await bootstrapManifestImpl(runId, {
+        env: preparation.env,
+        pipeline: preparation.pipeline,
+        parentRunId: params.options.parentRunId ?? null,
+        taskSlug: preparation.metadata.slug,
+        approvalPolicy: params.options.approvalPolicy ?? null,
+        planTargetId: preparation.planPreview?.targetId ?? preparation.plannerTargetId ?? null,
+        issueProvider: params.options.issueProvider ?? null,
+        issueId: params.options.issueId ?? null,
+        issueIdentifier: params.options.issueIdentifier ?? null,
+        issueUpdatedAt: params.options.issueUpdatedAt ?? null
+    });
+    params.applyRequestedRuntimeMode(manifest, runtimeModeResolution.mode);
+    if (preparation.configNotice) {
+        appendSummaryImpl(manifest, preparation.configNotice);
+    }
+    const persister = createPersister({
+        manifest,
+        paths,
+        persistIntervalMs: Math.max(1000, manifest.heartbeat_interval_seconds * 1000)
+    });
+    return {
+        preparation,
+        runId,
+        runtimeModeResolution,
+        manifest,
+        paths,
+        persister
+    };
+}

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

@@ -0,0 +1,70 @@
+import process from 'node:process';
+import { logger } from '../../logger.js';
+import { loadManifest } from '../run/manifest.js';
+import { resolveRuntimeActivitySnapshot } from '../run/runtimeActivity.js';
+import { relativeToRepo } from '../run/runPaths.js';
+export function buildOrchestratorStatusPayload(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
+    };
+}
+export function renderOrchestratorStatus(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}`);
+    }
+}
+export async function runOrchestratorStatusShell(params) {
+    const loadManifestImpl = params.loadManifestImpl ?? loadManifest;
+    const resolveRuntimeActivitySnapshotImpl = params.resolveRuntimeActivitySnapshotImpl ?? resolveRuntimeActivitySnapshot;
+    const { manifest, paths } = await loadManifestImpl(params.baseEnv, params.options.runId);
+    const activity = await resolveRuntimeActivitySnapshotImpl(manifest, paths);
+    if (params.options.format === 'json') {
+        process.stdout.write(`${JSON.stringify(buildOrchestratorStatusPayload(params.baseEnv, manifest, paths, activity), null, 2)}\n`);
+        return manifest;
+    }
+    renderOrchestratorStatus(manifest, activity);
+    return manifest;
+}

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

@@ -1,5 +1,5 @@
 import process from 'node:process';
-import { loadPackageConfig, loadUserConfig } from '../config/userConfig.js';
+import { loadPackageConfig, loadUserConfig, resolveRepoConfigPath } from '../config/userConfig.js';
 import { resolvePipeline } from '../pipelines/index.js';
 import { loadDesignConfig, shouldActivateDesignPipeline, designPipelineId } from '../../../../packages/shared/config/index.js';
 import { logger } from '../../logger.js';
@@ -45,9 +45,13 @@ export class PipelineResolver {
             this.logInfo(`[design-config] using defaults (missing file at ${designConfig.path})`, quiet);
         }
         const repoConfigRequired = isRepoConfigRequired(runtimeEnv);
-        const userConfig = await loadUserConfig(env, { allowPackageFallback: !repoConfigRequired, quiet });
+        const userConfig = await loadUserConfig(env, {
+            allowPackageFallback: !repoConfigRequired,
+            quiet,
+            processEnv: runtimeEnv
+        });
         if (repoConfigRequired && userConfig?.source !== 'repo') {
-            throw new Error(formatRepoConfigRequiredError(env.repoRoot));
+            throw new Error(formatRepoConfigRequiredError(resolveRepoConfigPath(env, runtimeEnv)));
         }
         let configNotice = null;
         if (userConfig?.source === 'package') {

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

@@ -0,0 +1,119 @@
+export const TASK_MEMORY_SOURCE0_REF_ID = 'source_0';
+const TASK_MEMORY_PROMPT_PACK_REF_PREFIX = 'prompt_pack:';
+function normalizeNonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function readPromptPackRefDomain(ref) {
+    return normalizeNonEmptyString(ref.domain)?.toLowerCase() ?? null;
+}
+function readSelectedMemoryRefArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((entry) => typeof entry === 'string')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+export function createPromptPackTaskMemoryRefId(packId) {
+    return `${TASK_MEMORY_PROMPT_PACK_REF_PREFIX}${packId}`;
+}
+export function readPromptPackIdFromTaskMemoryRefId(refId) {
+    if (!refId.startsWith(TASK_MEMORY_PROMPT_PACK_REF_PREFIX)) {
+        return null;
+    }
+    const packId = refId.slice(TASK_MEMORY_PROMPT_PACK_REF_PREFIX.length).trim();
+    return packId.length > 0 ? packId : null;
+}
+export function buildTaskMemoryContext(promptPacks) {
+    const refs = [
+        {
+            id: TASK_MEMORY_SOURCE0_REF_ID,
+            kind: 'source_0',
+            label: 'Shared source 0 anchor'
+        }
+    ];
+    for (const pack of promptPacks) {
+        const packId = normalizeNonEmptyString(pack.id);
+        const domain = normalizeNonEmptyString(pack.domain);
+        if (!packId || !domain || !Number.isInteger(pack.experienceSlots) || pack.experienceSlots <= 0) {
+            continue;
+        }
+        refs.push({
+            id: createPromptPackTaskMemoryRefId(packId),
+            kind: 'prompt_pack',
+            label: `Prompt pack ${packId}`,
+            domain,
+            packId,
+            experienceSlots: pack.experienceSlots
+        });
+    }
+    return { refs };
+}
+export function readSelectedMemoryRefs(target) {
+    const metadata = target.metadata ?? {};
+    return [
+        ...readSelectedMemoryRefArray(metadata.selectedMemoryRefs),
+        ...readSelectedMemoryRefArray(metadata.selected_memory_refs)
+    ].filter((value, index, entries) => entries.indexOf(value) === index);
+}
+function selectPromptPackTaskMemoryRef(params) {
+    const candidates = params.refs.filter((ref) => ref.kind === 'prompt_pack' && readPromptPackRefDomain(ref) !== null);
+    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((ref) => {
+        const domain = readPromptPackRefDomain(ref);
+        return domain !== null && domain !== 'implementation' && haystack.includes(domain);
+    });
+    if (directMatch) {
+        return directMatch;
+    }
+    const broadDirectMatch = candidates.find((ref) => {
+        const domain = readPromptPackRefDomain(ref);
+        return domain !== null && haystack.includes(domain);
+    });
+    if (broadDirectMatch) {
+        return broadDirectMatch;
+    }
+    const implementation = candidates.find((ref) => readPromptPackRefDomain(ref) === 'implementation');
+    if (implementation) {
+        return implementation;
+    }
+    return candidates[0] ?? null;
+}
+export function selectTaskMemoryRefs(params) {
+    const refs = params.task.memory?.refs ?? [];
+    if (refs.length === 0) {
+        return [];
+    }
+    const selected = [];
+    if (refs.some((ref) => ref.id === TASK_MEMORY_SOURCE0_REF_ID)) {
+        selected.push(TASK_MEMORY_SOURCE0_REF_ID);
+    }
+    const promptPackRef = selectPromptPackTaskMemoryRef({
+        refs,
+        pipeline: params.pipeline,
+        target: params.target,
+        stage: params.stage
+    });
+    if (promptPackRef && !selected.includes(promptPackRef.id)) {
+        selected.push(promptPackRef.id);
+    }
+    return selected;
+}