@kbediako/codex-orchestrator 0.1.0

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

@@ -0,0 +1,82 @@
+import process from 'node:process';
+import { CommandPlanner } from '../adapters/index.js';
+import { PipelineResolver } from './pipelineResolver.js';
+import { sanitizeTaskId } from '../run/environment.js';
+import { loadTaskMetadata } from '../tasks/taskMetadata.js';
+import { resolvePipeline } from '../pipelines/index.js';
+import { findPipeline } from '../config/userConfig.js';
+import { logger } from '../../logger.js';
+export function overrideTaskEnvironment(baseEnv, taskId) {
+    if (!taskId) {
+        return { ...baseEnv };
+    }
+    const sanitized = sanitizeTaskId(taskId);
+    return { ...baseEnv, taskId: sanitized };
+}
+export function resolveTargetStageId(explicit, fallback, envTarget = process.env.CODEX_ORCHESTRATOR_TARGET_STAGE) {
+    const normalizedExplicit = explicit?.trim();
+    if (normalizedExplicit) {
+        return normalizedExplicit;
+    }
+    const normalizedFallback = fallback?.trim();
+    if (normalizedFallback) {
+        return normalizedFallback;
+    }
+    if (typeof envTarget === 'string' && envTarget.trim().length > 0) {
+        return envTarget.trim();
+    }
+    return null;
+}
+export async function prepareRun(options) {
+    logger.info(`prepareRun start for pipeline ${options.pipelineId ?? options.pipeline?.id ?? '<default>'}`);
+    const env = overrideTaskEnvironment(options.baseEnv, options.taskIdOverride);
+    const resolver = options.resolver ?? new PipelineResolver();
+    logger.info(`prepareRun resolving pipeline ${options.pipelineId ?? '<default>'}`);
+    const resolvedPipeline = options.pipeline
+        ? {
+            pipeline: options.pipeline,
+            source: options.pipelineSource ?? null,
+            envOverrides: options.envOverrides ?? {}
+        }
+        : await resolver.resolve(env, { pipelineId: options.pipelineId });
+    logger.info(`prepareRun resolved pipeline ${resolvedPipeline.pipeline.id}`);
+    const metadata = await loadTaskMetadata(env);
+    logger.info(`prepareRun loaded metadata for task ${metadata.id}`);
+    const taskContext = createTaskContext(metadata);
+    const targetId = resolveTargetStageId(options.targetStageId, options.planTargetFallback ?? null);
+    const planner = options.planner ?? new CommandPlanner(resolvedPipeline.pipeline, { targetStageId: targetId });
+    logger.info(`prepareRun running planner for pipeline ${resolvedPipeline.pipeline.id}`);
+    const planPreview = await planner.plan(taskContext);
+    logger.info(`prepareRun planner completed for pipeline ${resolvedPipeline.pipeline.id}`);
+    logger.info(`prepareRun complete for pipeline ${resolvedPipeline.pipeline.id}`);
+    return {
+        env,
+        pipeline: resolvedPipeline.pipeline,
+        pipelineSource: resolvedPipeline.source ?? null,
+        envOverrides: resolvedPipeline.envOverrides ?? {},
+        planner,
+        plannerTargetId: planPreview?.targetId ?? targetId,
+        taskContext,
+        metadata,
+        resolver,
+        planPreview
+    };
+}
+export function resolvePipelineForResume(env, manifest, config) {
+    const existing = findPipeline(config ?? null, manifest.pipeline_id);
+    if (existing) {
+        return existing;
+    }
+    const { pipeline } = resolvePipeline(env, { pipelineId: manifest.pipeline_id, config });
+    return pipeline;
+}
+export function createTaskContext(metadata) {
+    return {
+        id: metadata.id,
+        title: metadata.title,
+        description: undefined,
+        metadata: {
+            slug: metadata.slug
+        }
+    };
+}

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

@@ -0,0 +1,35 @@
+import { join } from 'node:path';
+import { relativeToRepo } from '../run/runPaths.js';
+import { writeJsonAtomic } from '../utils/fs.js';
+import { persistManifest } from '../run/manifestPersister.js';
+export function applyHandlesToRunSummary(runSummary, manifest) {
+    if (!manifest.handles || manifest.handles.length === 0) {
+        return;
+    }
+    runSummary.handles = manifest.handles.map((handle) => ({
+        handleId: handle.handle_id,
+        correlationId: handle.correlation_id,
+        stageId: handle.stage_id,
+        status: handle.status,
+        frameCount: handle.frame_count,
+        latestSequence: handle.latest_sequence
+    }));
+}
+export function applyPrivacyToRunSummary(runSummary, manifest) {
+    if (!manifest.privacy) {
+        return;
+    }
+    runSummary.privacy = {
+        mode: manifest.privacy.mode,
+        totalFrames: manifest.privacy.totals.total_frames,
+        redactedFrames: manifest.privacy.totals.redacted_frames,
+        blockedFrames: manifest.privacy.totals.blocked_frames,
+        allowedFrames: manifest.privacy.totals.allowed_frames
+    };
+}
+export async function persistRunSummary(env, paths, manifest, runSummary, persister) {
+    const summaryPath = join(paths.runDir, 'run-summary.json');
+    await writeJsonAtomic(summaryPath, runSummary);
+    manifest.run_summary_path = relativeToRepo(env, summaryPath);
+    await persistManifest(paths, manifest, persister, { force: true });
+}

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

@@ -0,0 +1,42 @@
+import { sanitizeTaskId } from '../run/environment.js';
+import { persistManifest } from '../run/manifestPersister.js';
+import { buildSchedulerRunSummary, createSchedulerPlan, finalizeSchedulerPlan, serializeSchedulerPlan } from '../../scheduler/index.js';
+import { isoTimestamp } from '../utils/time.js';
+export class SchedulerService {
+    now;
+    constructor(now = () => new Date()) {
+        this.now = now;
+    }
+    async createPlanForRun(options) {
+        const plan = createSchedulerPlan(options.controlPlaneResult.request, {
+            now: this.now,
+            instancePrefix: sanitizeTaskId(options.env.taskId)
+        });
+        this.attachSchedulerPlanToManifest(options.manifest, plan);
+        await persistManifest(options.paths, options.manifest, options.persister, { force: true });
+        return plan;
+    }
+    async finalizePlan(options) {
+        const finalStatus = this.resolveSchedulerFinalStatus(options.manifest.status);
+        const finalizedAt = options.manifest.completed_at ?? isoTimestamp();
+        finalizeSchedulerPlan(options.plan, finalStatus, finalizedAt);
+        this.attachSchedulerPlanToManifest(options.manifest, options.plan);
+        await persistManifest(options.paths, options.manifest, options.persister, { force: true });
+    }
+    applySchedulerToRunSummary(runSummary, plan) {
+        runSummary.scheduler = buildSchedulerRunSummary(plan);
+    }
+    resolveSchedulerFinalStatus(status) {
+        switch (status) {
+            case 'succeeded':
+                return 'succeeded';
+            case 'in_progress':
+                return 'running';
+            default:
+                return 'failed';
+        }
+    }
+    attachSchedulerPlanToManifest(manifest, plan) {
+        manifest.scheduler = serializeSchedulerPlan(plan);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function loadTaskMetadata(env) {
+    const tasksPath = join(env.repoRoot, 'tasks', 'index.json');
+    try {
+        const raw = await readFile(tasksPath, 'utf8');
+        const data = JSON.parse(raw);
+        const match = data.items.find((item) => item.id === env.taskId);
+        if (match) {
+            return { id: match.id, slug: match.slug, title: match.title };
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    return { id: env.taskId, slug: env.taskId, title: `Task ${env.taskId}` };
+}

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

@@ -0,0 +1,8 @@
+import { getManifestSchema, validateManifest } from '../../../../packages/shared/manifest/validator.js';
+export const CLI_MANIFEST_SCHEMA = getManifestSchema();
+export function getTelemetrySchemas() {
+    return { manifest: CLI_MANIFEST_SCHEMA };
+}
+export function validateCliManifest(candidate) {
+    return validateManifest(candidate);
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,112 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { Box, Text } from 'ink';
+import { createInitialHudState } from './store.js';
+export function HudApp({ store, footerNote }) {
+    const [state, setState] = useState(store.getState());
+    const [tick, setTick] = useState(() => Date.now());
+    useEffect(() => {
+        const unsubscribe = store.subscribe(setState);
+        return () => unsubscribe();
+    }, [store]);
+    useEffect(() => {
+        const timer = setInterval(() => setTick(Date.now()), 1000);
+        return () => clearInterval(timer);
+    }, []);
+    const elapsed = useMemo(() => formatElapsed(state.startedAt, state.completedAt, tick), [state.startedAt, state.completedAt, tick]);
+    if (state.status === 'idle' && !state.runId) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "codex-orchestrator HUD" }), _jsx(Text, { color: "gray", children: "Awaiting run events..." })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { state: state, elapsed: elapsed }), _jsx(Text, { children: " " }), _jsx(StageList, { stages: state.stages }), _jsx(Text, { children: " " }), _jsx(LogPanel, { logs: state.logs }), _jsx(Text, { children: " " }), _jsx(Footer, { manifestPath: state.manifestPath, metricsPath: state.metricsPath, runSummaryPath: state.runSummaryPath, note: footerNote })] }));
+}
+function Header({ state, elapsed }) {
+    const statusColor = colorForStatus(state.status);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["HUD | TASK ", state.taskId ?? '-', " | RUN ", state.runId ?? '-', " | STATUS", ' ', _jsxs(Text, { color: statusColor, children: ["[", state.status.toUpperCase(), "]"] }), " | ELAPSED ", elapsed] }), _jsxs(Text, { color: "gray", children: [state.pipelineTitle ?? 'pipeline', " | manifest: ", state.manifestPath ?? 'pending', " | log: ", state.logPath ?? 'pending'] })] }));
+}
+function StageList({ stages }) {
+    if (!stages || stages.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { color: "gray", children: "No stage metadata available yet." }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", children: "Stages" }), stages.map((stage) => (_jsx(StageRow, { stage: stage }, stage.id)))] }));
+}
+function StageRow({ stage }) {
+    const statusColor = colorForStatus(stage.status);
+    const label = stage.title || stage.id;
+    const summary = stage.summary ?? stage.logPath ?? '';
+    return (_jsxs(Text, { children: ["[", String(stage.index).padStart(2, '0'), "] ", _jsx(Text, { color: statusColor, children: stage.status.toUpperCase() }), " ", label, summary ? ` - ${summary}` : ''] }));
+}
+function LogPanel({ logs }) {
+    const tail = logs.slice(-8);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "cyan", children: ["Log Tail (latest ", tail.length, ")"] }), tail.length === 0 ? (_jsx(Text, { color: "gray", children: "No logs yet." })) : (tail.map((log) => (_jsxs(Text, { color: colorForLevel(log.level), children: [formatClock(log.timestamp), " ", log.stageId ? `[${log.stageId}] ` : '', log.message.trim()] }, log.id))))] }));
+}
+function Footer({ manifestPath, metricsPath, runSummaryPath, note }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "gray", children: ["read-only HUD | manifest: ", manifestPath ?? 'pending', " | metrics: ", metricsPath ?? 'pending', " | summary:", ' ', runSummaryPath ?? 'pending'] }), note ? _jsx(Text, { color: "gray", children: note }) : null] }));
+}
+function colorForStatus(status) {
+    switch (status) {
+        case 'running':
+        case 'in_progress':
+            return 'cyan';
+        case 'succeeded':
+            return 'green';
+        case 'skipped':
+            return 'yellow';
+        case 'failed':
+        case 'cancelled':
+            return 'red';
+        case 'pending':
+            return 'gray';
+        default:
+            return undefined;
+    }
+}
+function colorForLevel(level) {
+    switch (level) {
+        case 'warn':
+            return 'yellow';
+        case 'error':
+            return 'red';
+        case 'debug':
+            return 'gray';
+        default:
+            return undefined;
+    }
+}
+function formatElapsed(start, end, nowMs) {
+    if (!start) {
+        return '--:--';
+    }
+    const startMs = Date.parse(start);
+    const endMs = end ? Date.parse(end) : nowMs;
+    if (Number.isNaN(startMs) || Number.isNaN(endMs)) {
+        return '--:--';
+    }
+    const totalSeconds = Math.max(0, Math.floor((endMs - startMs) / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    const hours = Math.floor(minutes / 60);
+    const minsRemaining = minutes % 60;
+    if (hours > 0) {
+        return `${String(hours).padStart(2, '0')}:${String(minsRemaining).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+    }
+    return `${String(minsRemaining).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+}
+function formatClock(timestamp) {
+    const parsed = Date.parse(timestamp);
+    if (Number.isNaN(parsed)) {
+        return '--:--:--';
+    }
+    const date = new Date(parsed);
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${hours}:${minutes}:${seconds}`;
+}
+// Exported for tests
+export const __private = {
+    formatElapsed,
+    formatClock,
+    colorForStatus,
+    colorForLevel,
+    createInitialHudState
+};

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

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { HudApp } from './HudApp.js';
+import { HudStore } from './store.js';
+export function startHud(options) {
+    const store = new HudStore({
+        logLimit: options.logLimit,
+        batchIntervalMs: options.batchIntervalMs
+    });
+    const unsubscribe = options.emitter.on('*', (event) => {
+        store.enqueue(event);
+    });
+    const ink = render(_jsx(HudApp, { store: store, footerNote: options.footerNote }));
+    let stopped = false;
+    return {
+        store,
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            unsubscribe();
+            store.dispose();
+            ink.unmount();
+        }
+    };
+}

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

@@ -0,0 +1,240 @@
+const DEFAULT_LOG_LIMIT = 200;
+const DEFAULT_BATCH_INTERVAL_MS = 120;
+export function createInitialHudState() {
+    return {
+        runId: null,
+        taskId: null,
+        pipelineTitle: null,
+        status: 'idle',
+        manifestPath: null,
+        runSummaryPath: null,
+        metricsPath: null,
+        logPath: null,
+        stages: [],
+        logs: [],
+        startedAt: null,
+        completedAt: null,
+        lastUpdated: null
+    };
+}
+export function reduceHudState(state, event, logLimit = DEFAULT_LOG_LIMIT) {
+    switch (event.type) {
+        case 'run:started':
+            return applyRunStarted(state, event);
+        case 'stage:started':
+            return applyStageStarted(state, event);
+        case 'stage:completed':
+            return applyStageCompleted(state, event);
+        case 'run:completed':
+            return {
+                ...state,
+                status: event.status,
+                manifestPath: event.manifestPath,
+                runSummaryPath: event.runSummaryPath,
+                metricsPath: event.metricsPath,
+                completedAt: event.timestamp,
+                lastUpdated: event.timestamp
+            };
+        case 'run:error': {
+            const status = state.status === 'succeeded' ? state.status : 'failed';
+            return appendLogEntry({
+                ...state,
+                status,
+                lastUpdated: event.timestamp
+            }, {
+                id: buildLogId(state),
+                message: event.message,
+                level: 'error',
+                stageId: event.stageId ?? null,
+                timestamp: event.timestamp
+            }, logLimit);
+        }
+        case 'log':
+            return appendLogEntry(state, {
+                id: buildLogId(state),
+                message: event.message,
+                level: event.level,
+                stageId: event.stageId,
+                stageIndex: event.stageIndex ?? null,
+                timestamp: event.timestamp
+            }, logLimit);
+        case 'tool:call':
+            return appendLogEntry(state, {
+                id: buildLogId(state),
+                message: formatToolCall(event),
+                level: 'info',
+                stageId: event.stageId,
+                stageIndex: event.stageIndex ?? null,
+                timestamp: event.timestamp
+            }, logLimit);
+        default:
+            return state;
+    }
+}
+export class HudStore {
+    state = createInitialHudState();
+    logLimit;
+    batchIntervalMs;
+    listeners = new Set();
+    pendingEvents = [];
+    batchTimer = null;
+    constructor(options = {}) {
+        this.logLimit = options.logLimit ?? DEFAULT_LOG_LIMIT;
+        this.batchIntervalMs = options.batchIntervalMs ?? DEFAULT_BATCH_INTERVAL_MS;
+    }
+    getState() {
+        return this.state;
+    }
+    enqueue(event) {
+        this.pendingEvents.push(event);
+        this.scheduleFlush();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        listener(this.state);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    dispose() {
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
+        this.listeners.clear();
+        this.pendingEvents = [];
+    }
+    scheduleFlush() {
+        if (this.batchTimer) {
+            return;
+        }
+        this.batchTimer = setTimeout(() => {
+            this.batchTimer = null;
+            this.flush();
+        }, this.batchIntervalMs);
+    }
+    flush() {
+        if (this.pendingEvents.length === 0) {
+            return;
+        }
+        const events = this.pendingEvents;
+        this.pendingEvents = [];
+        let nextState = this.state;
+        for (const event of events) {
+            nextState = reduceHudState(nextState, event, this.logLimit);
+        }
+        this.state = nextState;
+        for (const listener of this.listeners) {
+            listener(this.state);
+        }
+    }
+}
+function applyRunStarted(state, event) {
+    const stages = event.stages
+        .slice()
+        .sort((a, b) => a.index - b.index)
+        .map((stage) => ({
+        id: stage.id,
+        index: stage.index,
+        title: stage.title,
+        kind: stage.kind,
+        status: stage.status,
+        summary: stage.summary,
+        exitCode: stage.exitCode,
+        logPath: stage.logPath,
+        subRunId: stage.subRunId,
+        startedAt: stage.status === 'running' ? event.timestamp : null,
+        completedAt: ['succeeded', 'failed', 'skipped'].includes(stage.status) ? event.timestamp : null
+    }));
+    return {
+        ...state,
+        runId: event.runId,
+        taskId: event.taskId,
+        pipelineTitle: event.pipelineTitle,
+        status: event.status,
+        manifestPath: event.manifestPath,
+        logPath: event.logPath,
+        stages,
+        startedAt: event.timestamp,
+        completedAt: null,
+        lastUpdated: event.timestamp
+    };
+}
+function applyStageStarted(state, event) {
+    const stages = updateStages(state.stages, {
+        id: event.stageId,
+        index: event.stageIndex,
+        title: event.title,
+        kind: event.kind,
+        status: 'running',
+        summary: null,
+        exitCode: null,
+        logPath: event.logPath ?? null,
+        startedAt: event.timestamp
+    });
+    return {
+        ...state,
+        stages,
+        status: state.status === 'idle' ? 'in_progress' : state.status,
+        lastUpdated: event.timestamp
+    };
+}
+function applyStageCompleted(state, event) {
+    const stages = updateStages(state.stages, {
+        id: event.stageId,
+        index: event.stageIndex,
+        title: event.title,
+        kind: event.kind,
+        status: event.status,
+        summary: event.summary,
+        exitCode: event.exitCode,
+        logPath: event.logPath ?? null,
+        completedAt: event.timestamp,
+        subRunId: event.subRunId
+    });
+    return {
+        ...state,
+        stages,
+        lastUpdated: event.timestamp
+    };
+}
+function updateStages(stages, update) {
+    const existingIndex = stages.findIndex((stage) => stage.id === update.id);
+    if (existingIndex >= 0) {
+        const next = stages.slice();
+        next[existingIndex] = {
+            ...next[existingIndex],
+            ...update
+        };
+        return next.sort((a, b) => a.index - b.index);
+    }
+    const summary = 'summary' in update ? update.summary ?? null : null;
+    const exitCode = 'exitCode' in update ? update.exitCode ?? null : null;
+    const logPath = 'logPath' in update ? update.logPath ?? null : null;
+    return [
+        ...stages,
+        {
+            ...update,
+            status: update.status ?? 'pending',
+            summary,
+            exitCode,
+            logPath
+        }
+    ].sort((a, b) => a.index - b.index);
+}
+function appendLogEntry(state, entry, limit) {
+    const nextLogs = [...state.logs, entry];
+    if (nextLogs.length > limit) {
+        nextLogs.splice(0, nextLogs.length - limit);
+    }
+    return { ...state, logs: nextLogs, lastUpdated: entry.timestamp };
+}
+function buildLogId(state) {
+    return `${state.logs.length + 1}`;
+}
+function formatToolCall(event) {
+    const stageFragment = event.stageId ? ` [${event.stageId}]` : '';
+    const attempt = typeof event.attempt === 'number' ? ` attempt ${event.attempt}` : '';
+    const message = event.message ? ` - ${event.message}` : '';
+    return `${event.toolName}${stageFragment}: ${event.status}${attempt}${message}`;
+}

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

@@ -0,0 +1,12 @@
+const TRUTHY_ENFORCE_VALUES = ['1', 'true', 'enforce', 'on', 'yes'];
+export function resolveEnforcementMode(explicit, enforce) {
+    const candidate = (explicit ?? null) ?? (enforce ?? null);
+    if (!candidate) {
+        return 'shadow';
+    }
+    const normalized = candidate.trim().toLowerCase();
+    if (TRUTHY_ENFORCE_VALUES.includes(normalized)) {
+        return 'enforce';
+    }
+    return 'shadow';
+}

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

@@ -0,0 +1,8 @@
+import { writeAtomicFile as writeAtomicFileInternal } from '../../utils/atomicWrite.js';
+export async function writeJsonAtomic(targetPath, data) {
+    const payload = `${JSON.stringify(data, null, 2)}\n`;
+    await writeFileAtomic(targetPath, payload);
+}
+export async function writeFileAtomic(targetPath, contents) {
+    await writeAtomicFileInternal(targetPath, contents, { ensureDir: true, encoding: 'utf8' });
+}

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

@@ -0,0 +1,25 @@
+import process from 'node:process';
+import { EnvUtils } from '../../../../packages/shared/config/index.js';
+export function evaluateInteractiveGate(options) {
+    const { requested, disabled = false, format, stdoutIsTTY = process.stdout.isTTY === true, stderrIsTTY = process.stderr.isTTY === true, term = process.env.TERM ?? null, env = process.env } = options;
+    if (!requested) {
+        return { enabled: false, reason: 'not requested' };
+    }
+    if (disabled) {
+        return { enabled: false, reason: 'flagged off' };
+    }
+    if (format === 'json') {
+        return { enabled: false, reason: 'json format requested' };
+    }
+    if (!stdoutIsTTY || !stderrIsTTY) {
+        return { enabled: false, reason: 'non-tty output streams' };
+    }
+    if ((term ?? '').toLowerCase() === 'dumb') {
+        return { enabled: false, reason: 'TERM=dumb' };
+    }
+    const ci = env.CI ?? '';
+    if (ci && EnvUtils.isTrue(ci)) {
+        return { enabled: false, reason: 'CI detected' };
+    }
+    return { enabled: true, reason: null };
+}

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

@@ -0,0 +1,10 @@
+export class JsonlWriter {
+    stream;
+    constructor(stream = process.stdout) {
+        this.stream = stream;
+    }
+    write(event) {
+        const payload = `${JSON.stringify(event)}\n`;
+        this.stream.write(payload);
+    }
+}

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

@@ -0,0 +1,30 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+export function resolveOptionalDependency(specifier, cwd = process.cwd()) {
+    const cwdPackage = join(cwd, 'package.json');
+    if (existsSync(cwdPackage)) {
+        try {
+            const cwdRequire = createRequire(cwdPackage);
+            return { path: cwdRequire.resolve(specifier), source: 'cwd' };
+        }
+        catch {
+            // ignore and fall back
+        }
+    }
+    try {
+        const selfRequire = createRequire(import.meta.url);
+        return { path: selfRequire.resolve(specifier), source: 'package' };
+    }
+    catch {
+        return { path: null, source: null };
+    }
+}
+export async function importOptionalDependency(specifier, cwd) {
+    const resolved = resolveOptionalDependency(specifier, cwd);
+    if (!resolved.path) {
+        throw new Error(`Missing optional dependency: ${specifier}`);
+    }
+    return (await import(pathToFileURL(resolved.path).href));
+}