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

package/dist/case-checkpoint-store.d.ts

@@ -0,0 +1,29 @@
+import { Effect, Option, Schema } from "effect";
+import { PipelineLedgerEntryV1, PipelineStateV1, type PipelineStageV1, type PipelineWorkCheckpointStoreV1 } from "./case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "./errors.js";
+/**
+ * Durable per-case pipeline state. Layout under `caseDirectory`:
+ * state.json, ledger.jsonl, <stage>.json for each pipeline stage, calls/, work/.
+ * Every JSON write is atomic (tmp + rename, mode 0o600) so a crash never
+ * leaves a half-written checkpoint; a checkpoint that fails to decode is
+ * treated as absent and regenerated.
+ */
+export type CaseCheckpointStoreV1 = PipelineWorkCheckpointStoreV1 & {
+    readonly caseDirectory: string;
+    readonly stagePath: (stage: PipelineStageV1) => string;
+    readonly readStage: <A>(stage: PipelineStageV1, schema: Schema.Codec<A, unknown, never, unknown>) => Effect.Effect<Option.Option<A>, RepositoryFoundryError>;
+    readonly writeStage: (stage: PipelineStageV1, value: unknown) => Effect.Effect<void, RepositoryFoundryError>;
+    /** Remove this stage's checkpoint and every later stage's checkpoint. */
+    readonly deleteFrom: (stage: PipelineStageV1) => Effect.Effect<void, RepositoryFoundryError>;
+    readonly readState: Effect.Effect<Option.Option<PipelineStateV1>, RepositoryFoundryError>;
+    readonly writeState: (state: PipelineStateV1) => Effect.Effect<void, RepositoryFoundryError>;
+    readonly appendLedger: (entry: PipelineLedgerEntryV1) => Effect.Effect<void, RepositoryFoundryError>;
+    readonly readLedger: Effect.Effect<readonly PipelineLedgerEntryV1[], RepositoryFoundryError>;
+    readonly writeCall: (operationId: string, attempt: number, payload: {
+        readonly request: unknown;
+        readonly response: unknown;
+    }) => Effect.Effect<void, RepositoryFoundryError>;
+};
+export declare const makeCaseCheckpointStoreV1: (input: {
+    readonly caseDirectory: string;
+}) => CaseCheckpointStoreV1;

package/dist/case-checkpoint-store.js

@@ -0,0 +1,133 @@
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Data, Effect, Option, Schema } from "effect";
+import { PIPELINE_STAGES, PipelineLedgerEntryV1, PipelineStateV1, pipelineStageIndexV1 } from "./case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "./errors.js";
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "checkpoint-store",
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const isMissingFile = (cause) => typeof cause === "object" &&
+    cause !== null &&
+    "code" in cause &&
+    cause.code === "ENOENT";
+/** Typed carrier so every catch callback keeps the error channel typed. */
+class CheckpointIoErrorV1 extends Data.TaggedError("CheckpointIoErrorV1") {
+}
+const describe = (cause) => cause instanceof Error && cause.message.trim().length > 0 ? cause.message : String(cause);
+/** File-name safe identifier; identifiers only, never natural language or code. */
+const fileSafe = (value) => value.replace(/[^A-Za-z0-9._-]/gu, "_");
+export const makeCaseCheckpointStoreV1 = (input) => {
+    const caseDirectory = input.caseDirectory;
+    const statePath = join(caseDirectory, "state.json");
+    const ledgerPath = join(caseDirectory, "ledger.jsonl");
+    const callsDirectory = join(caseDirectory, "calls");
+    const workDirectory = join(caseDirectory, "work");
+    const stagePath = (stage) => join(caseDirectory, `${stage}.json`);
+    const workPath = (name) => join(workDirectory, `${fileSafe(name)}.json`);
+    const ensureDirectory = (directory) => Effect.tryPromise({
+        try: () => mkdir(directory, { recursive: true, mode: 0o700 }),
+        catch: (cause) => failure(`could not create ${directory}: ${describe(cause)}`, cause)
+    });
+    const writeJsonAtomically = Effect.fnUntraced(function* (target, value) {
+        yield* ensureDirectory(dirname(target));
+        const temporary = `${target}.${randomUUID()}.tmp`;
+        const text = `${JSON.stringify(value, null, 2)}\n`;
+        yield* Effect.ensuring(Effect.gen(function* () {
+            yield* Effect.tryPromise({
+                try: () => writeFile(temporary, text, { encoding: "utf8", mode: 0o600 }),
+                catch: (cause) => failure(`could not write ${target}: ${describe(cause)}`, cause)
+            });
+            yield* Effect.tryPromise({
+                try: () => rename(temporary, target),
+                catch: (cause) => failure(`could not commit ${target}: ${describe(cause)}`, cause)
+            });
+        }), Effect.tryPromise(() => rm(temporary, { force: true })).pipe(Effect.ignore));
+    });
+    /** Missing file => none. Corrupt JSON or schema violation => none plus a warning. */
+    const readJsonLeniently = (target, schema) => Effect.gen(function* () {
+        const text = yield* Effect.tryPromise({
+            try: () => readFile(target, "utf8"),
+            catch: (cause) => new CheckpointIoErrorV1({ cause })
+        }).pipe(Effect.map(Option.some), Effect.catchIf((error) => isMissingFile(error.cause), () => Effect.succeed(Option.none())), Effect.mapError((error) => failure(`could not read ${target}: ${describe(error.cause)}`, error.cause)));
+        if (Option.isNone(text))
+            return Option.none();
+        const parsed = yield* Effect.try({
+            try: () => JSON.parse(text.value),
+            catch: (cause) => new CheckpointIoErrorV1({ cause })
+        }).pipe(Effect.result);
+        if (parsed._tag === "Failure") {
+            yield* Effect.logWarning(`checkpoint ${target} is not valid JSON and will be regenerated: ${describe(parsed.failure.cause)}`);
+            return Option.none();
+        }
+        const decoded = yield* Schema.decodeUnknownEffect(schema)(parsed.success).pipe(Effect.result);
+        if (decoded._tag === "Failure") {
+            yield* Effect.logWarning(`checkpoint ${target} failed schema decode and will be regenerated: ${describe(decoded.failure)}`);
+            return Option.none();
+        }
+        return Option.some(decoded.success);
+    });
+    const removeFile = (target) => Effect.tryPromise({
+        try: () => rm(target, { force: true }),
+        catch: (cause) => failure(`could not remove ${target}: ${describe(cause)}`, cause)
+    });
+    return {
+        caseDirectory,
+        stagePath,
+        readStage: (stage, schema) => readJsonLeniently(stagePath(stage), schema),
+        writeStage: (stage, value) => writeJsonAtomically(stagePath(stage), value),
+        deleteFrom: (stage) => Effect.forEach(PIPELINE_STAGES.filter((candidate) => pipelineStageIndexV1(candidate) >= pipelineStageIndexV1(stage)), (candidate) => removeFile(stagePath(candidate)), { discard: true }),
+        readState: Effect.gen(function* () {
+            const text = yield* Effect.tryPromise({
+                try: () => readFile(statePath, "utf8"),
+                catch: (cause) => new CheckpointIoErrorV1({ cause })
+            }).pipe(Effect.map(Option.some), Effect.catchIf((error) => isMissingFile(error.cause), () => Effect.succeed(Option.none())), Effect.mapError((error) => failure(`could not read ${statePath}: ${describe(error.cause)}`, error.cause)));
+            if (Option.isNone(text))
+                return Option.none();
+            // State carries the cumulative budget; a corrupt state file is a typed
+            // failure rather than a silent budget reset.
+            const parsed = yield* Effect.try({
+                try: () => JSON.parse(text.value),
+                catch: (cause) => failure(`${statePath} is not valid JSON: ${describe(cause)}`, cause)
+            });
+            const state = yield* Schema.decodeUnknownEffect(PipelineStateV1)(parsed).pipe(Effect.mapError((cause) => failure(`${statePath} failed schema decode: ${describe(cause)}`, cause)));
+            return Option.some(state);
+        }),
+        writeState: (state) => writeJsonAtomically(statePath, state),
+        appendLedger: (entry) => Effect.gen(function* () {
+            yield* ensureDirectory(caseDirectory);
+            yield* Effect.tryPromise({
+                try: () => appendFile(ledgerPath, `${JSON.stringify(entry)}\n`, { encoding: "utf8", mode: 0o600 }),
+                catch: (cause) => failure(`could not append ${ledgerPath}: ${describe(cause)}`, cause)
+            });
+        }),
+        readLedger: Effect.gen(function* () {
+            const text = yield* Effect.tryPromise({
+                try: () => readFile(ledgerPath, "utf8"),
+                catch: (cause) => new CheckpointIoErrorV1({ cause })
+            }).pipe(Effect.map(Option.some), Effect.catchIf((error) => isMissingFile(error.cause), () => Effect.succeed(Option.none())), Effect.mapError((error) => failure(`could not read ${ledgerPath}: ${describe(error.cause)}`, error.cause)));
+            if (Option.isNone(text))
+                return [];
+            const entries = [];
+            const lines = text.value.split("\n").filter((line) => line.trim().length > 0);
+            for (const [index, line] of lines.entries()) {
+                const decoded = yield* Effect.try({
+                    try: () => JSON.parse(line),
+                    catch: (cause) => new CheckpointIoErrorV1({ cause })
+                }).pipe(Effect.flatMap((value) => Schema.decodeUnknownEffect(PipelineLedgerEntryV1)(value)), Effect.result);
+                if (decoded._tag === "Failure") {
+                    yield* Effect.logWarning(`ledger line ${String(index + 1)} of ${ledgerPath} is unreadable and was skipped: ${describe(decoded.failure)}`);
+                    continue;
+                }
+                entries.push(decoded.success);
+            }
+            return entries;
+        }),
+        writeCall: (operationId, attempt, payload) => writeJsonAtomically(join(callsDirectory, `${fileSafe(operationId)}.attempt-${String(attempt)}.json`), { operationId, attempt, request: payload.request, response: payload.response }),
+        readWorkCheckpoint: (name, schema) => readJsonLeniently(workPath(name), schema),
+        writeWorkCheckpoint: (name, value) => writeJsonAtomically(workPath(name), value),
+        deleteWorkCheckpoint: (name) => removeFile(workPath(name))
+    };
+};

package/dist/case-pipeline-protocol-v2.d.ts

@@ -0,0 +1,184 @@
+import { type Effect, Schema } from "effect";
+import type { RepositoryCommandObservationV1 } from "./repository-execution-protocol.js";
+export declare const PIPELINE_PROTOCOL_VERSION_V2: 2;
+export declare const PIPELINE_STAGES_V2: readonly ["seed", "spec", "oracle", "controls", "tournament", "challenge", "admit"];
+export declare const pipelineDigestV2: (value: unknown) => string;
+export declare const PipelineStageV2: Schema.Literals<readonly ["seed", "spec", "oracle", "controls", "tournament", "challenge", "admit"]>;
+export type PipelineStageV2 = typeof PipelineStageV2.Type;
+export declare const PipelineDimensionV2: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly description: Schema.String;
+    readonly includes: Schema.$Array<Schema.String>;
+    readonly excludes: Schema.$Array<Schema.String>;
+}>;
+export type PipelineDimensionV2 = typeof PipelineDimensionV2.Type;
+export declare const PipelineModelRoleV2: Schema.Literals<readonly ["seed-author", "specification-author", "specification-reviewer", "oracle-author", "control-author", "adversary-author", "oracle-critic", "admission-reviewer"]>;
+export type PipelineModelRoleV2 = typeof PipelineModelRoleV2.Type;
+export declare const PipelineModelBindingV2: Schema.Struct<{
+    readonly role: Schema.Literals<readonly ["seed-author", "specification-author", "specification-reviewer", "oracle-author", "control-author", "adversary-author", "oracle-critic", "admission-reviewer"]>;
+    readonly model: Schema.String;
+    readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>;
+    readonly maximumCalls: Schema.Finite;
+    readonly maximumOutputTokens: Schema.Finite;
+}>;
+export type PipelineModelBindingV2 = typeof PipelineModelBindingV2.Type;
+export declare const PipelineScientificIdentityV2: Schema.Struct<{
+    readonly version: Schema.Literal<2>;
+    readonly repository: Schema.Struct<{
+        readonly repositoryId: Schema.String;
+        readonly repository: Schema.String;
+        readonly commitSha: Schema.String;
+        readonly treeSha: Schema.String;
+    }>;
+    readonly caseId: Schema.String;
+    readonly coverageCellId: Schema.String;
+    readonly dimension: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly includes: Schema.$Array<Schema.String>;
+        readonly excludes: Schema.$Array<Schema.String>;
+    }>;
+    readonly source: Schema.Struct<{
+        readonly referenceCommitSha: Schema.String;
+        readonly referenceTaskDigest: Schema.String;
+        readonly basisDigest: Schema.String;
+    }>;
+    readonly modelPlan: Schema.$Array<Schema.Struct<{
+        readonly role: Schema.Literals<readonly ["seed-author", "specification-author", "specification-reviewer", "oracle-author", "control-author", "adversary-author", "oracle-critic", "admission-reviewer"]>;
+        readonly model: Schema.String;
+        readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>;
+        readonly maximumCalls: Schema.Finite;
+        readonly maximumOutputTokens: Schema.Finite;
+    }>>;
+    readonly policy: Schema.Struct<{
+        readonly foundryPolicyVersion: Schema.String;
+        readonly admissionPolicyVersion: Schema.String;
+        readonly repositoryModelDigest: Schema.String;
+        readonly oracleRepetitions: Schema.Finite;
+        readonly oracleConcurrency: Schema.Finite;
+        readonly foldLimit: Schema.Finite;
+    }>;
+    readonly budget: Schema.Struct<{
+        readonly maximumModelCalls: Schema.Finite;
+        readonly maximumWallTimeMs: Schema.Finite;
+        readonly maximumArtifactBytes: Schema.Finite;
+    }>;
+}>;
+export type PipelineScientificIdentityV2 = typeof PipelineScientificIdentityV2.Type;
+export declare const decodePipelineScientificIdentityV2: (value: unknown) => PipelineScientificIdentityV2;
+export declare const pipelineScientificIdentityDigestV2: (identity: PipelineScientificIdentityV2) => string;
+export declare const PipelineCheckpointKindV2: Schema.Literals<readonly ["stage", "loop", "terminal"]>;
+export type PipelineCheckpointKindV2 = typeof PipelineCheckpointKindV2.Type;
+export declare const PipelineCheckpointDescriptorV2: Schema.Struct<{
+    readonly version: Schema.Literal<2>;
+    readonly checkpointId: Schema.String;
+    readonly identityDigest: Schema.String;
+    readonly attemptGeneration: Schema.Finite;
+    readonly sequence: Schema.Finite;
+    readonly kind: Schema.Literals<readonly ["stage", "loop", "terminal"]>;
+    readonly stage: Schema.Literals<readonly ["seed", "spec", "oracle", "controls", "tournament", "challenge", "admit"]>;
+    readonly loopName: Schema.optionalKey<Schema.String>;
+    readonly loopIteration: Schema.optionalKey<Schema.Finite>;
+    readonly parentDigest: Schema.String;
+    readonly payloadDigest: Schema.String;
+    readonly payloadBytes: Schema.Finite;
+    readonly createdAt: Schema.String;
+}>;
+export type PipelineCheckpointDescriptorV2 = typeof PipelineCheckpointDescriptorV2.Type;
+export declare const decodePipelineCheckpointDescriptorV2: (value: unknown) => PipelineCheckpointDescriptorV2;
+export declare const pipelineCheckpointDescriptorDigestV2: (descriptor: PipelineCheckpointDescriptorV2) => string;
+export declare const assertPipelineCheckpointChainV2: (identity: PipelineScientificIdentityV2, checkpoints: readonly PipelineCheckpointDescriptorV2[]) => void;
+export declare const assertPipelineCheckpointReplayV2: (accepted: PipelineCheckpointDescriptorV2, replay: PipelineCheckpointDescriptorV2) => void;
+export declare const PipelineArtifactVisibilityV2: Schema.Literals<readonly ["private", "public"]>;
+export type PipelineArtifactVisibilityV2 = typeof PipelineArtifactVisibilityV2.Type;
+export declare const PipelineArtifactDescriptorV2: Schema.Struct<{
+    readonly artifactId: Schema.String;
+    readonly identityDigest: Schema.String;
+    readonly checkpointDigest: Schema.String;
+    readonly kind: Schema.String;
+    readonly visibility: Schema.Literals<readonly ["private", "public"]>;
+    readonly sha256: Schema.String;
+    readonly bytes: Schema.Finite;
+    readonly mediaType: Schema.String;
+}>;
+export type PipelineArtifactDescriptorV2 = typeof PipelineArtifactDescriptorV2.Type;
+export declare const PipelineModelCallV2: Schema.Struct<{
+    readonly operationId: Schema.String;
+    readonly caseId: Schema.String;
+    readonly stage: Schema.Literals<readonly ["seed", "spec", "oracle", "controls", "tournament", "challenge", "admit"]>;
+    readonly role: Schema.Literals<readonly ["seed-author", "specification-author", "specification-reviewer", "oracle-author", "control-author", "adversary-author", "oracle-critic", "admission-reviewer"]>;
+    readonly model: Schema.String;
+    readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>;
+    readonly input: Schema.String;
+    readonly maximumOutputTokens: Schema.Finite;
+}>;
+export type PipelineModelCallV2 = typeof PipelineModelCallV2.Type;
+declare const PipelinePortErrorV2_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PipelinePortErrorV2";
+} & Readonly<A>;
+export declare class PipelinePortErrorV2 extends PipelinePortErrorV2_base<{
+    readonly port: "repository" | "model" | "checkpoint" | "artifact" | "execution" | "progress" | "clock";
+    readonly operation: string;
+    readonly detail: string;
+    readonly retryable: boolean;
+    readonly cause?: unknown;
+}> {
+}
+export type PipelineRepositoryPortV2 = {
+    readonly materialize: (identity: PipelineScientificIdentityV2, runtimeRoot: string) => Effect.Effect<void, PipelinePortErrorV2>;
+    readonly verify: (identity: PipelineScientificIdentityV2, runtimeRoot: string) => Effect.Effect<void, PipelinePortErrorV2>;
+};
+export type PipelineModelPortV2 = {
+    readonly complete: (call: PipelineModelCallV2) => Effect.Effect<{
+        readonly callId: string;
+        readonly text: string;
+    }, PipelinePortErrorV2>;
+};
+export type PipelineCheckpointPortV2 = {
+    readonly list: (identityDigest: string) => Effect.Effect<readonly PipelineCheckpointDescriptorV2[], PipelinePortErrorV2>;
+    readonly read: (descriptor: PipelineCheckpointDescriptorV2) => Effect.Effect<Uint8Array, PipelinePortErrorV2>;
+    readonly put: (descriptor: PipelineCheckpointDescriptorV2, payload: Uint8Array) => Effect.Effect<PipelineCheckpointDescriptorV2, PipelinePortErrorV2>;
+};
+export type PipelineArtifactPortV2 = {
+    readonly put: (descriptor: PipelineArtifactDescriptorV2, payload: Uint8Array) => Effect.Effect<PipelineArtifactDescriptorV2, PipelinePortErrorV2>;
+    readonly read: (descriptor: PipelineArtifactDescriptorV2) => Effect.Effect<Uint8Array, PipelinePortErrorV2>;
+};
+export type PipelineExecutionPortV2 = {
+    readonly run: (input: {
+        readonly operationId: string;
+        readonly runtimeRoot: string;
+        readonly command: readonly string[];
+        readonly timeoutMs: number;
+    }) => Effect.Effect<{
+        readonly exitCode: number;
+        readonly stdout: string;
+        readonly stderr: string;
+    }, PipelinePortErrorV2>;
+};
+export type PipelineProgressPortV2 = {
+    readonly emit: (event: {
+        readonly identityDigest: string;
+        readonly sequence: number;
+        readonly stage: PipelineStageV2;
+        readonly detail: string;
+    }) => Effect.Effect<void, PipelinePortErrorV2>;
+    /**
+     * Best-effort live command telemetry. Implementations enqueue synchronously;
+     * pipeline execution never waits for delivery.
+     */
+    readonly observeCommand?: (event: RepositoryCommandObservationV1) => void;
+};
+export type PipelineClockPortV2 = {
+    readonly now: Effect.Effect<Date, PipelinePortErrorV2>;
+    readonly sleep: (milliseconds: number) => Effect.Effect<void, PipelinePortErrorV2>;
+};
+export type PipelinePortsV2 = {
+    readonly repository: PipelineRepositoryPortV2;
+    readonly model: PipelineModelPortV2;
+    readonly checkpoints: PipelineCheckpointPortV2;
+    readonly artifacts: PipelineArtifactPortV2;
+    readonly execution: PipelineExecutionPortV2;
+    readonly progress: PipelineProgressPortV2;
+    readonly clock: PipelineClockPortV2;
+};
+export {};

package/dist/case-pipeline-protocol-v2.js

@@ -0,0 +1,193 @@
+import { createHash } from "node:crypto";
+import { assertExplicitEvalModel } from "@velum-labs/routekit-eval-contracts";
+import { Data, Schema } from "effect";
+export const PIPELINE_PROTOCOL_VERSION_V2 = 2;
+export const PIPELINE_STAGES_V2 = [
+    "seed",
+    "spec",
+    "oracle",
+    "controls",
+    "tournament",
+    "challenge",
+    "admit"
+];
+const Sha256V2 = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => /^[a-f0-9]{64}$/u.test(value) ? undefined : "must be a lowercase SHA-256 digest")));
+const CommitShaV2 = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => /^[a-f0-9]{40}$/u.test(value) ? undefined : "must be a lowercase Git commit SHA")));
+const BoundedIdV2 = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => value.length >= 1 && value.length <= 256 && value.trim() === value
+    ? undefined
+    : "must be a trimmed identifier between 1 and 256 characters")));
+const PositiveIntegerV2 = Schema.Finite.pipe(Schema.check(Schema.makeFilter((value) => Number.isInteger(value) && value > 0 ? undefined : "must be a positive integer")));
+const NonNegativeIntegerV2 = Schema.Finite.pipe(Schema.check(Schema.makeFilter((value) => Number.isInteger(value) && value >= 0 ? undefined : "must be a non-negative integer")));
+const ExplicitModelV2 = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => {
+    try {
+        assertExplicitEvalModel(value, "author");
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : "model must be explicit";
+    }
+})));
+const stableJsonV2 = (value) => JSON.stringify(value, (_key, entry) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+        return entry;
+    const record = entry;
+    return Object.fromEntries(Object.keys(record)
+        .sort()
+        .map((key) => [key, record[key]]));
+});
+export const pipelineDigestV2 = (value) => createHash("sha256").update(stableJsonV2(value), "utf8").digest("hex");
+export const PipelineStageV2 = Schema.Literals(PIPELINE_STAGES_V2);
+export const PipelineDimensionV2 = Schema.Struct({
+    id: BoundedIdV2,
+    description: Schema.String,
+    includes: Schema.Array(Schema.String),
+    excludes: Schema.Array(Schema.String)
+});
+export const PipelineModelRoleV2 = Schema.Literals([
+    "seed-author",
+    "specification-author",
+    "specification-reviewer",
+    "oracle-author",
+    "control-author",
+    "adversary-author",
+    "oracle-critic",
+    "admission-reviewer"
+]);
+export const PipelineModelBindingV2 = Schema.Struct({
+    role: PipelineModelRoleV2,
+    model: ExplicitModelV2,
+    reasoningEffort: Schema.Literals(["low", "medium", "high", "xhigh"]),
+    maximumCalls: PositiveIntegerV2,
+    maximumOutputTokens: PositiveIntegerV2
+});
+export const PipelineScientificIdentityV2 = Schema.Struct({
+    version: Schema.Literal(PIPELINE_PROTOCOL_VERSION_V2),
+    repository: Schema.Struct({
+        repositoryId: BoundedIdV2,
+        repository: Schema.String,
+        commitSha: CommitShaV2,
+        treeSha: CommitShaV2
+    }),
+    caseId: BoundedIdV2,
+    coverageCellId: BoundedIdV2,
+    dimension: PipelineDimensionV2,
+    source: Schema.Struct({
+        referenceCommitSha: CommitShaV2,
+        referenceTaskDigest: Sha256V2,
+        basisDigest: Sha256V2
+    }),
+    modelPlan: Schema.Array(PipelineModelBindingV2),
+    policy: Schema.Struct({
+        foundryPolicyVersion: BoundedIdV2,
+        admissionPolicyVersion: BoundedIdV2,
+        repositoryModelDigest: Sha256V2,
+        oracleRepetitions: PositiveIntegerV2,
+        oracleConcurrency: PositiveIntegerV2,
+        foldLimit: PositiveIntegerV2
+    }),
+    budget: Schema.Struct({
+        maximumModelCalls: PositiveIntegerV2,
+        maximumWallTimeMs: PositiveIntegerV2,
+        maximumArtifactBytes: PositiveIntegerV2
+    })
+});
+export const decodePipelineScientificIdentityV2 = (value) => {
+    const decoded = Schema.decodeUnknownSync(PipelineScientificIdentityV2, {
+        onExcessProperty: "error"
+    })(value);
+    if (decoded.modelPlan.length === 0) {
+        throw new Error("portable foundry V2 requires at least one explicit model binding");
+    }
+    const roles = decoded.modelPlan.map(({ role }) => role);
+    if (new Set(roles).size !== roles.length) {
+        throw new Error("portable foundry V2 model roles must be unique");
+    }
+    return decoded;
+};
+export const pipelineScientificIdentityDigestV2 = (identity) => pipelineDigestV2(decodePipelineScientificIdentityV2(identity));
+export const PipelineCheckpointKindV2 = Schema.Literals(["stage", "loop", "terminal"]);
+export const PipelineCheckpointDescriptorV2 = Schema.Struct({
+    version: Schema.Literal(PIPELINE_PROTOCOL_VERSION_V2),
+    checkpointId: BoundedIdV2,
+    identityDigest: Sha256V2,
+    attemptGeneration: PositiveIntegerV2,
+    sequence: PositiveIntegerV2,
+    kind: PipelineCheckpointKindV2,
+    stage: PipelineStageV2,
+    loopName: Schema.optionalKey(BoundedIdV2),
+    loopIteration: Schema.optionalKey(NonNegativeIntegerV2),
+    parentDigest: Sha256V2,
+    payloadDigest: Sha256V2,
+    payloadBytes: NonNegativeIntegerV2,
+    createdAt: Schema.String
+});
+export const decodePipelineCheckpointDescriptorV2 = (value) => {
+    const decoded = Schema.decodeUnknownSync(PipelineCheckpointDescriptorV2, {
+        onExcessProperty: "error"
+    })(value);
+    const loopFieldsPresent = decoded.loopName !== undefined && decoded.loopIteration !== undefined;
+    if ((decoded.kind === "loop") !== loopFieldsPresent) {
+        throw new Error("loop checkpoints require both loopName and loopIteration, and only loops use them");
+    }
+    return decoded;
+};
+export const pipelineCheckpointDescriptorDigestV2 = (descriptor) => pipelineDigestV2(decodePipelineCheckpointDescriptorV2(descriptor));
+export const assertPipelineCheckpointChainV2 = (identity, checkpoints) => {
+    const identityDigest = pipelineScientificIdentityDigestV2(identity);
+    let parentDigest = identityDigest;
+    let priorSequence = 0;
+    let priorStageIndex = -1;
+    let attemptGeneration = 0;
+    for (const checkpointValue of checkpoints) {
+        const checkpoint = decodePipelineCheckpointDescriptorV2(checkpointValue);
+        if (checkpoint.identityDigest !== identityDigest) {
+            throw new Error("checkpoint scientific identity does not match");
+        }
+        if (checkpoint.sequence !== priorSequence + 1) {
+            throw new Error("checkpoint sequence must be contiguous and start at one");
+        }
+        if (checkpoint.parentDigest !== parentDigest) {
+            throw new Error("checkpoint parent digest does not match the accepted chain head");
+        }
+        const stageIndex = PIPELINE_STAGES_V2.indexOf(checkpoint.stage);
+        if (stageIndex < priorStageIndex) {
+            throw new Error("checkpoint stages cannot move backwards");
+        }
+        if (checkpoint.attemptGeneration < attemptGeneration) {
+            throw new Error("checkpoint attempt generation cannot move backwards");
+        }
+        parentDigest = pipelineCheckpointDescriptorDigestV2(checkpoint);
+        priorSequence = checkpoint.sequence;
+        priorStageIndex = stageIndex;
+        attemptGeneration = checkpoint.attemptGeneration;
+    }
+};
+export const assertPipelineCheckpointReplayV2 = (accepted, replay) => {
+    if (accepted.checkpointId !== replay.checkpointId ||
+        pipelineCheckpointDescriptorDigestV2(accepted) !== pipelineCheckpointDescriptorDigestV2(replay)) {
+        throw new Error("checkpoint replay conflicts with the accepted immutable checkpoint");
+    }
+};
+export const PipelineArtifactVisibilityV2 = Schema.Literals(["private", "public"]);
+export const PipelineArtifactDescriptorV2 = Schema.Struct({
+    artifactId: BoundedIdV2,
+    identityDigest: Sha256V2,
+    checkpointDigest: Sha256V2,
+    kind: BoundedIdV2,
+    visibility: PipelineArtifactVisibilityV2,
+    sha256: Sha256V2,
+    bytes: NonNegativeIntegerV2,
+    mediaType: BoundedIdV2
+});
+export const PipelineModelCallV2 = Schema.Struct({
+    operationId: BoundedIdV2,
+    caseId: BoundedIdV2,
+    stage: PipelineStageV2,
+    role: PipelineModelRoleV2,
+    model: ExplicitModelV2,
+    reasoningEffort: Schema.Literals(["low", "medium", "high", "xhigh"]),
+    input: Schema.String,
+    maximumOutputTokens: PositiveIntegerV2
+});
+export class PipelinePortErrorV2 extends Data.TaggedError("PipelinePortErrorV2") {
+}