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

package/dist/test/case-pipeline-foundation.test.js

@@ -0,0 +1,535 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { Effect, Fiber, Layer, Option, Schema } from "effect";
+import { TestClock } from "effect/testing";
+import { makeCaseCheckpointStoreV1 } from "../case-checkpoint-store.js";
+import { checkpointDigestV1, makePipelineCaseContextV1, nextPipelineStageV1, PIPELINE_STAGES, PipelineBudgetExhaustedError, pipelineScientificIdentityDigestV1, pipelineStageToProgressStageV1 } from "../case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "../errors.js";
+import { BudgetedLanguageModelLive, budgetExhaustedErrorOfV1, budgetSnapshotV1, generateWithFeedbackV1, isStructuredOutputInvalidV1, makePipelineStateAccessorV1, structuredOutputInvalidResponseTextV1 } from "../services/budgeted-model/service.js";
+import { runCasePipelineV1 } from "../services/case-pipeline/service.js";
+import { reportFoundryAuthoringArtifactV1 } from "../services/foundry-progress/service.js";
+import { RepositoryFoundryLanguageModel } from "../services/language-model/service.js";
+const Tiny = Schema.Struct({ version: Schema.Literal(1), stage: Schema.String, n: Schema.Finite });
+const Answer = Schema.Struct({ answer: Schema.String });
+const assignment = {
+    role: "spec-writer",
+    model: "openai/gpt-6-astra",
+    reasoningEffort: "high"
+};
+const dimension = { id: "dim", description: "A dimension.", includes: [], excludes: [] };
+const initialState = (overrides = {}) => ({
+    version: 1,
+    caseId: "case-1",
+    repositoryRoot: "/repo",
+    dimension,
+    model: "openai/gpt-6-astra",
+    stage: "spec",
+    status: "running",
+    startedAt: "2026-09-08T00:00:00.000Z",
+    updatedAt: "2026-09-08T00:00:00.000Z",
+    modelCalls: 0,
+    elapsedMs: 0,
+    resumeCount: 0,
+    folds: 0,
+    ...overrides
+});
+async function caseDirectory(t) {
+    const root = await mkdtemp(join(tmpdir(), "case-pipeline-foundation-"));
+    t.after(() => rm(root, { recursive: true, force: true }));
+    return join(root, "case");
+}
+/** A fake inner model; the wrapper must never see the transport directly. */
+const fakeInner = (reply) => {
+    const state = { calls: 0 };
+    const generateAssignedStructured = (input) => Effect.gen(function* () {
+        state.calls += 1;
+        const raw = yield* reply({
+            operationId: input.operationId,
+            input: input.input,
+            attempt: state.calls
+        });
+        const value = yield* Schema.decodeUnknownEffect(input.outputSchema)(raw).pipe(Effect.mapError((cause) => new RepositoryFoundryError({
+            operation: "invoke-language-model",
+            detail: `language-model role ${input.assignment.role} violated ${input.schemaName}`,
+            cause
+        })));
+        return {
+            value,
+            call: {
+                operationId: input.operationId,
+                role: input.assignment.role,
+                model: input.assignment.model,
+                reasoningEffort: input.assignment.reasoningEffort,
+                callId: `call-${String(state.calls)}`
+            }
+        };
+    });
+    return {
+        get calls() {
+            return state.calls;
+        },
+        generateAssignedStructured,
+        generateStructured: (input) => generateAssignedStructured({
+            ...input,
+            assignment: { role: input.role, model: "openai/gpt-6-astra", reasoningEffort: "high" }
+        })
+    };
+};
+async function harness(t, options) {
+    const directory = await caseDirectory(t);
+    const store = makeCaseCheckpointStoreV1({ caseDirectory: directory });
+    const state = await Effect.runPromise(makePipelineStateAccessorV1(options.state ?? initialState()));
+    const sleeps = [];
+    const inner = fakeInner(options.reply);
+    const layer = BudgetedLanguageModelLive({
+        store,
+        state,
+        budget: options.budget ?? { maxModelCalls: 10, maxWallMs: 60 * 60_000 },
+        startedAtMs: Date.now(),
+        inner,
+        sleep: (ms) => Effect.sync(() => {
+            sleeps.push(ms);
+        })
+    });
+    const generate = (input = { ask: "value" }) => Effect.gen(function* () {
+        const model = yield* RepositoryFoundryLanguageModel;
+        return yield* model.generateAssignedStructured({
+            assignment,
+            operationId: "op",
+            instructions: "Answer.",
+            input,
+            schemaName: "Answer",
+            outputSchema: Answer,
+            maximumOutputTokens: 64
+        });
+    });
+    return { directory, store, state, sleeps, inner, layer, generate };
+}
+test("checkpoint store writes atomically, reads back, and deletes this stage and later stages", async (t) => {
+    const directory = await caseDirectory(t);
+    const store = makeCaseCheckpointStoreV1({ caseDirectory: directory });
+    await Effect.runPromise(Effect.gen(function* () {
+        for (const [index, stage] of PIPELINE_STAGES.entries()) {
+            yield* store.writeStage(stage, { version: 1, stage, n: index });
+        }
+        const oracle = yield* store.readStage("oracle", Tiny);
+        assert.deepEqual(oracle, Option.some({ version: 1, stage: "oracle", n: 2 }));
+        yield* store.deleteFrom("controls");
+        assert.deepEqual(yield* store.readStage("oracle", Tiny), Option.some({ version: 1, stage: "oracle", n: 2 }));
+        assert.deepEqual(yield* store.readStage("controls", Tiny), Option.none());
+        assert.deepEqual(yield* store.readStage("admit", Tiny), Option.none());
+        yield* store.writeState(initialState());
+        const state = yield* store.readState;
+        assert.equal(Option.isSome(state) && state.value.caseId, "case-1");
+        yield* store.writeCall("spec:writer/1", 2, { request: { a: 1 }, response: { b: 2 } });
+        yield* store.writeWorkCheckpoint("reference/qualification", {
+            version: 1,
+            stage: "seed",
+            n: 7
+        });
+        assert.deepEqual(yield* store.readWorkCheckpoint("reference/qualification", Tiny), Option.some({ version: 1, stage: "seed", n: 7 }));
+        yield* store.deleteWorkCheckpoint("reference/qualification");
+        assert.deepEqual(yield* store.readWorkCheckpoint("reference/qualification", Tiny), Option.none());
+    }));
+    const entries = await readdir(directory);
+    assert.ok(!entries.some((entry) => entry.endsWith(".tmp")), "no temporary files remain");
+    assert.equal((await stat(join(directory, "seed.json"))).mode & 0o777, 0o600);
+    assert.equal((await stat(directory)).mode & 0o777, 0o700);
+    const calls = await readdir(join(directory, "calls"));
+    assert.deepEqual(calls, ["spec_writer_1.attempt-2.json"]);
+    assert.deepEqual(JSON.parse(await readFile(join(directory, "calls", calls[0]), "utf8")), {
+        operationId: "spec:writer/1",
+        attempt: 2,
+        request: { a: 1 },
+        response: { b: 2 }
+    });
+});
+test("a checkpoint that fails schema decode or JSON parse reads as absent, never as a failure", async (t) => {
+    const directory = await caseDirectory(t);
+    const store = makeCaseCheckpointStoreV1({ caseDirectory: directory });
+    await Effect.runPromise(store.writeStage("seed", { version: 2, stage: "seed", n: "nope" }));
+    await writeFile(join(directory, "spec.json"), "{ not json", "utf8");
+    const [seed, spec, missing] = await Effect.runPromise(Effect.all([
+        store.readStage("seed", Tiny),
+        store.readStage("spec", Tiny),
+        store.readStage("admit", Tiny)
+    ]));
+    assert.deepEqual(seed, Option.none());
+    assert.deepEqual(spec, Option.none());
+    assert.deepEqual(missing, Option.none());
+});
+test("budget exhaustion fails before the inner model is called", async (t) => {
+    const run = await harness(t, {
+        reply: () => Effect.succeed({ answer: "never" }),
+        state: initialState({ modelCalls: 3 }),
+        budget: { maxModelCalls: 3, maxWallMs: 60_000 }
+    });
+    const exit = await Effect.runPromise(run.generate().pipe(Effect.provide(run.layer), Effect.flip));
+    const exhausted = budgetExhaustedErrorOfV1(exit);
+    assert.ok(exhausted instanceof PipelineBudgetExhaustedError);
+    assert.equal(exhausted.modelCalls, 3);
+    assert.equal(exhausted.stage, "spec");
+    assert.equal(run.inner.calls, 0);
+    const ledger = await Effect.runPromise(run.store.readLedger);
+    assert.deepEqual(ledger, []);
+});
+test("transport failures are retried with backoff and ledgered, then the received call is counted once", async (t) => {
+    const run = await harness(t, {
+        reply: ({ attempt }) => attempt <= 2
+            ? Effect.fail(new RepositoryFoundryError({
+                operation: "invoke-language-model",
+                detail: attempt === 1
+                    ? "language-model role spec-writer failed: RouteKit Eval could not complete authoring-evaluations: author model request failed before response headers: unknown"
+                    : `language-model role spec-writer failed: Transport error: fetch failed (attempt ${String(attempt)})`
+            }))
+            : Effect.succeed({ answer: "ok" })
+    });
+    const result = await Effect.runPromise(Effect.gen(function* () {
+        const generated = yield* run.generate();
+        const snapshot = yield* budgetSnapshotV1;
+        return { generated, snapshot };
+    }).pipe(Effect.provide(run.layer)));
+    assert.deepEqual(result.generated.value, { answer: "ok" });
+    assert.equal(result.generated.call.callId, "call-3");
+    assert.deepEqual(run.sleeps, [5_000, 15_000]);
+    assert.equal(result.snapshot.modelCalls, 1);
+    assert.equal(result.snapshot.remainingCalls, 9);
+    assert.equal(run.inner.calls, 3);
+    const persisted = await Effect.runPromise(run.store.readState);
+    assert.equal(Option.isSome(persisted) && persisted.value.modelCalls, 1);
+    const ledger = await Effect.runPromise(run.store.readLedger);
+    assert.deepEqual(ledger.map((entry) => [entry.phase, entry.attempt]), [
+        ["start", 1],
+        ["retry", 1],
+        ["start", 2],
+        ["retry", 2],
+        ["start", 3],
+        ["received", 3],
+        ["validated", 3]
+    ]);
+    assert.ok(ledger.every((entry) => entry.role === "spec-writer" && entry.model === assignment.model));
+    assert.equal(ledger[5].callId, "call-3");
+    assert.ok((ledger[0].inputBytes ?? 0) > 0);
+    assert.ok((ledger[5].outputBytes ?? 0) > 0);
+});
+test("a transport retry that cannot fit in the wall budget fails as exhausted, not as a case failure", async (t) => {
+    const run = await harness(t, {
+        reply: () => Effect.fail(new RepositoryFoundryError({
+            operation: "invoke-language-model",
+            detail: "language-model role spec-writer failed: connect ECONNREFUSED 127.0.0.1:8787"
+        })),
+        budget: { maxModelCalls: 10, maxWallMs: 4_000 }
+    });
+    const error = await Effect.runPromise(run.generate().pipe(Effect.provide(run.layer), Effect.flip));
+    assert.ok(budgetExhaustedErrorOfV1(error) instanceof PipelineBudgetExhaustedError);
+    assert.deepEqual(run.sleeps, []);
+    assert.equal(run.inner.calls, 1);
+});
+test("the orchestrator interrupts a host stage at the remaining cumulative wall deadline without persisting its checkpoint", async (t) => {
+    const directory = await caseDirectory(t);
+    const store = makeCaseCheckpointStoreV1({ caseDirectory: directory });
+    const context = makePipelineCaseContextV1({
+        repositoryRoot: "/repo",
+        caseId: "case-host-wall",
+        caseDirectory: directory,
+        dimension,
+        primaryModel: "openai/gpt-6-astra",
+        budget: { maxModelCalls: 10, maxWallMs: 100 }
+    });
+    const map = {
+        version: 1,
+        repository: { root: "/repo", commit: "head", requestedRef: "HEAD", tree: "tree" },
+        packages: [],
+        publicSurfaces: [],
+        protocols: [],
+        commands: [],
+        tests: [],
+        testBindings: [],
+        historyEpisodes: [],
+        workloadSignals: [],
+        blindSpots: []
+    };
+    const prior = initialState({
+        caseId: context.caseId,
+        repositoryRoot: context.repositoryRoot,
+        identityDigest: pipelineScientificIdentityDigestV1(context, map),
+        elapsedMs: 75
+    });
+    const inner = {
+        generateAssignedStructured: () => Effect.never,
+        generateStructured: () => Effect.never
+    };
+    await Effect.runPromise(store.writeState(prior));
+    const result = await Effect.runPromise(Effect.gen(function* () {
+        const fiber = yield* runCasePipelineV1({ context, map, store }).pipe(Effect.forkChild);
+        yield* TestClock.adjust(25);
+        return yield* Fiber.join(fiber);
+    }).pipe(Effect.provide(Layer.mergeAll(Layer.succeed(RepositoryFoundryLanguageModel, inner), TestClock.layer()))));
+    assert.equal(result.state.status, "exhausted");
+    assert.equal(result.state.stage, "seed");
+    assert.equal(result.state.modelCalls, 0);
+    assert.equal(result.state.elapsedMs, 100);
+    assert.match(result.state.reason ?? "", /exhausted its budget during seed/u);
+    assert.deepEqual(await Effect.runPromise(store.readStage("seed", Tiny)), Option.none());
+    const extended = { ...context, budget: { maxModelCalls: 10, maxWallMs: 200 } };
+    const resumed = await Effect.runPromise(Effect.gen(function* () {
+        const fiber = yield* runCasePipelineV1({ context: extended, map, store }).pipe(Effect.forkChild);
+        yield* TestClock.adjust(100);
+        return yield* Fiber.join(fiber);
+    }).pipe(Effect.provide(Layer.mergeAll(Layer.succeed(RepositoryFoundryLanguageModel, inner), TestClock.layer()))));
+    assert.equal(resumed.state.status, "exhausted");
+    assert.equal(resumed.state.elapsedMs, 200, "a resume receives only the extended remainder");
+    assert.ok(resumed.state.resumeCount >= 1);
+    assert.deepEqual(await Effect.runPromise(store.readStage("seed", Tiny)), Option.none());
+});
+test("received-but-invalid responses count as model calls and surface as structured-output-invalid", async (t) => {
+    const run = await harness(t, {
+        reply: () => Effect.succeed({ answer: 42 })
+    });
+    const error = await Effect.runPromise(run.generate().pipe(Effect.provide(run.layer), Effect.flip));
+    assert.ok(error instanceof RepositoryFoundryError);
+    assert.ok(isStructuredOutputInvalidV1(error));
+    assert.match(error.detail, /^structured-output-invalid: language-model role spec-writer violated Answer/u);
+    const persisted = await Effect.runPromise(run.store.readState);
+    assert.equal(Option.isSome(persisted) && persisted.value.modelCalls, 1);
+    assert.equal(run.sleeps.length, 0);
+    const ledger = await Effect.runPromise(run.store.readLedger);
+    assert.deepEqual(ledger.map((entry) => entry.phase), ["start", "received", "failed"]);
+});
+test("a response observed through the progress artifact is counted and its raw text is kept for feedback", async (t) => {
+    const run = await harness(t, {
+        reply: ({ operationId }) => Effect.gen(function* () {
+            yield* reportFoundryAuthoringArtifactV1({
+                version: 1,
+                operationId,
+                role: "spec-writer",
+                model: assignment.model,
+                reasoningEffort: "high",
+                schemaName: "Answer",
+                validation: "received",
+                request: { instructions: "Answer.", input: {}, jsonSchema: {}, maximumOutputTokens: 64 },
+                response: { text: "{ answer: unquoted }", callId: "provider-1" }
+            });
+            return yield* new RepositoryFoundryError({
+                operation: "invoke-language-model",
+                detail: "unexpected decoder failure without a known marker"
+            });
+        })
+    });
+    const error = await Effect.runPromise(run.generate().pipe(Effect.provide(run.layer), Effect.flip));
+    assert.ok(isStructuredOutputInvalidV1(error));
+    assert.equal(structuredOutputInvalidResponseTextV1(error), "{ answer: unquoted }");
+    const persisted = await Effect.runPromise(run.store.readState);
+    assert.equal(Option.isSome(persisted) && persisted.value.modelCalls, 1);
+    const ledger = await Effect.runPromise(run.store.readLedger);
+    assert.equal(ledger[1].phase, "received");
+    assert.equal(ledger[1].callId, "provider-1");
+    const calls = await readdir(join(run.directory, "calls"));
+    const saved = JSON.parse(await readFile(join(run.directory, "calls", calls[0]), "utf8"));
+    assert.equal(saved.response.text, "{ answer: unquoted }");
+});
+test("generateWithFeedbackV1 re-calls the same role with the prior output and findings until validation is clean", async (t) => {
+    const seen = [];
+    const run = await harness(t, {
+        reply: ({ operationId, input, attempt }) => Effect.sync(() => {
+            seen.push({ operationId, input });
+            if (attempt === 1)
+                return "not even an object";
+            if (attempt === 2)
+                return { answer: "too short" };
+            return { answer: "a complete answer" };
+        })
+    });
+    const result = await Effect.runPromise(generateWithFeedbackV1({
+        assignment,
+        operationId: "spec:analysis",
+        instructions: "Answer.",
+        input: { ask: "value" },
+        schemaName: "Answer",
+        outputSchema: Answer,
+        maximumOutputTokens: 64,
+        validate: (value) => Effect.succeed(value.answer.length < 12
+            ? [{ kind: "contract", message: "answer must be complete", path: "answer" }]
+            : [])
+    }).pipe(Effect.provide(run.layer)));
+    assert.deepEqual(result.value, { answer: "a complete answer" });
+    assert.equal(result.attempts, 3);
+    assert.equal(result.feedback.length, 2);
+    assert.deepEqual(seen.map((entry) => entry.operationId), ["spec:analysis", "spec:analysis:attempt-2", "spec:analysis:attempt-3"]);
+    assert.deepEqual(seen[0].input, { ask: "value" });
+    const second = seen[1].input;
+    assert.equal(second.ask, "value");
+    assert.equal(second.hostFeedback.attempt, 1);
+    assert.equal(second.hostFeedback.findings[0].kind, "schema");
+    const third = seen[2].input;
+    assert.equal(third.hostFeedback.attempt, 2);
+    assert.deepEqual(third.hostFeedback.priorOutput, { answer: "too short" });
+    assert.deepEqual(third.hostFeedback.findings, [
+        { kind: "contract", message: "answer must be complete", path: "answer" }
+    ]);
+    const snapshot = await Effect.runPromise(budgetSnapshotV1.pipe(Effect.provide(run.layer)));
+    assert.equal(snapshot.modelCalls, 3);
+});
+test("generateWithFeedbackV1 reports an unresolved loop as a recoverable foundry error and honours the global budget", async (t) => {
+    const run = await harness(t, {
+        reply: () => Effect.succeed({ answer: "x" }),
+        budget: { maxModelCalls: 2, maxWallMs: 60_000 }
+    });
+    const unresolved = await Effect.runPromise(generateWithFeedbackV1({
+        assignment,
+        operationId: "loop",
+        instructions: "Answer.",
+        input: [1, 2],
+        schemaName: "Answer",
+        outputSchema: Answer,
+        maximumOutputTokens: 64,
+        maxAttempts: 2,
+        validate: () => Effect.succeed([{ kind: "critique", message: "never good" }])
+    }).pipe(Effect.provide(run.layer), Effect.flip));
+    assert.ok(unresolved instanceof RepositoryFoundryError);
+    assert.match(unresolved.detail, /^feedback-loop-unresolved: critique: never good/u);
+    const exhausted = await Effect.runPromise(generateWithFeedbackV1({
+        assignment,
+        operationId: "loop-2",
+        instructions: "Answer.",
+        input: [1, 2],
+        schemaName: "Answer",
+        outputSchema: Answer,
+        maximumOutputTokens: 64,
+        validate: () => Effect.succeed([{ kind: "critique", message: "never good" }])
+    }).pipe(Effect.provide(run.layer), Effect.flip));
+    assert.ok(exhausted instanceof PipelineBudgetExhaustedError);
+});
+test("feedback continuation revalidates a received response after interruption without buying another call", async (t) => {
+    const run = await harness(t, {
+        reply: () => Effect.succeed({ answer: "retained answer" }),
+        budget: { maxModelCalls: 1, maxWallMs: 60_000 }
+    });
+    let interrupt = true;
+    let validations = 0;
+    const invoke = () => generateWithFeedbackV1({
+        assignment,
+        operationId: "durable:control",
+        instructions: "Answer.",
+        input: { task: "value" },
+        schemaName: "Answer",
+        outputSchema: Answer,
+        maximumOutputTokens: 64,
+        checkpoint: {
+            store: makeCaseCheckpointStoreV1({ caseDirectory: run.directory }),
+            binding: { commit: "pinned", validationRecipe: "sanity" }
+        },
+        validate: () => Effect.gen(function* () {
+            validations += 1;
+            if (interrupt)
+                return yield* Effect.interrupt;
+            return [];
+        })
+    }).pipe(Effect.provide(run.layer));
+    await Effect.runPromiseExit(invoke());
+    interrupt = false;
+    const resumed = await Effect.runPromise(invoke());
+    assert.deepEqual(resumed.value, { answer: "retained answer" });
+    assert.equal(resumed.attempts, 1);
+    assert.equal(validations, 2, "resumption must execute validation, not promote authoring to proof");
+    const snapshot = await Effect.runPromise(budgetSnapshotV1.pipe(Effect.provide(run.layer)));
+    assert.equal(snapshot.modelCalls, 1, "pending validation needs no remaining model budget");
+});
+test("feedback continuation preserves schema and host findings across reconstruction", async (t) => {
+    const seen = [];
+    let interrupted = false;
+    const run = await harness(t, {
+        reply: ({ input, attempt }) => {
+            seen.push(input);
+            if (attempt === 1)
+                return Effect.succeed("invalid schema");
+            if (attempt === 2)
+                return Effect.succeed({ answer: "needs repair" });
+            if (!interrupted) {
+                interrupted = true;
+                return Effect.interrupt;
+            }
+            return Effect.succeed({ answer: "complete" });
+        }
+    });
+    const invoke = () => generateWithFeedbackV1({
+        assignment,
+        operationId: "durable:findings",
+        instructions: "Answer.",
+        input: { task: "value" },
+        schemaName: "Answer",
+        outputSchema: Answer,
+        maximumOutputTokens: 64,
+        checkpoint: {
+            store: makeCaseCheckpointStoreV1({ caseDirectory: run.directory }),
+            binding: { validator: 1 }
+        },
+        validate: ({ answer }) => Effect.succeed(answer === "complete" ? [] : [
+            { kind: "execution", message: "concrete sanity failure" }
+        ])
+    }).pipe(Effect.provide(run.layer));
+    await Effect.runPromiseExit(invoke());
+    const resumed = await Effect.runPromise(invoke());
+    assert.equal(resumed.attempts, 3);
+    assert.equal(resumed.feedback.length, 2);
+    assert.equal(resumed.feedback[0].findings[0].kind, "schema");
+    assert.deepEqual(seen.at(-1), seen.at(-2));
+    assert.deepEqual(seen.at(-1).hostFeedback, {
+        attempt: 2,
+        findings: [{ kind: "execution", message: "concrete sanity failure" }],
+        priorOutput: { answer: "needs repair" }
+    });
+});
+test("feedback continuation invalidates changed host validation inputs even when the prompt is unchanged", async (t) => {
+    let calls = 0;
+    const run = await harness(t, {
+        reply: () => Effect.succeed({ answer: `response-${++calls}` })
+    });
+    const invoke = (binding) => generateWithFeedbackV1({
+        assignment,
+        operationId: "durable:binding",
+        instructions: "Answer.",
+        input: { task: "same-visible-task" },
+        schemaName: "Answer",
+        outputSchema: Answer,
+        maximumOutputTokens: 64,
+        checkpoint: { store: run.store, binding },
+        validate: () => Effect.succeed([])
+    }).pipe(Effect.provide(run.layer));
+    assert.equal((await Effect.runPromise(invoke({ commit: "a" }))).value.answer, "response-1");
+    assert.equal((await Effect.runPromise(invoke({ commit: "a" }))).value.answer, "response-1");
+    assert.equal((await Effect.runPromise(invoke({ commit: "b" }))).value.answer, "response-2");
+    assert.equal(calls, 2);
+});
+test("protocol helpers: stable digests, progress stage mapping, stage order, and context defaults", () => {
+    assert.equal(checkpointDigestV1({ b: 1, a: [{ d: 2, c: 3 }] }), checkpointDigestV1({ a: [{ c: 3, d: 2 }], b: 1 }));
+    assert.notEqual(checkpointDigestV1({ a: 1 }), checkpointDigestV1({ a: 2 }));
+    assert.deepEqual(PIPELINE_STAGES.map(pipelineStageToProgressStageV1), [
+        "replay-qualify",
+        "author-specification",
+        "oracle-design",
+        "valid-solutions",
+        "tournament",
+        "held-out-tournament",
+        "admit"
+    ]);
+    assert.equal(nextPipelineStageV1("seed"), "spec");
+    assert.equal(nextPipelineStageV1("admit"), "done");
+    const context = makePipelineCaseContextV1({
+        repositoryRoot: "/repo",
+        caseId: "case-1",
+        caseDirectory: "/repo/.routekit/pipeline/case-1",
+        dimension,
+        primaryModel: "openai/gpt-6-astra",
+        budget: { maxModelCalls: 40, maxWallMs: 3_600_000 },
+        reasoningEffort: "medium"
+    });
+    assert.equal(context.reasoningEffort, "medium");
+    assert.equal(context.oracleRepetitions, 2);
+    assert.equal(context.foldLimit, 2);
+    assert.ok(context.modelPlan.assignments.some((entry) => entry.role === "oracle-critic"));
+    assert.ok(context.modelPlan.assignments.every((entry) => entry.reasoningEffort === "high"));
+});

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

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

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

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { assertPipelineCheckpointChainV2, assertPipelineCheckpointReplayV2, decodePipelineCheckpointDescriptorV2, decodePipelineScientificIdentityV2, pipelineCheckpointDescriptorDigestV2, pipelineScientificIdentityDigestV2 } from "../case-pipeline-protocol-v2.js";
+const sha = "a".repeat(64);
+const identity = {
+    version: 2,
+    repository: {
+        repositoryId: "repo-1",
+        repository: "velum-labs/routekit",
+        commitSha: "b".repeat(40),
+        treeSha: "c".repeat(40)
+    },
+    caseId: "case-1",
+    coverageCellId: "cell-1",
+    dimension: {
+        id: "routing",
+        description: "Routing behavior",
+        includes: ["explicit behavior"],
+        excludes: ["unrelated formatting"]
+    },
+    source: {
+        referenceCommitSha: "d".repeat(40),
+        referenceTaskDigest: sha,
+        basisDigest: "e".repeat(64)
+    },
+    modelPlan: [
+        {
+            role: "seed-author",
+            model: "openai/gpt-explicit",
+            reasoningEffort: "high",
+            maximumCalls: 4,
+            maximumOutputTokens: 4096
+        }
+    ],
+    policy: {
+        foundryPolicyVersion: "foundry-v2",
+        admissionPolicyVersion: "admission-v1",
+        repositoryModelDigest: "f".repeat(64),
+        oracleRepetitions: 2,
+        oracleConcurrency: 2,
+        foldLimit: 2
+    },
+    budget: {
+        maximumModelCalls: 16,
+        maximumWallTimeMs: 60_000,
+        maximumArtifactBytes: 1_048_576
+    }
+};
+test("scientific identity is path-independent and rejects runtime coordinates and auto models", () => {
+    const parsed = decodePipelineScientificIdentityV2(identity);
+    assert.equal(pipelineScientificIdentityDigestV2(parsed), pipelineScientificIdentityDigestV2(structuredClone(parsed)));
+    assert.throws(() => decodePipelineScientificIdentityV2({ ...identity, repositoryRoot: "/workspace/a" }));
+    assert.throws(() => decodePipelineScientificIdentityV2({
+        ...identity,
+        modelPlan: [{ ...identity.modelPlan[0], model: "auto" }]
+    }));
+    assert.throws(() => decodePipelineScientificIdentityV2({
+        ...identity,
+        modelPlan: [identity.modelPlan[0], identity.modelPlan[0]]
+    }));
+});
+test("checkpoint descriptors form a fenced, hash-linked, portable chain", () => {
+    const identityDigest = pipelineScientificIdentityDigestV2(decodePipelineScientificIdentityV2(identity));
+    const first = decodePipelineCheckpointDescriptorV2({
+        version: 2,
+        checkpointId: "checkpoint-1",
+        identityDigest,
+        attemptGeneration: 1,
+        sequence: 1,
+        kind: "stage",
+        stage: "seed",
+        parentDigest: identityDigest,
+        payloadDigest: sha,
+        payloadBytes: 10,
+        createdAt: "2026-09-11T00:00:00.000Z"
+    });
+    const second = decodePipelineCheckpointDescriptorV2({
+        version: 2,
+        checkpointId: "checkpoint-2",
+        identityDigest,
+        attemptGeneration: 2,
+        sequence: 2,
+        kind: "loop",
+        stage: "oracle",
+        loopName: "oracle-critique",
+        loopIteration: 0,
+        parentDigest: pipelineCheckpointDescriptorDigestV2(first),
+        payloadDigest: "9".repeat(64),
+        payloadBytes: 20,
+        createdAt: "2026-09-11T00:01:00.000Z"
+    });
+    assert.doesNotThrow(() => assertPipelineCheckpointChainV2(identity, [first, second]));
+    assert.throws(() => assertPipelineCheckpointChainV2(identity, [first, { ...second, sequence: 3 }]), /contiguous/);
+    assert.throws(() => assertPipelineCheckpointChainV2(identity, [
+        first,
+        { ...second, parentDigest: "8".repeat(64) }
+    ]), /parent/);
+});
+test("checkpoint replay acknowledges exact values and rejects conflicts", () => {
+    const identityDigest = pipelineScientificIdentityDigestV2(decodePipelineScientificIdentityV2(identity));
+    const checkpoint = decodePipelineCheckpointDescriptorV2({
+        version: 2,
+        checkpointId: "checkpoint-1",
+        identityDigest,
+        attemptGeneration: 1,
+        sequence: 1,
+        kind: "terminal",
+        stage: "admit",
+        parentDigest: identityDigest,
+        payloadDigest: sha,
+        payloadBytes: 10,
+        createdAt: "2026-09-11T00:00:00.000Z"
+    });
+    assert.doesNotThrow(() => assertPipelineCheckpointReplayV2(checkpoint, checkpoint));
+    assert.throws(() => assertPipelineCheckpointReplayV2(checkpoint, {
+        ...checkpoint,
+        payloadDigest: "9".repeat(64)
+    }), /conflicts/);
+    assert.throws(() => decodePipelineCheckpointDescriptorV2({
+        ...checkpoint,
+        kind: "loop",
+        loopName: "missing-iteration"
+    }));
+});

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

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