@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/services/case-pipeline/service.d.ts

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+import { type CaseCheckpointStoreV1 } from "../../case-checkpoint-store.js";
+import { type AdmitCheckpointV1, type PipelineCaseContextV1, type PipelineCheckpointsV1, type PipelineStateV1 } from "../../case-pipeline-protocol.js";
+import type { RepositoryBehaviorMapV1 } from "../../repository-behavior-protocol.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+export type CasePipelineRunInputV1 = {
+    readonly context: PipelineCaseContextV1;
+    readonly map: RepositoryBehaviorMapV1;
+    readonly store?: CaseCheckpointStoreV1;
+};
+export type CasePipelineRunResultV1 = {
+    readonly state: PipelineStateV1;
+    readonly checkpoints: PipelineCheckpointsV1;
+    readonly admit?: AdmitCheckpointV1;
+};
+export type CasePipelineStatusResultV1 = {
+    readonly state?: PipelineStateV1;
+    readonly checkpoints: PipelineCheckpointsV1;
+    readonly ledgerEntries: number;
+    readonly error?: string;
+};
+/** Public runner: every failure, including defects at an adapter boundary, is returned as durable state. */
+export declare const runCasePipelineV1: (input: CasePipelineRunInputV1) => Effect.Effect<CasePipelineRunResultV1, never, RepositoryFoundryLanguageModel>;
+/** Read-only status inspection. It never invokes or requires a language model. */
+export declare const readCasePipelineStatusV1: (input: {
+    readonly caseDirectory: string;
+}) => Effect.Effect<CasePipelineStatusResultV1>;
+export declare const runRepositoryCasePipelineV1: (input: CasePipelineRunInputV1) => Effect.Effect<CasePipelineRunResultV1, never, RepositoryFoundryLanguageModel>;
+export declare const readRepositoryCasePipelineStatusV1: (input: {
+    readonly caseDirectory: string;
+}) => Effect.Effect<CasePipelineStatusResultV1>;

package/dist/services/case-pipeline/service.js

@@ -0,0 +1,485 @@
+import { Cause, Clock, Effect, Option, Schema } from "effect";
+import { makeCaseCheckpointStoreV1 } from "../../case-checkpoint-store.js";
+import { checkpointDigestV1, nextPipelineStageV1, PIPELINE_CHECKPOINT_SCHEMAS, PIPELINE_STAGES, PipelineBudgetExhaustedError, PipelineStageError, pipelineScientificIdentityDigestV1, pipelineStageIndexV1 } from "../../case-pipeline-protocol.js";
+import { RepositorySpecificationReviewV1 } from "../../repository-specification-critique-protocol.js";
+import { BudgetedLanguageModelLive, makePipelineStateAccessorV1, normalizePipelineFailureV1, PipelineBudgetTracker } from "../budgeted-model/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+import { runPipelineAdmitStageV1, runPipelineChallengeStageV1 } from "../pipeline-challenge/service.js";
+import { runPipelineControlsStageV1 } from "../pipeline-controls/service.js";
+import { runPipelineOracleStageV1 } from "../pipeline-oracle/service.js";
+import { runPipelineSeedStageV1 } from "../pipeline-seed/service.js";
+import { runPipelineSpecStageV1 } from "../pipeline-spec/service.js";
+import { runPipelineTournamentStageV1 } from "../pipeline-tournament/service.js";
+const nowIso = (millis) => new Date(millis).toISOString();
+const initialState = (context, map, at) => ({
+    version: 1,
+    caseId: context.caseId,
+    repositoryRoot: context.repositoryRoot,
+    dimension: context.dimension,
+    model: context.primaryModel,
+    identityDigest: pipelineScientificIdentityDigestV1(context, map),
+    stage: "seed",
+    status: "running",
+    startedAt: nowIso(at),
+    updatedAt: nowIso(at),
+    modelCalls: 0,
+    elapsedMs: 0,
+    resumeCount: 0,
+    folds: 0
+});
+const sameIdentity = (state, context, map) => state.caseId === context.caseId &&
+    state.repositoryRoot === context.repositoryRoot &&
+    state.model === context.primaryModel &&
+    state.identityDigest === pipelineScientificIdentityDigestV1(context, map);
+const acceptedSpec = (checkpoint) => {
+    const last = checkpoint.reviews.at(-1);
+    if (last === undefined)
+        return false;
+    const decoded = Schema.decodeUnknownOption(RepositorySpecificationReviewV1)(last);
+    if (Option.isNone(decoded))
+        return false;
+    const review = decoded.value;
+    return (review.verdict === "sufficient" &&
+        review.dimensionFit?.outcome === "fit" &&
+        review.referenceCompatibility?.outcome === "compatible" &&
+        (review.criticalBehaviorCoverage?.every(({ outcome }) => outcome === "covered") ?? false) &&
+        review.findings.every(({ severity }) => severity !== "blocker"));
+};
+const checkpointComplete = (stage, checkpoint) => {
+    switch (stage) {
+        case "seed":
+            return checkpoint.seed.status === "qualified";
+        case "spec":
+            return acceptedSpec(checkpoint);
+        case "oracle": {
+            const oracle = checkpoint;
+            return oracle.preflight.passed;
+        }
+        case "controls": {
+            const controls = checkpoint;
+            return controls.valid.length >= 1 && controls.wrong.length >= 1;
+        }
+        case "tournament":
+            return checkpoint.adequacy.admitted;
+        case "challenge":
+        case "admit":
+            return true;
+    }
+};
+const parentDigest = (stage, context, checkpoints) => {
+    if (stage === "seed")
+        return checkpointDigestV1(context);
+    const previous = PIPELINE_STAGES[pipelineStageIndexV1(stage) - 1];
+    if (previous === undefined)
+        return undefined;
+    const checkpoint = checkpoints[previous];
+    return checkpoint === undefined ? undefined : checkpointDigestV1(checkpoint);
+};
+const withCheckpoint = (checkpoints, stage, checkpoint) => ({ ...checkpoints, [stage]: checkpoint });
+const withoutFrom = (checkpoints, stage) => {
+    const retained = {};
+    for (const candidate of PIPELINE_STAGES) {
+        if (pipelineStageIndexV1(candidate) < pipelineStageIndexV1(stage)) {
+            const value = checkpoints[candidate];
+            if (value !== undefined)
+                retained[candidate] = value;
+        }
+    }
+    return retained;
+};
+const readStageCheckpoint = (store, stage) => {
+    switch (stage) {
+        case "seed":
+            return store.readStage(stage, PIPELINE_CHECKPOINT_SCHEMAS.seed);
+        case "spec":
+            return store.readStage(stage, PIPELINE_CHECKPOINT_SCHEMAS.spec);
+        case "oracle":
+            return store.readStage(stage, PIPELINE_CHECKPOINT_SCHEMAS.oracle);
+        case "controls":
+            return store.readStage(stage, PIPELINE_CHECKPOINT_SCHEMAS.controls);
+        case "tournament":
+            return store.readStage(stage, PIPELINE_CHECKPOINT_SCHEMAS.tournament);
+        case "challenge":
+            return store.readStage(stage, PIPELINE_CHECKPOINT_SCHEMAS.challenge);
+        case "admit":
+            return store.readStage(stage, PIPELINE_CHECKPOINT_SCHEMAS.admit);
+    }
+};
+/**
+ * Persist and decode through the checkpoint schema before exposing a checkpoint
+ * to the next stage. Stage parent digests must describe the durable JSON value,
+ * not an in-memory value that may differ after JSON/schema round-tripping.
+ */
+const persistStageCheckpoint = Effect.fn("CasePipeline.persistStageCheckpoint")(function* (store, stage, checkpoint) {
+    yield* store.writeStage(stage, checkpoint);
+    const persisted = yield* readStageCheckpoint(store, stage);
+    if (Option.isNone(persisted)) {
+        return yield* Effect.die(new Error(`persisted pipeline checkpoint ${stage} could not be decoded`));
+    }
+    return persisted.value;
+});
+const loadCheckpoints = Effect.fn("CasePipeline.loadCheckpoints")(function* (store, context) {
+    let checkpoints = {};
+    for (const stage of PIPELINE_STAGES) {
+        const loaded = yield* readStageCheckpoint(store, stage);
+        if (Option.isNone(loaded)) {
+            yield* store.deleteFrom(stage);
+            break;
+        }
+        const checkpoint = loaded.value;
+        const expected = parentDigest(stage, context, checkpoints);
+        // The seed digest includes the requested budget, which may be extended on resume.
+        // Its durable state identity is checked separately; scientific child links are strict.
+        if (stage !== "seed" && checkpoint.parentDigest !== expected) {
+            yield* Effect.logWarning(`pipeline checkpoint ${stage} has a stale parent and will be regenerated: expected=${String(expected)} actual=${checkpoint.parentDigest}`);
+            yield* store.deleteFrom(stage);
+            break;
+        }
+        checkpoints = withCheckpoint(checkpoints, stage, checkpoint);
+        if (!checkpointComplete(stage, checkpoint)) {
+            const next = nextPipelineStageV1(stage);
+            if (next !== "done")
+                yield* store.deleteFrom(next);
+            break;
+        }
+    }
+    return checkpoints;
+});
+const firstIncompleteStage = (checkpoints) => {
+    for (const stage of PIPELINE_STAGES) {
+        const checkpoint = checkpoints[stage];
+        if (checkpoint === undefined || !checkpointComplete(stage, checkpoint))
+            return stage;
+    }
+    return "done";
+};
+const runStage = (input) => {
+    const base = {
+        context: input.context,
+        map: input.map,
+        workCheckpointStore: input.store,
+        checkpoints: input.checkpoints
+    };
+    const checkpoint = (stage, value) => input.beforeCheckpoint.pipe(Effect.andThen(input.store.writeStage(stage, value)), Effect.orDie);
+    switch (input.stage) {
+        case "seed":
+            return runPipelineSeedStageV1({
+                ...base,
+                checkpoint: (value) => checkpoint("seed", value)
+            });
+        case "spec":
+            return runPipelineSpecStageV1({
+                ...base,
+                checkpoint: (value) => checkpoint("spec", value)
+            });
+        case "oracle":
+            return runPipelineOracleStageV1({
+                ...base,
+                checkpoint: (value) => checkpoint("oracle", value)
+            });
+        case "controls":
+            return runPipelineControlsStageV1({
+                ...base,
+                checkpoint: (value) => checkpoint("controls", value)
+            });
+        case "tournament":
+            return runPipelineTournamentStageV1({
+                ...base,
+                checkpoint: (value) => checkpoint("tournament", value)
+            });
+        case "challenge":
+            return runPipelineChallengeStageV1({
+                ...base,
+                checkpoint: (value) => checkpoint("challenge", value)
+            });
+        case "admit":
+            return runPipelineAdmitStageV1({
+                ...base,
+                checkpoint: (value) => checkpoint("admit", value)
+            });
+    }
+};
+const persistedState = Effect.fnUntraced(function* (input) {
+    const current = yield* input.accessor.get;
+    const at = yield* Clock.currentTimeMillis;
+    const next = {
+        ...current,
+        ...input.patch,
+        elapsedMs: Math.max(current.elapsedMs, input.baselineElapsedMs + Math.max(0, at - input.runStartedAt)),
+        updatedAt: nowIso(at)
+    };
+    yield* input.accessor.set(next);
+    yield* input.store.writeState(next);
+    return next;
+});
+const describeFailure = (error) => error instanceof Error && error.message.trim().length > 0 ? error.message : String(error);
+const pipelineStageErrorOf = (error, depth = 0) => {
+    if (error instanceof PipelineStageError)
+        return error;
+    if (depth >= 8 || typeof error !== "object" || error === null || !("cause" in error)) {
+        return undefined;
+    }
+    return pipelineStageErrorOf(error.cause, depth + 1);
+};
+const wallBudgetError = (context, stage, snapshot) => new PipelineBudgetExhaustedError({
+    budget: context.budget,
+    modelCalls: snapshot.modelCalls,
+    elapsedMs: snapshot.elapsedMs,
+    stage
+});
+const pipelineProgram = Effect.fn("CasePipeline.runProgram")(function* (input) {
+    const store = input.store ?? makeCaseCheckpointStoreV1({ caseDirectory: input.context.caseDirectory });
+    const runStartedAt = yield* Clock.currentTimeMillis;
+    const prior = yield* store.readState;
+    const base = Option.isSome(prior)
+        ? prior.value
+        : initialState(input.context, input.map, runStartedAt);
+    const accessor = yield* makePipelineStateAccessorV1(base);
+    const baselineElapsedMs = base.elapsedMs;
+    if (!sameIdentity(base, input.context, input.map)) {
+        const at = yield* Clock.currentTimeMillis;
+        /*
+         * Refuse the incompatible invocation without poisoning the durable case.
+         * The caller receives one of the four public outcomes, while a subsequent
+         * invocation with the original identity can still resume its evidence.
+         */
+        const state = {
+            ...base,
+            status: "failed",
+            stage: "done",
+            reason: "case directory belongs to a different pipeline identity",
+            updatedAt: nowIso(at)
+        };
+        return { state, checkpoints: {} };
+    }
+    let checkpoints = yield* loadCheckpoints(store, input.context);
+    const resumed = Option.isSome(prior);
+    let state = yield* persistedState({
+        accessor,
+        store,
+        patch: {
+            status: "running",
+            stage: firstIncompleteStage(checkpoints),
+            reason: undefined,
+            resumeCount: base.resumeCount + (resumed ? 1 : 0)
+        },
+        runStartedAt,
+        baselineElapsedMs
+    });
+    const inner = yield* RepositoryFoundryLanguageModel;
+    const execute = Effect.gen(function* () {
+        const budget = yield* PipelineBudgetTracker;
+        const assertWallAvailable = (stage) => Effect.gen(function* () {
+            const snapshot = yield* budget.snapshot;
+            if (snapshot.remainingMs <= 0) {
+                return yield* wallBudgetError(input.context, stage, snapshot);
+            }
+            return snapshot;
+        });
+        let challengeFold = state.folds;
+        for (;;) {
+            const failedChallenge = checkpoints.challenge;
+            if (failedChallenge?.verdict === "failed") {
+                if (failedChallenge.fold >= input.context.foldLimit) {
+                    state = yield* persistedState({
+                        accessor,
+                        store,
+                        patch: {
+                            status: "rejected",
+                            stage: "done",
+                            reason: "fresh held-out challenge failed at the fold limit"
+                        },
+                        runStartedAt,
+                        baselineElapsedMs
+                    });
+                    return { state, checkpoints };
+                }
+                const controls = checkpoints.controls;
+                if (controls === undefined) {
+                    state = yield* persistedState({
+                        accessor,
+                        store,
+                        patch: {
+                            status: "failed",
+                            stage: "done",
+                            reason: "challenge fold has no controls checkpoint"
+                        },
+                        runStartedAt,
+                        baselineElapsedMs
+                    });
+                    return { state, checkpoints };
+                }
+                const nextFolds = Math.max(state.folds, failedChallenge.fold + 1);
+                /*
+                 * Persist the next fresh-challenge identity before invalidating any
+                 * descendant. If the process stops during the fold, the failed
+                 * challenge remains sufficient to replay this idempotent transition;
+                 * after descendant deletion, state.folds alone preserves the identity.
+                 */
+                state = yield* persistedState({
+                    accessor,
+                    store,
+                    patch: { status: "running", stage: "tournament", folds: nextFolds, reason: undefined },
+                    runStartedAt,
+                    baselineElapsedMs
+                });
+                const existingWrongIds = new Set(controls.wrong.map(({ id }) => id));
+                const newHeldOut = failedChallenge.heldOut.filter(({ id }) => !existingWrongIds.has(id));
+                const foldedControls = {
+                    ...controls,
+                    createdAt: nowIso(yield* Clock.currentTimeMillis),
+                    wrong: [...controls.wrong, ...newHeldOut]
+                };
+                const persistedControls = yield* persistStageCheckpoint(store, "controls", foldedControls);
+                yield* store.deleteFrom("tournament");
+                checkpoints = {
+                    ...withoutFrom(checkpoints, "tournament"),
+                    controls: persistedControls
+                };
+                challengeFold = nextFolds;
+                continue;
+            }
+            const stage = firstIncompleteStage(checkpoints);
+            if (stage === "done") {
+                const admit = checkpoints.admit;
+                const status = admit?.verdict === "admitted" ? "admitted" : "rejected";
+                state = yield* persistedState({
+                    accessor,
+                    store,
+                    patch: {
+                        status,
+                        stage: "done",
+                        ...(status === "admitted"
+                            ? { reason: undefined }
+                            : { reason: admit?.reasons.join("; ") ?? "admission evidence is incomplete" })
+                    },
+                    runStartedAt,
+                    baselineElapsedMs
+                });
+                return {
+                    state,
+                    checkpoints,
+                    ...(admit === undefined ? {} : { admit })
+                };
+            }
+            state = yield* persistedState({
+                accessor,
+                store,
+                patch: { status: "running", stage, reason: undefined },
+                runStartedAt,
+                baselineElapsedMs
+            });
+            const stageCheckpoints = stage === "challenge"
+                ? {
+                    ...checkpoints,
+                    /*
+                     * Challenge consumes only the durable fold number from a prior
+                     * checkpoint. Keep that scheduling hint out of the scientific
+                     * checkpoint chain until the stage returns a complete value.
+                     */
+                    challenge: { fold: challengeFold }
+                }
+                : checkpoints;
+            const beforeStage = yield* assertWallAvailable(stage).pipe(Effect.result);
+            if (beforeStage._tag === "Failure") {
+                const reason = describeFailure(beforeStage.failure);
+                state = yield* persistedState({
+                    accessor,
+                    store,
+                    patch: { status: "exhausted", stage, reason },
+                    runStartedAt,
+                    baselineElapsedMs
+                });
+                return { state, checkpoints };
+            }
+            const outcome = yield* Effect.result(runStage({
+                stage,
+                context: input.context,
+                map: input.map,
+                checkpoints: stageCheckpoints,
+                store,
+                beforeCheckpoint: assertWallAvailable(stage).pipe(Effect.asVoid)
+            }).pipe(Effect.catchDefect((defect) => defect instanceof PipelineBudgetExhaustedError
+                ? Effect.fail(defect)
+                : Effect.die(defect)), Effect.interruptible, Effect.timeoutOrElse({
+                duration: beforeStage.success.remainingMs,
+                orElse: () => Effect.flatMap(budget.snapshot, (snapshot) => Effect.fail(wallBudgetError(input.context, stage, snapshot)))
+            }), Effect.flatMap((checkpoint) => assertWallAvailable(stage).pipe(Effect.as(checkpoint)))));
+            if (outcome._tag === "Failure") {
+                const normalized = normalizePipelineFailureV1(outcome.failure);
+                const stageError = pipelineStageErrorOf(normalized);
+                const status = normalized instanceof PipelineBudgetExhaustedError
+                    ? "exhausted"
+                    : stageError?.terminal === true
+                        ? "failed"
+                        : "running";
+                const reason = describeFailure(normalized);
+                state = yield* persistedState({
+                    accessor,
+                    store,
+                    patch: { status, stage: status === "failed" ? "done" : stage, reason },
+                    runStartedAt,
+                    baselineElapsedMs
+                });
+                return { state, checkpoints };
+            }
+            const checkpoint = yield* persistStageCheckpoint(store, stage, outcome.success);
+            checkpoints = withCheckpoint(checkpoints, stage, checkpoint);
+        }
+    });
+    return yield* execute.pipe(Effect.provide(BudgetedLanguageModelLive({
+        store,
+        state: accessor,
+        budget: input.context.budget,
+        startedAtMs: runStartedAt,
+        inner
+    })));
+});
+/** Public runner: every failure, including defects at an adapter boundary, is returned as durable state. */
+export const runCasePipelineV1 = (input) => pipelineProgram(input).pipe(Effect.catchCause((cause) => Effect.gen(function* () {
+    const store = input.store ?? makeCaseCheckpointStoreV1({ caseDirectory: input.context.caseDirectory });
+    const at = yield* Clock.currentTimeMillis;
+    const loaded = yield* store.readState.pipe(Effect.option);
+    const prior = Option.isSome(loaded) && Option.isSome(loaded.value)
+        ? loaded.value.value
+        : initialState(input.context, input.map, at);
+    const terminal = pipelineStageErrorOf(Cause.squash(cause))?.terminal === true;
+    const state = {
+        ...prior,
+        status: terminal ? "failed" : "running",
+        stage: terminal ? "done" : prior.stage,
+        reason: Cause.pretty(cause),
+        updatedAt: nowIso(at)
+    };
+    yield* store.writeState(state).pipe(Effect.ignore);
+    const loadedCheckpoints = yield* Effect.result(loadCheckpoints(store, input.context));
+    const checkpoints = loadedCheckpoints._tag === "Success"
+        ? loadedCheckpoints.success
+        : {};
+    return {
+        state,
+        checkpoints,
+        ...(checkpoints.admit === undefined ? {} : { admit: checkpoints.admit })
+    };
+})));
+/** Read-only status inspection. It never invokes or requires a language model. */
+export const readCasePipelineStatusV1 = (input) => {
+    const store = makeCaseCheckpointStoreV1(input);
+    return Effect.gen(function* () {
+        const state = yield* store.readState;
+        const ledger = yield* store.readLedger;
+        let checkpoints = {};
+        for (const stage of PIPELINE_STAGES) {
+            const value = yield* readStageCheckpoint(store, stage);
+            if (Option.isSome(value))
+                checkpoints = withCheckpoint(checkpoints, stage, value.value);
+        }
+        return {
+            ...(Option.isNone(state) ? {} : { state: state.value }),
+            checkpoints,
+            ledgerEntries: ledger.length
+        };
+    }).pipe(Effect.catchCause((cause) => Effect.succeed({ checkpoints: {}, ledgerEntries: 0, error: Cause.pretty(cause) })));
+};
+export const runRepositoryCasePipelineV1 = runCasePipelineV1;
+export const readRepositoryCasePipelineStatusV1 = readCasePipelineStatusV1;

package/dist/services/case-pipeline-v2/service.d.ts

@@ -0,0 +1,70 @@
+import { Effect } from "effect";
+import { type CaseCheckpointStoreV1 } from "../../case-checkpoint-store.js";
+import { type PipelineCheckpointOfV1 } from "../../case-pipeline-protocol.js";
+import { type PipelineCheckpointDescriptorV2, type PipelinePortsV2, type PipelineScientificIdentityV2 } from "../../case-pipeline-protocol-v2.js";
+import { type RepositoryCommandExecutionPortV1 } from "../../adapters/repository-command-runner.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import type { RepositoryBehaviorMapV1 } from "../../repository-behavior-protocol.js";
+import { type CasePipelineRunResultV1 } from "../case-pipeline/service.js";
+/** The platform port executes commands in the real isolated checkout, with the runner's exact environment. */
+export declare const makeRepositoryCommandExecutionPortV2: (ports: PipelinePortsV2) => RepositoryCommandExecutionPortV1;
+export type CasePipelineRunInputV2 = {
+    readonly identity: PipelineScientificIdentityV2;
+    readonly runtimeRoot: string;
+    readonly attemptGeneration: number;
+    readonly map: RepositoryBehaviorMapV1;
+    readonly ports: PipelinePortsV2;
+};
+export type CasePipelineRunResultV2 = {
+    readonly identityDigest: string;
+    readonly runtimeRoot: string;
+    readonly attemptGeneration: number;
+    readonly checkpoints: readonly PipelineCheckpointDescriptorV2[];
+    readonly result: CasePipelineRunResultV1;
+};
+export declare const repositoryBehaviorMapDigestV2: (map: RepositoryBehaviorMapV1) => string;
+export declare const makePortableCheckpointStoreV2: (input: {
+    readonly identity: PipelineScientificIdentityV2;
+    readonly runtimeRoot: string;
+    readonly attemptGeneration: number;
+    readonly ports: PipelinePortsV2;
+}) => Effect.Effect<{
+    store: CaseCheckpointStoreV1;
+    descriptors: () => readonly PipelineCheckpointDescriptorV2[];
+    completeAdmit: (admit: PipelineCheckpointOfV1<"admit">) => Effect.Effect<{
+        readonly kind: "stage" | "loop" | "terminal";
+        readonly version: 2;
+        readonly stage: "seed" | "spec" | "oracle" | "controls" | "tournament" | "challenge" | "admit";
+        readonly checkpointId: string;
+        readonly identityDigest: string;
+        readonly attemptGeneration: number;
+        readonly sequence: number;
+        readonly parentDigest: string;
+        readonly payloadDigest: string;
+        readonly payloadBytes: number;
+        readonly createdAt: string;
+        readonly loopName?: string | undefined;
+        readonly loopIteration?: number | undefined;
+    }, RepositoryFoundryError, never>;
+}, RepositoryFoundryError, never>;
+export declare const runCasePipelineV2: (input: CasePipelineRunInputV2) => Effect.Effect<{
+    identityDigest: string;
+    runtimeRoot: string;
+    attemptGeneration: number;
+    checkpoints: readonly {
+        readonly kind: "stage" | "loop" | "terminal";
+        readonly version: 2;
+        readonly stage: "seed" | "spec" | "oracle" | "controls" | "tournament" | "challenge" | "admit";
+        readonly checkpointId: string;
+        readonly identityDigest: string;
+        readonly attemptGeneration: number;
+        readonly sequence: number;
+        readonly parentDigest: string;
+        readonly payloadDigest: string;
+        readonly payloadBytes: number;
+        readonly createdAt: string;
+        readonly loopName?: string | undefined;
+        readonly loopIteration?: number | undefined;
+    }[];
+    result: CasePipelineRunResultV1;
+}, RepositoryFoundryError, never>;