@kbediako/codex-orchestrator 0.1.0

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

@@ -0,0 +1,140 @@
+import { appendCommandError, finalizeStatus, updateCommandStatus } from '../run/manifest.js';
+import { isoTimestamp } from '../utils/time.js';
+import { normalizeErrorMessage } from '../../utils/errorMessage.js';
+export { normalizeErrorMessage };
+export async function finalizeCommandLifecycle(context, stageResult) {
+    const commandIndex = 0;
+    let commandEntry = context.manifest.commands[commandIndex];
+    const summarySnapshot = stageResult.summary;
+    let resultExitCode = extractExecMetadataField(stageResult.toolRecord, 'exitCode') ?? null;
+    if (summarySnapshot && summarySnapshot.exitCode !== undefined) {
+        resultExitCode = summarySnapshot.exitCode;
+    }
+    let resultSignal = extractExecMetadataField(stageResult.toolRecord, 'signal') ?? null;
+    if (summarySnapshot && summarySnapshot.signal !== undefined) {
+        resultSignal = summarySnapshot.signal;
+    }
+    if (stageResult.commandError && resultExitCode === null) {
+        resultExitCode = 1;
+    }
+    if (stageResult.commandError && commandEntry) {
+        commandEntry = await finalizeFailedCommandEntry({
+            env: context.env,
+            paths: context.paths,
+            manifest: context.manifest,
+            commandEntry,
+            commandIndex,
+            error: stageResult.commandError,
+            exitCode: resultExitCode,
+            signal: resultSignal,
+            toolRecord: stageResult.toolRecord,
+            summarySnapshot,
+            shellCommand: context.shellCommand
+        });
+    }
+    const runStatus = determineRunStatus(commandEntry);
+    context.manifest.summary = commandEntry?.summary ?? context.manifest.summary;
+    finalizeStatus(context.manifest, runStatus, commandEntry?.status === 'failed' ? 'exec-failed' : null);
+    return {
+        commandEntry,
+        runStatus,
+        exitCode: resultExitCode,
+        signal: resultSignal,
+        summarySnapshot,
+        toolRecord: stageResult.toolRecord,
+        commandError: stageResult.commandError
+    };
+}
+export async function finalizeFailedCommandEntry(params) {
+    const { env, paths, manifest, commandEntry, commandIndex, error, exitCode, signal, toolRecord, summarySnapshot, shellCommand } = params;
+    const failureSummary = buildFailureSummary(error, exitCode, signal);
+    const updatedEntry = updateCommandStatus(manifest, commandIndex, {
+        status: 'failed',
+        completed_at: commandEntry.completed_at ?? isoTimestamp(),
+        exit_code: exitCode,
+        summary: failureSummary
+    });
+    const errorDetails = buildCommandErrorDetails({
+        error,
+        exitCode,
+        signal,
+        toolRecord,
+        summarySnapshot,
+        shellCommand
+    });
+    const errorFile = await appendCommandError(env, paths, manifest, updatedEntry, 'command-execution-error', errorDetails);
+    return updateCommandStatus(manifest, commandIndex, {
+        error_file: errorFile
+    });
+}
+export function buildFailureSummary(error, exitCode, signal) {
+    const message = normalizeErrorMessage(error);
+    if (signal) {
+        return `Command failed with signal ${signal}${message ? `: ${message}` : ''}`;
+    }
+    if (exitCode !== null && exitCode !== undefined) {
+        return `Command failed with code ${exitCode}${message ? `: ${message}` : ''}`;
+    }
+    return message ? `Command failed: ${message}` : 'Command failed.';
+}
+export function buildCommandErrorDetails(params) {
+    const { error, exitCode, signal, toolRecord, summarySnapshot, shellCommand } = params;
+    const execMetadata = readExecMetadata(toolRecord);
+    const details = {
+        message: normalizeErrorMessage(error),
+        command: shellCommand
+    };
+    if (exitCode !== null && exitCode !== undefined) {
+        details.exit_code = exitCode;
+    }
+    if (signal) {
+        details.signal = signal;
+    }
+    const sandboxState = summarySnapshot?.sandboxState ?? toolRecord?.sandboxState ?? execMetadata?.sandboxState;
+    if (sandboxState) {
+        details.sandbox_state = sandboxState;
+    }
+    const correlationId = execMetadata?.correlationId ?? null;
+    if (correlationId) {
+        details.correlation_id = correlationId;
+    }
+    if (execMetadata?.sessionId) {
+        details.session_id = execMetadata.sessionId;
+    }
+    if (typeof execMetadata?.persisted === 'boolean') {
+        details.persisted = execMetadata.persisted;
+    }
+    if (toolRecord?.id) {
+        details.tool_run_id = toolRecord.id;
+    }
+    if (toolRecord?.status) {
+        details.status = toolRecord.status;
+    }
+    if (typeof toolRecord?.attemptCount === 'number') {
+        details.attempts = toolRecord.attemptCount;
+    }
+    else if (typeof toolRecord?.retryCount === 'number') {
+        details.attempts = toolRecord.retryCount + 1;
+    }
+    return details;
+}
+export function determineRunStatus(entry) {
+    if (!entry) {
+        return 'failed';
+    }
+    return entry.status === 'succeeded' ? 'succeeded' : 'failed';
+}
+export function readExecMetadata(record) {
+    if (!record?.metadata || typeof record.metadata !== 'object') {
+        return null;
+    }
+    const candidate = record.metadata.exec;
+    if (!candidate || typeof candidate !== 'object') {
+        return null;
+    }
+    return candidate;
+}
+export function extractExecMetadataField(record, field) {
+    const metadata = readExecMetadata(record);
+    return metadata ? metadata[field] : undefined;
+}

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

@@ -0,0 +1,62 @@
+import process from 'node:process';
+import { persistManifest } from '../run/manifestPersister.js';
+import { isoTimestamp } from '../utils/time.js';
+import { logger } from '../../logger.js';
+import { runLearningHarvester } from '../../learning/harvester.js';
+import { synthesizeScenario } from '../../learning/runner.js';
+import { runScenarioValidation } from '../../learning/validator.js';
+export async function maybeTriggerLearning(runContext, runStatus) {
+    const enabled = process.env.LEARNING_PIPELINE_ENABLED === '1';
+    if (!enabled) {
+        return;
+    }
+    const storageDir = process.env.LEARNING_SNAPSHOT_DIR;
+    if (runStatus !== 'succeeded') {
+        return;
+    }
+    try {
+        const harvester = await runLearningHarvester(runContext.manifest, {
+            repoRoot: runContext.env.repoRoot,
+            runsRoot: runContext.env.runsRoot,
+            manifestPath: runContext.paths.manifestPath,
+            taskId: runContext.env.taskId,
+            runId: runContext.manifest.run_id,
+            diffPath: null,
+            promptPath: null,
+            executionHistoryPath: runContext.paths.logPath,
+            storageDir,
+            alertTargets: { slack: '#learning-alerts', pagerduty: 'learning-pipeline' }
+        });
+        const scenario = await synthesizeScenario({
+            manifest: harvester.manifest,
+            taskId: runContext.env.taskId,
+            runId: runContext.manifest.run_id,
+            runsRoot: runContext.env.runsRoot,
+            prompt: null,
+            diff: null,
+            executionHistory: [
+                {
+                    command: runContext.shellCommand,
+                    exitCode: 0,
+                    cwd: runContext.stage.cwd ?? runContext.env.repoRoot,
+                    timestamp: isoTimestamp()
+                }
+            ],
+            alertTargets: { slack: '#learning-alerts', pagerduty: 'learning-pipeline' },
+            pagerDutySeverity: 'none'
+        });
+        const validation = await runScenarioValidation({
+            manifest: scenario.manifest,
+            repoRoot: runContext.env.repoRoot,
+            runsRoot: runContext.env.runsRoot,
+            taskId: runContext.env.taskId,
+            runId: runContext.manifest.run_id,
+            paths: runContext.paths,
+            scenarioPath: scenario.scenarioPath
+        });
+        await persistManifest(runContext.paths, validation.manifest, runContext.persister, { force: true });
+    }
+    catch (error) {
+        logger.warn(`[learning] auto-trigger failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

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

@@ -0,0 +1,71 @@
+import { runCommandStage } from '../services/commandRunner.js';
+import { serializeExecEvent } from '../../../../packages/shared/events/serializer.js';
+import { sanitizeToolRunRecord } from '../../../../packages/shared/manifest/writer.js';
+export async function runExecStage(context) {
+    let runResultSummary = null;
+    let toolRecord = null;
+    const hooks = {
+        onEvent: (event) => {
+            context.execEvents.push(event);
+            const serialized = serializeExecEvent(event);
+            context.telemetryTasks.push(Promise.resolve(context.telemetrySink.record(serialized)).then(() => undefined));
+            if (context.outputMode === 'jsonl' && context.jsonlWriter) {
+                context.jsonlWriter.write(serialized);
+            }
+            else if (context.outputMode === 'interactive') {
+                streamInteractive(context.stdout, context.stderr, event);
+            }
+        },
+        onResult: (result) => {
+            runResultSummary = {
+                correlationId: result.correlationId,
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode,
+                signal: result.signal,
+                durationMs: result.durationMs,
+                status: result.status,
+                sandboxState: result.sandboxState
+            };
+            toolRecord = sanitizeToolRunRecord(JSON.parse(JSON.stringify(result.record)));
+        },
+        onError: (error) => {
+            toolRecord = sanitizeToolRunRecord(JSON.parse(JSON.stringify(error.record)));
+        }
+    };
+    let commandError = null;
+    try {
+        await runCommandStage({
+            env: context.env,
+            paths: context.paths,
+            manifest: context.manifest,
+            stage: context.stage,
+            index: 1
+        }, hooks);
+    }
+    catch (error) {
+        commandError = error;
+    }
+    return {
+        summary: runResultSummary,
+        toolRecord,
+        commandError
+    };
+}
+export function streamInteractive(stdout, stderr, event) {
+    switch (event.type) {
+        case 'exec:chunk':
+            if (event.payload.stream === 'stdout') {
+                stdout.write(event.payload.data);
+            }
+            else {
+                stderr.write(event.payload.data);
+            }
+            break;
+        case 'exec:retry':
+            stderr.write(`[retry] attempt ${event.attempt} in ${event.payload.delayMs}ms — ${event.payload.errorMessage}\n`);
+            break;
+        default:
+            break;
+    }
+}

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

@@ -0,0 +1,109 @@
+import { join } from 'node:path';
+import { relativeToRepo } from '../run/runPaths.js';
+import { writeJsonAtomic } from '../utils/fs.js';
+import { persistManifest } from '../run/manifestPersister.js';
+import { readExecMetadata } from './finalization.js';
+export function createRunSummaryPayload(params) {
+    const { env, paths, manifest, runStatus, shellCommand, argv, resultSummary, toolRecord, execEvents, exitCode, signal, notificationTargets, cwd, metrics } = params;
+    const stdout = resultSummary?.stdout ?? '';
+    const stderr = resultSummary?.stderr ?? '';
+    const correlationId = resultSummary?.correlationId ?? execEvents[0]?.correlationId ?? manifest.run_id;
+    const attempts = typeof toolRecord?.attemptCount === 'number'
+        ? toolRecord.attemptCount
+        : (toolRecord?.retryCount ?? 0) + 1;
+    const execMetadata = readExecMetadata(toolRecord);
+    const sessionId = typeof execMetadata?.sessionId === 'string' ? execMetadata.sessionId : 'default';
+    const persisted = Boolean(execMetadata?.persisted);
+    const metadataSandbox = execMetadata?.sandboxState;
+    const sandboxState = resultSummary?.sandboxState ?? toolRecord?.sandboxState ?? metadataSandbox ?? 'sandboxed';
+    return {
+        status: runStatus === 'succeeded' ? 'succeeded' : 'failed',
+        run: {
+            id: manifest.run_id,
+            taskId: manifest.task_id,
+            pipelineId: manifest.pipeline_id,
+            manifest: relativeToRepo(env, paths.manifestPath),
+            artifactRoot: manifest.artifact_root,
+            summary: manifest.summary
+        },
+        result: {
+            exitCode,
+            signal,
+            durationMs: resultSummary?.durationMs ?? 0,
+            status: resultSummary?.status ?? (toolRecord?.status ?? 'failed'),
+            sandboxState,
+            correlationId,
+            attempts
+        },
+        command: {
+            argv,
+            shell: shellCommand,
+            cwd,
+            sessionId,
+            persisted
+        },
+        outputs: {
+            stdout,
+            stderr
+        },
+        logs: {
+            runner: relativeToRepo(env, paths.logPath),
+            command: manifest.commands[0]?.log_path ?? null
+        },
+        toolRun: toolRecord,
+        metrics: metrics ?? undefined,
+        notifications: {
+            targets: notificationTargets,
+            delivered: [],
+            failures: []
+        }
+    };
+}
+export function renderRunOutput(context, summaryPayload, summaryEvent) {
+    if (context.outputMode === 'jsonl' && context.jsonlWriter) {
+        context.jsonlWriter.write(summaryEvent);
+        return;
+    }
+    if (context.outputMode === 'json') {
+        const spacing = context.invocation.jsonPretty ? 2 : 0;
+        context.stdout.write(`${JSON.stringify(summaryEvent, null, spacing)}\n`);
+        return;
+    }
+    if (context.outputMode === 'interactive') {
+        context.stdout.write(`\n${summaryPayload.run.id} ${summaryPayload.status.toUpperCase()}\n`);
+        context.stdout.write(`Manifest: ${summaryPayload.run.manifest}\n`);
+        context.stdout.write(`Log: ${summaryPayload.logs.runner}\n`);
+    }
+}
+export async function persistRunOutputs(context, summaryEvent) {
+    const runSummaryPath = join(context.paths.runDir, 'run-summary.json');
+    await writeJsonAtomic(runSummaryPath, summaryEvent);
+    context.manifest.run_summary_path = relativeToRepo(context.env, runSummaryPath);
+    await persistManifest(context.paths, context.manifest, context.persister, { force: true });
+}
+export function emitCommandError(context, commandError) {
+    if (!commandError) {
+        return;
+    }
+    if (context.outputMode === 'jsonl' || context.outputMode === 'json') {
+        return;
+    }
+    context.stderr.write(`Command execution failed: ${commandError?.message ?? String(commandError)}\n`);
+}
+export function buildExecRunSummary(params) {
+    return {
+        runId: params.manifest.run_id,
+        manifestPath: params.summaryPayload.run.manifest,
+        logPath: params.summaryPayload.logs.runner,
+        status: params.summaryPayload.status,
+        exitCode: params.summaryPayload.result.exitCode,
+        signal: params.summaryPayload.result.signal,
+        stdout: params.summaryPayload.outputs.stdout,
+        stderr: params.summaryPayload.outputs.stderr,
+        shellCommand: params.shellCommand,
+        argv: params.argv,
+        events: params.events,
+        summaryEvent: params.summaryEvent,
+        toolRun: params.toolRecord ?? null
+    };
+}

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

@@ -0,0 +1,18 @@
+export async function deliverNotifications(context, summaryPayload, summaryEvent) {
+    const notificationOutcome = await context.notificationSink.notify(summaryEvent);
+    if (summaryPayload.notifications) {
+        summaryPayload.notifications.delivered = notificationOutcome.delivered;
+        summaryPayload.notifications.failures = notificationOutcome.failures;
+    }
+}
+export function recordSummaryTelemetry(context, summaryEvent) {
+    context.telemetryTasks.push(Promise.resolve(context.telemetrySink.recordSummary(summaryEvent)).then(() => undefined));
+}
+export async function flushTelemetry(context) {
+    await Promise.allSettled(context.telemetryTasks);
+    await context.telemetrySink.flush();
+}
+export async function shutdownSinks(context) {
+    await context.telemetrySink.shutdown();
+    await context.notificationSink.shutdown();
+}

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

@@ -0,0 +1,200 @@
+import { relativeToRepo } from '../run/runPaths.js';
+import { logger } from '../../logger.js';
+import { summarizeTrajectory, optimizeExperience, framesFromToolMetrics } from './experience.js';
+const COST_PER_TOKEN_USD = 0.000002;
+const DEFAULT_EXPERIENCE_WORD_LIMIT = 32;
+export function resolveTfgrpoContext(env = process.env) {
+    const epoch = parsePositiveInteger(env.TFGRPO_EPOCH);
+    const groupSize = parsePositiveInteger(env.TFGRPO_GROUP_SIZE);
+    const groupId = env.TFGRPO_GROUP_ID?.trim() || null;
+    return {
+        epoch,
+        groupId,
+        groupSize,
+        active: epoch !== null || groupSize !== null || groupId !== null
+    };
+}
+export function resolveExperiencePolicy(env = process.env) {
+    const configured = env.TFGRPO_EXPERIENCE_MAX_WORDS;
+    const parsed = configured ? Number.parseInt(configured, 10) : NaN;
+    const maxSummaryWords = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_EXPERIENCE_WORD_LIMIT;
+    return {
+        maxSummaryWords,
+        rewardFloor: 0
+    };
+}
+export function createToolMetricSnapshot(toolRecord, summary) {
+    if (!toolRecord && !summary) {
+        return null;
+    }
+    const stdout = summary?.stdout ?? '';
+    const tokens = estimateTokenCount(stdout);
+    const latencyMs = summary?.durationMs ?? deriveDurationFromEvents(toolRecord);
+    const costUsd = roundCurrency(tokens * COST_PER_TOKEN_USD);
+    const attempts = toolRecord?.attemptCount ?? 1;
+    const status = toolRecord?.status ?? summary?.status ?? 'failed';
+    const sandboxState = summary?.sandboxState ?? toolRecord?.sandboxState ?? 'sandboxed';
+    const toolName = toolRecord?.tool ?? 'cli:command';
+    return {
+        tool: toolName,
+        tokens,
+        costUsd,
+        latencyMs,
+        attempts,
+        status,
+        sandboxState
+    };
+}
+export function createRunMetricSummary(metrics, context) {
+    const toolCalls = metrics.length;
+    if (toolCalls === 0 && !context.active) {
+        return null;
+    }
+    const tokenTotal = metrics.reduce((sum, metric) => sum + metric.tokens, 0);
+    const costUsd = roundCurrency(metrics.reduce((sum, metric) => sum + metric.costUsd, 0));
+    const latencyMs = metrics.reduce((sum, metric) => sum + metric.latencyMs, 0);
+    return {
+        toolCalls,
+        tokenTotal,
+        costUsd,
+        latencyMs,
+        perTool: metrics,
+        tfgrpo: context.active
+            ? {
+                epoch: context.epoch,
+                groupSize: context.groupSize,
+                groupId: context.groupId
+            }
+            : undefined
+    };
+}
+export function mergeTfgrpoManifest(existing, metrics, context) {
+    if (!metrics && !existing && !context.active) {
+        return null;
+    }
+    const manifestMetrics = metrics
+        ? {
+            tool_calls: metrics.toolCalls,
+            token_total: metrics.tokenTotal,
+            cost_usd: metrics.costUsd,
+            latency_ms: metrics.latencyMs,
+            per_tool: metrics.perTool.map((entry) => ({
+                tool: entry.tool,
+                tokens: entry.tokens,
+                cost_usd: entry.costUsd,
+                latency_ms: entry.latencyMs,
+                attempts: entry.attempts,
+                status: entry.status,
+                sandbox_state: entry.sandboxState
+            }))
+        }
+        : existing?.tool_metrics;
+    return {
+        epoch: context.epoch ?? existing?.epoch ?? null,
+        group_id: context.groupId ?? existing?.group_id ?? null,
+        group_size: context.groupSize ?? existing?.group_size ?? null,
+        tool_metrics: manifestMetrics ?? existing?.tool_metrics,
+        experiences: existing?.experiences
+    };
+}
+export async function persistExperienceRecords(params) {
+    const { runMetrics } = params;
+    if (!runMetrics || runMetrics.perTool.length === 0) {
+        return null;
+    }
+    const promptPack = params.manifest.prompt_packs?.[0];
+    if (!promptPack?.domain || !promptPack.stamp) {
+        return null;
+    }
+    const terminalEvent = findTerminalEvent(params.execEvents);
+    if (!terminalEvent) {
+        return null;
+    }
+    try {
+        const frames = framesFromToolMetrics(runMetrics.perTool, terminalEvent);
+        const trajectory = summarizeTrajectory({
+            runId: params.manifest.run_id,
+            taskId: params.manifest.task_id,
+            epoch: params.tfgrpoContext.epoch,
+            groupId: params.tfgrpoContext.groupId,
+            domain: promptPack.domain,
+            stampSignature: promptPack.stamp,
+            frames,
+            baseSummary: params.manifest.summary ?? undefined
+        });
+        const optimized = optimizeExperience(trajectory, params.policy);
+        const manifestPath = relativeToRepo(params.env, params.paths.manifestPath);
+        const written = await params.store.recordBatch([optimized], manifestPath);
+        if (written.length > 0) {
+            const existing = params.manifest.tfgrpo?.experiences ?? {
+                ids: [],
+                written: 0,
+                manifest_path: manifestPath
+            };
+            const summary = {
+                ids: [...existing.ids, ...written.map((record) => record.id)],
+                written: existing.written + written.length,
+                manifest_path: manifestPath
+            };
+            params.manifest.tfgrpo = {
+                ...(params.manifest.tfgrpo ?? {
+                    epoch: params.tfgrpoContext.epoch,
+                    group_id: params.tfgrpoContext.groupId,
+                    group_size: params.tfgrpoContext.groupSize
+                }),
+                experiences: summary
+            };
+        }
+        return written;
+    }
+    catch (error) {
+        logger.warn(`Failed to persist TF-GRPO experience: ${String(error)}`);
+        return null;
+    }
+}
+function parsePositiveInteger(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        return null;
+    }
+    return parsed;
+}
+function deriveDurationFromEvents(record) {
+    const events = record?.events;
+    if (!Array.isArray(events) || events.length === 0) {
+        return 0;
+    }
+    const first = events.find((event) => event.type === 'exec:begin');
+    const last = [...events].reverse().find((event) => event.type === 'exec:end');
+    if (!first || !last) {
+        return 0;
+    }
+    const startedAt = Date.parse(first.timestamp);
+    const completedAt = Date.parse(last.timestamp);
+    if (Number.isNaN(startedAt) || Number.isNaN(completedAt) || completedAt < startedAt) {
+        return 0;
+    }
+    return completedAt - startedAt;
+}
+function estimateTokenCount(output) {
+    const trimmed = output.trim();
+    if (!trimmed) {
+        return 0;
+    }
+    return trimmed.split(/\s+/u).filter(Boolean).length;
+}
+function roundCurrency(value) {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}
+function findTerminalEvent(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const candidate = events[index];
+        if (candidate?.type === 'exec:end') {
+            return candidate;
+        }
+    }
+    return events.length > 0 ? events[events.length - 1] : null;
+}

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

@@ -0,0 +1,19 @@
+import { persistManifest } from '../run/manifestPersister.js';
+import { createRunMetricSummary, createToolMetricSnapshot, mergeTfgrpoManifest, persistExperienceRecords, resolveExperiencePolicy } from './tfgrpo.js';
+export async function handleTfgrpoArtifacts(context, finalization, tfgrpoContext) {
+    const toolMetric = createToolMetricSnapshot(finalization.toolRecord, finalization.summarySnapshot);
+    const runMetricSummary = createRunMetricSummary(toolMetric ? [toolMetric] : [], tfgrpoContext);
+    context.manifest.tfgrpo = mergeTfgrpoManifest(context.manifest.tfgrpo, runMetricSummary, tfgrpoContext);
+    await persistExperienceRecords({
+        store: context.experienceStore,
+        manifest: context.manifest,
+        env: context.env,
+        paths: context.paths,
+        tfgrpoContext,
+        runMetrics: runMetricSummary,
+        execEvents: context.execEvents,
+        policy: resolveExperiencePolicy()
+    });
+    await persistManifest(context.paths, context.manifest, context.persister, { force: true });
+    return runMetricSummary;
+}

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

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

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

@@ -0,0 +1,64 @@
+import { copyFile, mkdir, readdir, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { findPackageRoot } from './utils/packageInfo.js';
+export async function initCodexTemplates(options) {
+    const root = findPackageRoot();
+    const templateRoot = join(root, 'templates', options.template);
+    const written = [];
+    const skipped = [];
+    await assertDirectory(templateRoot);
+    await copyTemplateDir(templateRoot, options.cwd, {
+        force: options.force,
+        written,
+        skipped
+    });
+    return { written, skipped, templateRoot };
+}
+async function assertDirectory(path) {
+    const info = await stat(path).catch(() => null);
+    if (!info || !info.isDirectory()) {
+        throw new Error(`Template directory not found: ${path}`);
+    }
+}
+async function copyTemplateDir(sourceDir, targetDir, options) {
+    await mkdir(targetDir, { recursive: true });
+    const entries = await readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourcePath = join(sourceDir, entry.name);
+        const targetPath = join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyTemplateDir(sourcePath, targetPath, options);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        if (existsSync(targetPath) && !options.force) {
+            options.skipped.push(targetPath);
+            continue;
+        }
+        await mkdir(dirname(targetPath), { recursive: true });
+        await copyFile(sourcePath, targetPath);
+        options.written.push(targetPath);
+    }
+}
+export function formatInitSummary(result, cwd) {
+    const lines = [];
+    if (result.written.length > 0) {
+        lines.push('Written:');
+        for (const filePath of result.written) {
+            lines.push(`  - ${relative(cwd, filePath)}`);
+        }
+    }
+    if (result.skipped.length > 0) {
+        lines.push('Skipped (already exists):');
+        for (const filePath of result.skipped) {
+            lines.push(`  - ${relative(cwd, filePath)}`);
+        }
+    }
+    if (lines.length === 0) {
+        lines.push('No files written.');
+    }
+    return lines;
+}