ralph-research 0.1.0

package/dist/core/engine/cycle-runner.js

@@ -0,0 +1,652 @@
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, extname, join, resolve } from "node:path";
+import { evaluateAnchorAgreement, applyAnchorAgreementGate, loadAnchorRecords } from "./anchor-checker.js";
+import { sampleAuditQueue } from "./audit-sampler.js";
+import { evaluateChangeBudget } from "./change-budget.js";
+import { compactRecentHistory, countConsecutiveAutoAccepts } from "./history-compactor.js";
+import { runExperiment } from "./experiment-runner.js";
+import { runLlmJudgeMetric } from "./judge-pack.js";
+import { runParallelProposers } from "./parallel-proposer.js";
+import { extractCommandMetric } from "../../adapters/extractor/command-extractor.js";
+import { runCommandProposer } from "../../adapters/proposer/command-proposer.js";
+import { evaluateConstraints } from "../state/constraint-engine.js";
+import { updateParetoFrontier, updateSingleBestFrontier } from "../state/frontier-engine.js";
+import { evaluateRatchet } from "../state/ratchet-engine.js";
+import { advanceRunPhase } from "../state/run-state-machine.js";
+export async function runCycle(input, dependencies) {
+    const now = dependencies.now ?? (() => new Date());
+    const context = await createRunContext(input.repoRoot, input.manifest, dependencies.runStore, now);
+    const manifestDir = dirname(input.manifestPath);
+    const referenceMetric = getReferenceMetric(input.manifest);
+    const priorRuns = await dependencies.runStore.list();
+    const priorDecisions = await dependencies.decisionStore.list();
+    const priorConsecutiveAccepts = countConsecutiveAutoAccepts(priorDecisions, {
+        metricId: "metric" in input.manifest.ratchet ? input.manifest.ratchet.metric ?? referenceMetric : referenceMetric,
+    });
+    let runRecord = createInitialRunRecord(input.manifest, undefined, context);
+    await dependencies.runStore.put(runRecord);
+    let frontier = input.currentFrontier;
+    try {
+        const proposerHistory = await buildProposerHistoryContext({
+            manifest: input.manifest,
+            runDir: context.runDir,
+            runs: priorRuns,
+            decisions: priorDecisions,
+            primaryMetric: referenceMetric,
+        });
+        const selectedCandidate = await prepareCandidateAttempt({
+            repoRoot: input.repoRoot,
+            manifestDir,
+            manifest: input.manifest,
+            runDir: context.runDir,
+            workspaceManager: dependencies.workspaceManager,
+            currentFrontier: frontier,
+            baseCandidateId: context.candidateId,
+            referenceMetric,
+            ...(proposerHistory ? { historyContext: proposerHistory } : {}),
+            ...(dependencies.judgeProvider ? { judgeProvider: dependencies.judgeProvider } : {}),
+        });
+        runRecord = {
+            ...runRecord,
+            candidateId: selectedCandidate.candidateId,
+            workspacePath: selectedCandidate.workspacePath,
+            proposal: {
+                ...runRecord.proposal,
+                proposerType: input.manifest.proposer.type,
+                summary: selectedCandidate.summary,
+                operators: selectedCandidate.operators,
+            },
+            logs: {
+                ...runRecord.logs,
+                proposeStdoutPath: selectedCandidate.proposeStdoutPath,
+                runStdoutPath: selectedCandidate.runStdoutPath,
+            },
+        };
+        runRecord = advanceRunPhase(runRecord, "executed");
+        await dependencies.runStore.put(runRecord);
+        let ratchetDecision = resolveDecision({
+            manifest: input.manifest,
+            metrics: selectedCandidate.metrics,
+            currentFrontier: frontier,
+            constraints: selectedCandidate.constraints,
+            changeBudget: selectedCandidate.changeBudget,
+            priorConsecutiveAccepts,
+        });
+        let anchorCheck;
+        if (ratchetDecision.outcome === "accepted") {
+            anchorCheck = selectedCandidate.anchorChecks.get(ratchetDecision.metricId);
+            if (anchorCheck) {
+                const gated = applyAnchorAgreementGate(ratchetDecision.outcome, anchorCheck);
+                ratchetDecision = {
+                    ...ratchetDecision,
+                    outcome: gated.outcome,
+                    frontierChanged: gated.outcome === "accepted",
+                    reason: `${ratchetDecision.reason}; ${gated.reason}`,
+                };
+            }
+        }
+        runRecord = advanceRunPhase({
+            ...runRecord,
+            proposal: {
+                ...runRecord.proposal,
+                diffLines: selectedCandidate.changeBudget.summary.totalLineDelta,
+                filesChanged: selectedCandidate.changeBudget.summary.filesChanged,
+                changedPaths: selectedCandidate.changeBudget.summary.entries.map((entry) => entry.path),
+                withinBudget: selectedCandidate.changeBudget.withinBudget,
+            },
+            metrics: selectedCandidate.metrics,
+            constraints: selectedCandidate.constraints.results.map(stripConstraintReason),
+            artifacts: selectedCandidate.artifacts,
+        }, "evaluated", {
+            status: ratchetDecision.outcome,
+        });
+        await dependencies.runStore.put(runRecord);
+        const decisionId = `decision-${context.runId}`;
+        const candidateFrontierEntry = buildFrontierEntry(context.runId, selectedCandidate.candidateId, now, selectedCandidate.metrics, selectedCandidate.artifacts);
+        const frontierUpdate = ratchetDecision.outcome === "accepted"
+            ? updateFrontier(input.manifest, frontier, candidateFrontierEntry)
+            : null;
+        let decisionRecord = {
+            decisionId,
+            runId: context.runId,
+            outcome: ratchetDecision.outcome,
+            actorType: "system",
+            policyType: ratchetDecision.policyType,
+            metricId: ratchetDecision.metricId,
+            ...(ratchetDecision.delta === undefined ? {} : { delta: ratchetDecision.delta }),
+            reason: ratchetDecision.reason,
+            createdAt: now().toISOString(),
+            frontierChanged: frontierUpdate?.comparison.frontierChanged ?? false,
+            beforeFrontierIds: frontier.map((entry) => entry.frontierId),
+            afterFrontierIds: (frontierUpdate?.entries ?? frontier).map((entry) => entry.frontierId),
+            auditRequired: false,
+            ...(ratchetDecision.graduation ? { graduation: ratchetDecision.graduation } : {}),
+        };
+        let auditQueue = buildAuditQueue(ratchetDecision.metricId, decisionRecord, input.manifest, selectedCandidate.packByMetricId);
+        decisionRecord = {
+            ...decisionRecord,
+            auditRequired: auditQueue.length > 0,
+        };
+        await dependencies.decisionStore.put(decisionRecord);
+        runRecord = advanceRunPhase(runRecord, "decision_written", {
+            status: ratchetDecision.outcome,
+            decisionId,
+        });
+        await dependencies.runStore.put(runRecord);
+        if (ratchetDecision.outcome === "accepted" && frontierUpdate) {
+            const promoted = await dependencies.workspaceManager.promoteWorkspace(selectedCandidate.candidateId, {
+                excludePaths: input.manifest.experiment.outputs.map((output) => output.path),
+            });
+            const commitResult = await dependencies.gitClient.stageAndCommitPaths([...promoted.copiedPaths, ...promoted.deletedPaths], `rrx: accept ${context.runId}`);
+            decisionRecord = {
+                ...decisionRecord,
+                commitSha: commitResult.commitSha,
+            };
+            await dependencies.decisionStore.put(decisionRecord);
+            frontier = frontierUpdate.entries.map((entry) => ({
+                ...entry,
+                commitSha: commitResult.commitSha,
+            }));
+            runRecord = advanceRunPhase(runRecord, "committed");
+            await dependencies.runStore.put(runRecord);
+            await dependencies.frontierStore.save(frontier);
+            runRecord = advanceRunPhase(runRecord, "frontier_updated");
+            await dependencies.runStore.put(runRecord);
+        }
+        if (ratchetDecision.outcome !== "needs_human") {
+            await dependencies.workspaceManager.cleanupWorkspace(selectedCandidate.candidateId);
+        }
+        runRecord = advanceRunPhase(runRecord, "completed", {
+            status: ratchetDecision.outcome,
+        });
+        await dependencies.runStore.put(runRecord);
+        return {
+            status: ratchetDecision.outcome,
+            run: runRecord,
+            decision: decisionRecord,
+            frontier,
+            auditQueue,
+            changeBudget: selectedCandidate.changeBudget,
+            ...(anchorCheck ? { anchorCheck } : {}),
+        };
+    }
+    catch (error) {
+        runRecord = advanceRunPhase(runRecord, "failed", {
+            error: {
+                message: error instanceof Error ? error.message : String(error),
+                ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
+            },
+            status: "failed",
+        });
+        await dependencies.runStore.put(runRecord);
+        return {
+            status: "failed",
+            run: runRecord,
+            frontier,
+            auditQueue: [],
+        };
+    }
+}
+async function createRunContext(repoRoot, manifest, runStore, now) {
+    const runs = await runStore.list();
+    const nextCycle = runs.reduce((highest, run) => Math.max(highest, run.cycle), 0) + 1;
+    const runId = `run-${String(nextCycle).padStart(4, "0")}`;
+    const candidateId = `candidate-${String(nextCycle).padStart(4, "0")}`;
+    const runDir = join(resolve(repoRoot), manifest.storage.root, "runs", runId);
+    const startedAt = now().toISOString();
+    const manifestHash = createHash("sha256").update(JSON.stringify(manifest)).digest("hex");
+    return {
+        runId,
+        cycle: nextCycle,
+        candidateId,
+        runDir,
+        startedAt,
+        manifestHash,
+    };
+}
+function createInitialRunRecord(manifest, workspacePath, context) {
+    return {
+        runId: context.runId,
+        cycle: context.cycle,
+        candidateId: context.candidateId,
+        status: "running",
+        phase: "proposed",
+        pendingAction: "execute_experiment",
+        startedAt: context.startedAt,
+        manifestHash: context.manifestHash,
+        workspaceRef: manifest.project.baselineRef,
+        ...(workspacePath ? { workspacePath } : {}),
+        proposal: {
+            proposerType: manifest.proposer.type,
+            summary: "proposal pending",
+            operators: manifest.proposer.type === "operator_llm"
+                ? manifest.proposer.operators
+                : manifest.proposer.type === "parallel"
+                    ? []
+                    : [],
+        },
+        artifacts: [],
+        metrics: {},
+        constraints: [],
+        logs: {},
+    };
+}
+async function prepareCandidateAttempt(input) {
+    if (input.manifest.proposer.type === "parallel") {
+        const selection = await runParallelProposers({
+            strategies: input.manifest.proposer.strategies,
+            pickBest: input.manifest.proposer.pickBest,
+            referenceMetric: input.referenceMetric,
+            execute: async (strategy, index) => {
+                const candidateId = `${input.baseCandidateId}-p${String(index + 1).padStart(2, "0")}`;
+                const candidate = await executeCandidateStrategy({
+                    repoRoot: input.repoRoot,
+                    manifestDir: input.manifestDir,
+                    manifest: input.manifest,
+                    proposer: strategy,
+                    candidateId,
+                    runDir: input.runDir,
+                    workspaceManager: input.workspaceManager,
+                    currentFrontier: input.currentFrontier,
+                    ...(input.judgeProvider ? { judgeProvider: input.judgeProvider } : {}),
+                    ...(input.historyContext ? { historyContext: input.historyContext } : {}),
+                });
+                return {
+                    strategyIndex: index,
+                    strategyType: strategy.type,
+                    candidate,
+                    metrics: candidate.metrics,
+                    summary: candidate.summary,
+                };
+            },
+            ...(input.manifest.proposer.pickBest === "judge_pairwise"
+                ? {
+                    comparePairwise: async (left, right) => compareCandidateAttempts({
+                        manifest: input.manifest,
+                        manifestDir: input.manifestDir,
+                        referenceMetric: input.referenceMetric,
+                        ...(input.judgeProvider ? { judgeProvider: input.judgeProvider } : {}),
+                    }, left.candidate, right.candidate),
+                }
+                : {}),
+        });
+        const hydratedCandidates = selection.candidates.map((candidate) => ({
+            ...candidate,
+            metrics: candidate.candidate.metrics,
+            summary: candidate.candidate.summary,
+        }));
+        const selected = hydratedCandidates.find((candidate) => candidate.strategyIndex === selection.selected.strategyIndex);
+        if (!selected) {
+            throw new Error("selected parallel candidate missing from candidate set");
+        }
+        await Promise.all(hydratedCandidates
+            .filter((candidate) => candidate.strategyIndex !== selected.strategyIndex)
+            .map((candidate) => input.workspaceManager.cleanupWorkspace(candidate.candidate.candidateId)));
+        return {
+            ...selected.candidate,
+            proposerType: "parallel",
+            summary: `${selected.candidate.summary}; ${selection.selectionReason}`,
+        };
+    }
+    return executeCandidateStrategy({
+        repoRoot: input.repoRoot,
+        manifestDir: input.manifestDir,
+        manifest: input.manifest,
+        proposer: input.manifest.proposer,
+        candidateId: input.baseCandidateId,
+        runDir: input.runDir,
+        workspaceManager: input.workspaceManager,
+        currentFrontier: input.currentFrontier,
+        ...(input.historyContext ? { historyContext: input.historyContext } : {}),
+        ...(input.judgeProvider ? { judgeProvider: input.judgeProvider } : {}),
+    });
+}
+async function executeCandidateStrategy(input) {
+    const workspace = await input.workspaceManager.createWorkspace(input.candidateId);
+    const proposal = await executeProposal(input.proposer, workspace.workspacePath, input.historyContext);
+    const proposeStdoutPath = await persistText(join(input.runDir, "logs", `${input.candidateId}.propose.stdout.log`), proposal.stdout);
+    const experiment = await runExperiment(input.manifest.experiment.run, {
+        workspacePath: workspace.workspacePath,
+    });
+    const runStdoutPath = await persistText(join(input.runDir, "logs", `${input.candidateId}.experiment.stdout.log`), experiment.stdout);
+    const metricEvaluation = await evaluateMetrics({
+        repoRoot: input.repoRoot,
+        manifestDir: input.manifestDir,
+        manifest: input.manifest,
+        currentFrontier: input.currentFrontier,
+        workspacePath: workspace.workspacePath,
+        runDir: join(input.runDir, "judge", input.candidateId),
+        ...(input.judgeProvider ? { judgeProvider: input.judgeProvider } : {}),
+    });
+    const artifacts = await snapshotArtifacts(input.manifest.experiment.outputs, workspace.workspacePath, join(input.runDir, "artifacts", input.candidateId));
+    const constraints = evaluateConstraints(input.manifest.constraints, metricEvaluation.metrics);
+    const changeBudget = await evaluateChangeBudget({
+        workspacePath: workspace.workspacePath,
+        scope: input.manifest.scope,
+    });
+    return {
+        candidateId: input.candidateId,
+        workspacePath: workspace.workspacePath,
+        proposerType: input.proposer.type,
+        operators: input.proposer.type === "operator_llm" ? input.proposer.operators : [],
+        summary: input.historyContext ? `${proposal.summary}; history_context=enabled` : proposal.summary,
+        proposeStdoutPath,
+        runStdoutPath,
+        metrics: metricEvaluation.metrics,
+        artifacts,
+        constraints,
+        changeBudget,
+        anchorChecks: metricEvaluation.anchorChecks,
+        packByMetricId: metricEvaluation.packByMetricId,
+    };
+}
+async function executeProposal(proposer, workspacePath, historyContext) {
+    if (proposer.type !== "command") {
+        throw new Error(`unsupported proposer type ${proposer.type} in cycle runner`);
+    }
+    return runCommandProposer(proposer, {
+        workspacePath,
+        ...(historyContext
+            ? {
+                env: {
+                    RRX_HISTORY_ENABLED: "1",
+                    RRX_HISTORY_SUMMARY: historyContext.summary,
+                    RRX_HISTORY_PATH: historyContext.path,
+                },
+            }
+            : {}),
+    });
+}
+async function compareCandidateAttempts(input, left, right) {
+    const metricDefinition = input.manifest.metrics.catalog.find((metric) => metric.id === input.referenceMetric);
+    if (!metricDefinition) {
+        throw new Error(`missing reference metric definition ${input.referenceMetric}`);
+    }
+    if (metricDefinition.kind !== "llm_score" ||
+        metricDefinition.extractor.type !== "llm_judge" ||
+        metricDefinition.extractor.mode !== "pairwise") {
+        return compareByMetric(left, right, input.referenceMetric);
+    }
+    if (!input.judgeProvider) {
+        throw new Error("parallel proposer pickBest=judge_pairwise requires a judge provider");
+    }
+    const extractor = metricDefinition.extractor;
+    const pack = getJudgePack(input.manifest, extractor.judgePack);
+    const prompt = await buildJudgePrompt({
+        repoRoot: process.cwd(),
+        manifestDir: input.manifestDir,
+        workspacePath: left.workspacePath,
+        extractor,
+        frontier: [
+            {
+                frontierId: `parallel-${right.candidateId}`,
+                runId: `parallel-${right.candidateId}`,
+                candidateId: right.candidateId,
+                acceptedAt: new Date(0).toISOString(),
+                metrics: right.metrics,
+                artifacts: right.artifacts,
+            },
+        ],
+    });
+    const result = await runLlmJudgeMetric({
+        metricId: metricDefinition.id,
+        direction: metricDefinition.direction,
+        extractor,
+        pack,
+        prompt,
+        provider: input.judgeProvider,
+    });
+    const winner = result.details.winner;
+    if (winner === "candidate") {
+        return "left";
+    }
+    if (winner === "incumbent") {
+        return "right";
+    }
+    return compareByMetric(left, right, input.referenceMetric);
+}
+function compareByMetric(left, right, metricId) {
+    const leftMetric = left.metrics[metricId];
+    const rightMetric = right.metrics[metricId];
+    if (!leftMetric || !rightMetric) {
+        throw new Error(`parallel proposer comparison requires metric "${metricId}" on both candidates`);
+    }
+    if (leftMetric.direction === "maximize") {
+        if (leftMetric.value > rightMetric.value) {
+            return "left";
+        }
+        if (leftMetric.value < rightMetric.value) {
+            return "right";
+        }
+        return "tie";
+    }
+    if (leftMetric.value < rightMetric.value) {
+        return "left";
+    }
+    if (leftMetric.value > rightMetric.value) {
+        return "right";
+    }
+    return "tie";
+}
+async function buildProposerHistoryContext(input) {
+    if (!input.manifest.proposer.history.enabled) {
+        return undefined;
+    }
+    const snapshot = compactRecentHistory({
+        runs: input.runs.filter((run) => run.phase === "completed"),
+        decisions: input.decisions,
+        maxRuns: input.manifest.proposer.history.maxRuns,
+        primaryMetric: input.primaryMetric,
+    });
+    const path = join(input.runDir, "history", "proposer-history.md");
+    await persistText(path, snapshot.summary);
+    return {
+        summary: snapshot.summary,
+        path,
+    };
+}
+async function evaluateMetrics(input) {
+    const metrics = {};
+    const anchorChecks = new Map();
+    const anchorCheckCache = new Map();
+    const packByMetricId = new Map();
+    for (const metricDefinition of input.manifest.metrics.catalog) {
+        if (metricDefinition.extractor.type === "command") {
+            metrics[metricDefinition.id] = await extractCommandMetric(metricDefinition.extractor, {
+                metricId: metricDefinition.id,
+                direction: metricDefinition.direction,
+                workspacePath: input.workspacePath,
+            });
+            continue;
+        }
+        if (!input.judgeProvider) {
+            throw new Error(`metric ${metricDefinition.id} requires a judge provider`);
+        }
+        const extractor = metricDefinition.extractor;
+        const pack = getJudgePack(input.manifest, extractor.judgePack);
+        packByMetricId.set(metricDefinition.id, pack);
+        const prompt = await buildJudgePrompt({
+            repoRoot: input.repoRoot,
+            manifestDir: input.manifestDir,
+            workspacePath: input.workspacePath,
+            extractor,
+            frontier: input.currentFrontier,
+        });
+        const metric = await runLlmJudgeMetric({
+            metricId: metricDefinition.id,
+            direction: metricDefinition.direction,
+            extractor,
+            pack,
+            prompt,
+            provider: input.judgeProvider,
+        });
+        const judgeTracePath = join(input.runDir, "judge", `${metricDefinition.id}.json`);
+        await persistJson(judgeTracePath, metric.details);
+        metrics[metricDefinition.id] = {
+            ...metric,
+            judgeTracePath,
+            details: {
+                ...metric.details,
+                judgeTracePath,
+            },
+        };
+        if (!anchorCheckCache.has(pack.id)) {
+            const anchors = pack.anchors ? await loadAnchorRecords(resolve(input.manifestDir, pack.anchors.path)) : [];
+            anchorCheckCache.set(pack.id, await evaluateAnchorAgreement({
+                pack,
+                extractor,
+                provider: input.judgeProvider,
+                anchors,
+            }));
+        }
+        anchorChecks.set(metricDefinition.id, anchorCheckCache.get(pack.id));
+    }
+    return {
+        metrics,
+        anchorChecks,
+        packByMetricId,
+    };
+}
+function resolveDecision(input) {
+    const referenceMetric = getReferenceMetric(input.manifest);
+    if (!input.changeBudget.withinBudget) {
+        return {
+            outcome: input.changeBudget.outcome === "needs_human" ? "needs_human" : "rejected",
+            frontierChanged: false,
+            metricId: referenceMetric,
+            policyType: input.manifest.ratchet.type,
+            reason: input.changeBudget.reason,
+        };
+    }
+    return evaluateRatchet({
+        ratchet: input.manifest.ratchet,
+        primaryMetric: referenceMetric,
+        candidateMetrics: input.metrics,
+        currentFrontier: input.currentFrontier,
+        priorConsecutiveAccepts: input.priorConsecutiveAccepts,
+        ...(input.manifest.frontier.strategy === "pareto"
+            ? {
+                paretoObjectives: input.manifest.frontier.objectives,
+            }
+            : {}),
+        ...(input.constraints.passed ? {} : { constraintFailureReason: input.constraints.reason }),
+    });
+}
+function buildFrontierEntry(runId, candidateId, now, metrics, artifacts) {
+    return {
+        frontierId: `frontier-${runId}`,
+        runId,
+        candidateId,
+        acceptedAt: now().toISOString(),
+        metrics,
+        artifacts,
+    };
+}
+function buildAuditQueue(metricId, decision, manifest, packByMetricId) {
+    const pack = packByMetricId.get(metricId);
+    if (!pack) {
+        return [];
+    }
+    return sampleAuditQueue([
+        {
+            runId: decision.runId,
+            decisionId: decision.decisionId,
+            outcome: decision.outcome,
+            metricId,
+            reason: decision.reason,
+        },
+    ], pack, decision.createdAt);
+}
+async function buildJudgePrompt(input) {
+    const template = await readTemplateOrInline(input.manifestDir, input.extractor.prompt);
+    const sections = [template];
+    for (const [key, source] of Object.entries(input.extractor.inputs)) {
+        const value = await resolvePromptInput(source, input.workspacePath, input.frontier);
+        sections.push(`\n[${key}]\n${value}`);
+    }
+    return sections.join("\n");
+}
+async function resolvePromptInput(source, workspacePath, frontier) {
+    if (source.startsWith("frontier.best:")) {
+        const reference = source.slice("frontier.best:".length);
+        const incumbent = frontier[0];
+        if (!incumbent) {
+            return "";
+        }
+        const artifact = incumbent.artifacts.find((entry) => entry.id === reference || entry.path.endsWith(reference));
+        if (!artifact) {
+            return "";
+        }
+        return readFile(resolve(artifact.path), "utf8");
+    }
+    const candidatePath = resolve(workspacePath, source);
+    try {
+        return await readFile(candidatePath, "utf8");
+    }
+    catch {
+        return source;
+    }
+}
+async function readTemplateOrInline(baseDir, value) {
+    const candidatePath = resolve(baseDir, value);
+    try {
+        return await readFile(candidatePath, "utf8");
+    }
+    catch {
+        return value;
+    }
+}
+async function snapshotArtifacts(outputs, workspacePath, artifactRoot) {
+    const artifacts = [];
+    for (const output of outputs) {
+        const sourcePath = resolve(workspacePath, output.path);
+        const destinationPath = join(artifactRoot, `${output.id}${extname(output.path) || ".txt"}`);
+        await mkdir(dirname(destinationPath), { recursive: true });
+        await copyFile(sourcePath, destinationPath);
+        artifacts.push({
+            id: output.id,
+            path: destinationPath,
+        });
+    }
+    return artifacts;
+}
+function stripConstraintReason(constraint) {
+    return {
+        metric: constraint.metric,
+        passed: constraint.passed,
+        actual: constraint.actual,
+        expected: constraint.expected,
+        op: constraint.op,
+    };
+}
+async function persistText(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, value, "utf8");
+    return path;
+}
+async function persistJson(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    return path;
+}
+function getJudgePack(manifest, judgePackId) {
+    const pack = manifest.judgePacks.find((entry) => entry.id === judgePackId);
+    if (!pack) {
+        throw new Error(`unknown judge pack ${judgePackId}`);
+    }
+    return pack;
+}
+function getReferenceMetric(manifest) {
+    if (manifest.frontier.strategy === "single_best") {
+        return manifest.frontier.primaryMetric;
+    }
+    return manifest.frontier.objectives[0].metric;
+}
+function updateFrontier(manifest, currentFrontier, candidateEntry) {
+    if (manifest.frontier.strategy === "single_best") {
+        return updateSingleBestFrontier(currentFrontier, candidateEntry, manifest.frontier.primaryMetric);
+    }
+    return updateParetoFrontier(currentFrontier, candidateEntry, manifest.frontier.objectives, manifest.frontier.tieBreaker, manifest.frontier.referencePoint);
+}
+//# sourceMappingURL=cycle-runner.js.map