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

package/dist/services/foundry/service.js

@@ -0,0 +1,442 @@
+import { Context, Effect, Layer } from "effect";
+import { discoverIntegratedRepositoryHistoryV1, validateIntegratedRepositoryHistoryV1 } from "../../adapters/integrated-repository-history.js";
+import { rankRepositorySeedCandidatesV1 } from "../../adapters/repository-seed-selection.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { assertRepositoryFoundryGenerationPlanV1, assertRepositoryFoundryReferenceExclusionsV1, REPOSITORY_FOUNDRY_MAXIMUM_SPECIFICATION_REVISIONS, REPOSITORY_FOUNDRY_MAXIMUM_VALID_CONTROL_REGENERATIONS, REPOSITORY_FOUNDRY_MAXIMUM_WALL_TIME_MS, REPOSITORY_FOUNDRY_MINIMUM_WALL_TIME_MS, repositoryFoundryGenerationBudgetV1, repositoryFoundryGenerationPlanDigestV1 } from "../../repository-foundry-plan-protocol.js";
+import { assertRepositoryFoundryModelPlanV1 } from "../../repository-language-model-protocol.js";
+import { generateHistoricalRepositoryCaseV1, reconstructRepositoryGeneratedCaseCheckpointV1 } from "../case-generation/service.js";
+import { reportFoundryStageV1 } from "../foundry-progress/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+import { buildRepositoryBehaviorMapV1 } from "../repository-model/service.js";
+import { extractHistoricalTaskSeedsV1, qualifyHistoricalTaskSeedAcrossBatchesV1 } from "../task-seed/service.js";
+export class RepositoryFoundry extends Context.Service()("@velum-labs/routekit-eval-setup/RepositoryFoundry") {
+}
+const failure = (operation, detail, cause) => new RepositoryFoundryError({
+    operation,
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const boundedInteger = (value, fallback, minimum, maximum) => Math.max(minimum, Math.min(maximum, Number.isSafeInteger(value) ? Math.trunc(value) : fallback));
+const deniedSmokePathRoots = ["docs", "examples"];
+const pathUnderDeniedSmokeRoot = (path) => path.split("/").some((segment) => /^(?:docs?|examples?)$/iu.test(segment));
+const seedPaths = (seed) => [
+    ...seed.capabilityEvidence.flatMap((evidence) => evidence.path === undefined ? [] : [evidence.path]),
+    ...seed.environment.trustedPreparationRecipes.map((recipe) => recipe.cwd),
+    ...seed.environment.candidateValidationRecipes.map((recipe) => recipe.cwd),
+    ...seed.environment.baselineGradeRecipes.map((recipe) => recipe.cwd),
+    ...seed.environment.gradeRecipes.map((recipe) => recipe.cwd),
+    ...seed.environment.protectedControlPaths
+];
+const qualificationDiagnostics = (qualification) => {
+    const observations = [
+        ...qualification.seed.baselineObservations,
+        ...qualification.seed.preChangeObservations,
+        ...qualification.seed.postChangeObservations
+    ];
+    const rendered = observations
+        .slice(0, 18)
+        .map((observation) => `${observation.id}=${observation.outcome}: ${observation.detail}`)
+        .join("\n");
+    const bytes = Buffer.from(rendered);
+    const bounded = bytes.byteLength <= 24_000
+        ? rendered
+        : `${bytes.subarray(0, 23_968).toString("utf8")}\n[truncated]`;
+    return bounded.length === 0 ? "qualification observations unavailable" : bounded;
+};
+export const planHistoricalRepositoryCaseGenerationV1 = Effect.fn("RepositoryFoundry.planHistorical")(function* (input) {
+    yield* Effect.try({
+        try: () => {
+            assertRepositoryFoundryModelPlanV1(input.modelPlan);
+            if (input.specificationContractFactsVersion !== undefined &&
+                (input.specificationContractFactsVersion !== 1 ||
+                    input.maximumSpecificationRevisions === undefined)) {
+                throw new Error("specification contract facts require version 1 and an explicit specification revision allowance");
+            }
+            if (input.oracleRepairFeedbackVersion !== undefined &&
+                input.oracleRepairFeedbackVersion !== 1) {
+                throw new Error("oracle repair feedback version must be 1");
+            }
+            if (input.oracleCoverageWitnessRepairVersion !== undefined &&
+                (input.oracleCoverageWitnessRepairVersion !== 1 ||
+                    input.oracleCoverageWitnessVersion === undefined ||
+                    input.maximumFixtureRepairAttempts === undefined)) {
+                throw new Error("coverage witness repair budgeting requires versioned witnesses and an explicit fixture repair allowance");
+            }
+            if (input.oracleCoverageWitnessVersion !== undefined &&
+                (![1, 2].includes(input.oracleCoverageWitnessVersion) ||
+                    input.maximumOracleCoverageRevisions === undefined ||
+                    input.maximumOracleCoverageRevisions < 1)) {
+                throw new Error("executable coverage witnesses require a versioned, nonzero coverage allowance");
+            }
+            if ((input.dependencyContextVersion !== undefined &&
+                ![1, 2].includes(input.dependencyContextVersion)) ||
+                (input.maximumFixtureRepairAttempts !== undefined &&
+                    (!Number.isSafeInteger(input.maximumFixtureRepairAttempts) ||
+                        input.maximumFixtureRepairAttempts < 0 ||
+                        input.maximumFixtureRepairAttempts > 3))) {
+                throw new Error("invalid dependency context version or fixture repair allowance");
+            }
+            if (input.maximumOracleCoverageRevisions !== undefined &&
+                (input.maximumSpecificationRevisions === undefined ||
+                    !Number.isSafeInteger(input.maximumOracleCoverageRevisions) ||
+                    input.maximumOracleCoverageRevisions < 0 ||
+                    input.maximumOracleCoverageRevisions > 2 ||
+                    !input.modelPlan.assignments.some((assignment) => assignment.role === "oracle-critic"))) {
+                throw new Error("oracle coverage review requires zero to two revisions, reference grounding, and an assigned oracle critic");
+            }
+            assertRepositoryFoundryReferenceExclusionsV1(input.excludedReferenceCommits);
+            if (input.oracleConcurrency !== undefined &&
+                (!Number.isSafeInteger(input.oracleConcurrency) ||
+                    input.oracleConcurrency < 1 ||
+                    input.oracleConcurrency > 4)) {
+                throw new Error("oracle concurrency must be an integer from 1 to 4");
+            }
+            if (input.referenceCommit !== undefined && input.excludedReferenceCommits !== undefined) {
+                throw new Error("new explicit-reference preparation cannot include automatic seed exclusions");
+            }
+            if (input.caseId.trim().length === 0 ||
+                (input.requestedDimension !== undefined &&
+                    (input.requestedDimension.trim().length === 0 ||
+                        input.requestedDimension.trim().length > 2000)) ||
+                (input.referenceCommit !== undefined && input.referenceCommit.trim().length === 0) ||
+                (input.referenceCommit === undefined && input.requestedDimension === undefined) ||
+                (input.maximumSeedCandidates !== undefined &&
+                    (!Number.isSafeInteger(input.maximumSeedCandidates) ||
+                        input.maximumSeedCandidates < 1 ||
+                        input.maximumSeedCandidates > 10)) ||
+                (input.maximumSpecificationRevisions !== undefined &&
+                    (!Number.isSafeInteger(input.maximumSpecificationRevisions) ||
+                        input.maximumSpecificationRevisions < 0 ||
+                        input.maximumSpecificationRevisions >
+                            REPOSITORY_FOUNDRY_MAXIMUM_SPECIFICATION_REVISIONS)) ||
+                (input.validControlRegenerationSequence !== undefined &&
+                    (!Number.isSafeInteger(input.validControlRegenerationSequence) ||
+                        input.validControlRegenerationSequence < 1 ||
+                        input.validControlRegenerationSequence >
+                            REPOSITORY_FOUNDRY_MAXIMUM_VALID_CONTROL_REGENERATIONS)) ||
+                (input.validControlReviewVersion !== undefined &&
+                    ![1, 2].includes(input.validControlReviewVersion)) ||
+                (input.wallTimeMs !== undefined &&
+                    (!Number.isSafeInteger(input.wallTimeMs) ||
+                        input.wallTimeMs < REPOSITORY_FOUNDRY_MINIMUM_WALL_TIME_MS ||
+                        input.wallTimeMs > REPOSITORY_FOUNDRY_MAXIMUM_WALL_TIME_MS))) {
+                throw new Error("case id, explicit reference or requested dimension, and seed candidate bound (1 to 10) are required");
+            }
+        },
+        catch: (cause) => failure("plan-generation", "repository foundry generation request failed validation", cause)
+    });
+    const qualification = {
+        batches: boundedInteger(input.qualificationBatches, 2, 2, 5),
+        repetitionsPerBatch: boundedInteger(input.qualificationRepetitionsPerBatch, 2, 2, 5),
+        oracleRepetitions: boundedInteger(input.oracleRepetitions, 2, 2, 5),
+        ...(input.oracleConcurrency === undefined ? {} : { oracleConcurrency: input.oracleConcurrency })
+    };
+    const prepareCandidate = Effect.fnUntraced(function* (referenceCommit, requestedRef) {
+        const map = yield* buildRepositoryBehaviorMapV1({
+            repositoryRoot: input.repositoryRoot,
+            requestedRef,
+            ...(input.maximumHistoryEpisodes === undefined
+                ? {}
+                : { maximumHistoryEpisodes: input.maximumHistoryEpisodes })
+        });
+        // Only this episode owns the historical environment. Unrelated older build
+        // graphs must not prevent a viable candidate from being replayed.
+        const seeds = yield* extractHistoricalTaskSeedsV1({
+            ...map,
+            historyEpisodes: map.historyEpisodes.filter((episode) => episode.commit === referenceCommit)
+        });
+        const seed = seeds.find((candidate) => candidate.referenceCommit === referenceCommit);
+        if (seed === undefined) {
+            return yield* failure("plan-generation", `no executable historical task seed was found for reference commit ${referenceCommit}`);
+        }
+        const preflight = yield* qualifyHistoricalTaskSeedAcrossBatchesV1({
+            repositoryRoot: map.repository.root,
+            seed,
+            batches: qualification.batches,
+            repetitionsPerBatch: qualification.repetitionsPerBatch
+        });
+        if (!preflight.stability.stable || preflight.seed.status !== "qualified") {
+            return yield* failure("plan-generation", [
+                `historical seed failed replay qualification before planning: ${preflight.stability.rejectionReasons.join("; ")}`,
+                qualificationDiagnostics(preflight)
+            ].join("\n"));
+        }
+        return { map, seed };
+    });
+    let selected;
+    let historyProvenance;
+    if (input.referenceCommit !== undefined) {
+        selected = yield* prepareCandidate(input.referenceCommit, input.requestedRef ?? input.referenceCommit);
+    }
+    else {
+        const discovery = yield* buildRepositoryBehaviorMapV1({
+            repositoryRoot: input.repositoryRoot,
+            requestedRef: input.requestedRef ?? "HEAD",
+            ...(input.maximumHistoryEpisodes === undefined
+                ? {}
+                : { maximumHistoryEpisodes: input.maximumHistoryEpisodes })
+        });
+        const retained = yield* discoverIntegratedRepositoryHistoryV1({
+            repositoryRoot: discovery.repository.root,
+            requestedRef: discovery.repository.requestedRef,
+            requestedTipCommit: discovery.repository.commit,
+            requestedTipTree: discovery.repository.tree,
+            integrationCommits: discovery.historyEpisodes.map(({ commit }) => commit)
+        });
+        const excludedRoots = discovery.blindSpots.find(({ id }) => id === "blind-excluded-package-roots")?.paths ?? [];
+        const excludedReferences = new Set(input.excludedReferenceCommits ?? []);
+        const candidates = rankRepositorySeedCandidatesV1({
+            ...discovery,
+            historyEpisodes: [
+                ...discovery.historyEpisodes,
+                ...retained
+                    .filter(({ episode }) => !episode.changedPaths.some(({ path }) => excludedRoots.some((root) => path === root || path.startsWith(`${root}/`))))
+                    .map(({ episode }) => episode)
+            ]
+        }, input.requestedDimension.trim())
+            .filter(({ episode }) => !excludedReferences.has(episode.commit))
+            .slice(0, input.maximumSeedCandidates ?? 3);
+        yield* reportFoundryStageV1("replay-qualify", `seed-selection tip=${discovery.repository.commit}; candidates=${String(candidates.length)}; excludedReferences=${excludedReferences.size}`);
+        if (candidates.length === 0 && excludedReferences.size > 0) {
+            return yield* failure("plan-generation", "no unseen eligible historical seed remains for the requested dimension after admitted-reference exclusions");
+        }
+        const rejections = [];
+        for (const [index, candidate] of candidates.entries()) {
+            const referenceCommit = candidate.episode.commit;
+            yield* reportFoundryStageV1("replay-qualify", `seed-selection candidate=${referenceCommit}; attempt=${String(index + 1)}; relevance=${String(candidate.relevance)}; matched=${candidate.matchedTerms.join(",")}`);
+            // Reindex at the candidate's reference, not at today's possibly renamed
+            // package layout; the selected plan then pins that exact historical tree.
+            const attempted = yield* prepareCandidate(referenceCommit, referenceCommit).pipe(Effect.match({
+                onFailure: (error) => ({ status: "rejected", error }),
+                onSuccess: (value) => ({ status: "qualified", value })
+            }));
+            if (attempted.status === "qualified") {
+                selected = attempted.value;
+                historyProvenance = retained.find(({ episode }) => episode.commit === referenceCommit)?.provenance;
+                yield* reportFoundryStageV1("replay-qualify", `seed-selection candidate=${referenceCommit}; status=selected`);
+                break;
+            }
+            const reason = attempted.error.detail.split("\n")[0].slice(0, 1_000);
+            rejections.push(`${referenceCommit}: ${reason}`);
+            yield* reportFoundryStageV1("replay-qualify", `seed-selection candidate=${referenceCommit}; status=rejected; reason=${reason}`);
+        }
+        if (selected === undefined) {
+            return yield* failure("plan-generation", `no historical seed qualified within ${String(candidates.length)} candidate attempts for the requested dimension${rejections.length === 0 ? "" : `: ${rejections.join("; ")}`}`);
+        }
+    }
+    const { map, seed } = selected;
+    const budget = repositoryFoundryGenerationBudgetV1(input.maximumHillClimbAttempts ?? 2, input.wallTimeMs, input.maximumSpecificationRevisions, input.maximumOracleCoverageRevisions, input.maximumFixtureRepairAttempts, input.reviewInputVersion, input.specificationContractFactsVersion);
+    const withoutDigest = {
+        version: 1,
+        repository: map.repository,
+        caseId: input.caseId,
+        ...(input.requestedDimension === undefined
+            ? {}
+            : { requestedDimension: input.requestedDimension.trim() }),
+        ...(input.excludedReferenceCommits === undefined
+            ? {}
+            : {
+                excludedReferenceCommits: [...input.excludedReferenceCommits]
+            }),
+        ...(historyProvenance === undefined ? {} : { historyProvenance }),
+        ...(input.validControlRegenerationSequence === undefined
+            ? {}
+            : { validControlRegenerationSequence: input.validControlRegenerationSequence }),
+        ...(input.validControlReviewVersion === undefined
+            ? {}
+            : { validControlReviewVersion: input.validControlReviewVersion }),
+        ...(input.dependencyContextVersion === undefined
+            ? {}
+            : { dependencyContextVersion: input.dependencyContextVersion }),
+        ...(input.oracleCoverageWitnessVersion === undefined
+            ? {}
+            : { oracleCoverageWitnessVersion: input.oracleCoverageWitnessVersion }),
+        ...(input.oracleCoverageWitnessRepairVersion === undefined
+            ? {}
+            : { oracleCoverageWitnessRepairVersion: input.oracleCoverageWitnessRepairVersion }),
+        ...(input.oracleRepairFeedbackVersion === undefined
+            ? {}
+            : { oracleRepairFeedbackVersion: input.oracleRepairFeedbackVersion }),
+        ...(input.reviewInputVersion === undefined
+            ? {}
+            : { reviewInputVersion: input.reviewInputVersion }),
+        ...(input.specificationContractFactsVersion === undefined
+            ? {}
+            : { specificationContractFactsVersion: input.specificationContractFactsVersion }),
+        seedId: seed.id,
+        initialCommit: seed.initialState.commit,
+        referenceCommit: seed.referenceCommit,
+        modelPlan: input.modelPlan,
+        qualification,
+        budget
+    };
+    const plan = {
+        ...withoutDigest,
+        planDigest: repositoryFoundryGenerationPlanDigestV1(withoutDigest)
+    };
+    yield* Effect.try({
+        try: () => assertRepositoryFoundryGenerationPlanV1(plan),
+        catch: (cause) => failure("plan-generation", "generated repository foundry plan failed validation", cause)
+    });
+    return plan;
+});
+export const smokeHistoricalRepositoryQualificationV1 = Effect.fn("RepositoryFoundry.smoke")(function* (input) {
+    const map = yield* buildRepositoryBehaviorMapV1({
+        repositoryRoot: input.repositoryRoot,
+        requestedRef: input.requestedRef ?? input.referenceCommit ?? "HEAD",
+        ...(input.maximumHistoryEpisodes === undefined
+            ? {}
+            : { maximumHistoryEpisodes: input.maximumHistoryEpisodes })
+    });
+    const seeds = yield* extractHistoricalTaskSeedsV1(map);
+    const selectableSeeds = seeds.filter((candidate) => !seedPaths(candidate).some(pathUnderDeniedSmokeRoot));
+    const selected = input.referenceCommit === undefined
+        ? selectableSeeds.at(-1)
+        : selectableSeeds.find((candidate) => candidate.referenceCommit === input.referenceCommit);
+    if (selected === undefined) {
+        return yield* failure("plan-generation", input.referenceCommit === undefined
+            ? "no executable historical task seed remained after denying docs/ and examples/ paths"
+            : `no executable historical task seed remained for reference commit ${input.referenceCommit} after denying docs/ and examples/ paths`);
+    }
+    const qualification = yield* qualifyHistoricalTaskSeedAcrossBatchesV1({
+        repositoryRoot: map.repository.root,
+        seed: selected,
+        batches: boundedInteger(input.qualificationBatches, 2, 2, 5),
+        repetitionsPerBatch: boundedInteger(input.qualificationRepetitionsPerBatch, 2, 2, 5)
+    });
+    if (!qualification.stability.stable || qualification.seed.status !== "qualified") {
+        return yield* failure("plan-generation", [
+            `historical seed failed replay qualification: ${qualification.stability.rejectionReasons.join("; ")}`,
+            qualificationDiagnostics(qualification)
+        ].join("\n"));
+    }
+    const selectedPathsUnderDeniedRoots = seedPaths(qualification.seed)
+        .filter(pathUnderDeniedSmokeRoot)
+        .sort();
+    if (selectedPathsUnderDeniedRoots.length > 0) {
+        return yield* failure("plan-generation", `qualified historical seed crossed the docs/examples path deny: ${selectedPathsUnderDeniedRoots.join(", ")}`);
+    }
+    return {
+        version: 1,
+        operation: "index-qualify-smoke",
+        repository: map.repository,
+        index: {
+            packages: map.packages.length,
+            publicSurfaces: map.publicSurfaces.length,
+            protocols: map.protocols.length,
+            commands: map.commands.length,
+            tests: map.tests.length,
+            historyEpisodes: map.historyEpisodes.length
+        },
+        seeds: {
+            extracted: seeds.length,
+            selected: {
+                id: selected.id,
+                summary: selected.summary,
+                initialCommit: selected.initialState.commit,
+                referenceCommit: selected.referenceCommit
+            }
+        },
+        qualification,
+        pathPolicy: {
+            deniedRoots: deniedSmokePathRoots,
+            selectedPathsUnderDeniedRoots
+        },
+        modelCalls: 0
+    };
+});
+const resolveHistoricalRepositoryCaseContextV1 = Effect.fn("RepositoryFoundry.resolveExecutionContext")(function* (input) {
+    yield* reportFoundryStageV1("execute-start", `plan=${input.plan.planDigest}`);
+    yield* Effect.try({
+        try: () => assertRepositoryFoundryGenerationPlanV1(input.plan),
+        catch: (cause) => failure("execute-generation", "repository foundry plan failed validation", cause)
+    });
+    if (input.plan.historyProvenance !== undefined) {
+        yield* validateIntegratedRepositoryHistoryV1({
+            repositoryRoot: input.plan.repository.root,
+            referenceCommit: input.plan.referenceCommit,
+            initialCommit: input.plan.initialCommit,
+            provenance: input.plan.historyProvenance
+        });
+    }
+    const map = yield* buildRepositoryBehaviorMapV1({
+        repositoryRoot: input.plan.repository.root,
+        requestedRef: input.plan.repository.commit
+    });
+    if (map.repository.commit !== input.plan.repository.commit ||
+        map.repository.tree !== input.plan.repository.tree) {
+        return yield* failure("execute-generation", "repository history changed after the immutable foundry plan was created");
+    }
+    const seeds = yield* extractHistoricalTaskSeedsV1({
+        ...map,
+        historyEpisodes: map.historyEpisodes.filter((episode) => episode.commit === input.plan.referenceCommit)
+    });
+    const candidateSeed = seeds.find((candidate) => candidate.id === input.plan.seedId &&
+        candidate.initialState.commit === input.plan.initialCommit &&
+        candidate.referenceCommit === input.plan.referenceCommit);
+    if (candidateSeed === undefined) {
+        return yield* failure("execute-generation", "the immutable foundry plan no longer identifies the same historical seed");
+    }
+    yield* reportFoundryStageV1("replay-qualify");
+    const qualification = yield* qualifyHistoricalTaskSeedAcrossBatchesV1({
+        repositoryRoot: input.plan.repository.root,
+        seed: candidateSeed,
+        batches: input.plan.qualification.batches,
+        repetitionsPerBatch: input.plan.qualification.repetitionsPerBatch
+    });
+    if (!qualification.stability.stable || qualification.seed.status !== "qualified") {
+        return yield* failure("execute-generation", [
+            `historical seed failed replay qualification: ${qualification.stability.rejectionReasons.join("; ")}`,
+            qualificationDiagnostics(qualification)
+        ].join("\n"));
+    }
+    return { map, qualification };
+});
+const historicalCaseInput = (plan, map, seed) => ({
+    repositoryRoot: plan.repository.root,
+    operationId: `repository-foundry-${plan.planDigest.slice(0, 20)}`,
+    caseId: plan.caseId,
+    requestedDimension: plan.requestedDimension,
+    validControlRegenerationSequence: plan.validControlRegenerationSequence,
+    validControlReviewVersion: plan.validControlReviewVersion,
+    dependencyContextVersion: plan.dependencyContextVersion,
+    oracleCoverageWitnessVersion: plan.oracleCoverageWitnessVersion,
+    oracleCoverageWitnessRepairVersion: plan.oracleCoverageWitnessRepairVersion,
+    oracleRepairFeedbackVersion: plan.oracleRepairFeedbackVersion,
+    reviewInputVersion: plan.reviewInputVersion,
+    specificationContractFactsVersion: plan.specificationContractFactsVersion,
+    map,
+    seed,
+    modelPlan: plan.modelPlan,
+    oracleRepetitions: plan.qualification.oracleRepetitions,
+    oracleConcurrency: plan.qualification.oracleConcurrency,
+    maximumHillClimbAttempts: plan.budget.maximumHillClimbAttempts,
+    maximumSpecificationRevisions: plan.budget.maximumSpecificationRevisions,
+    maximumOracleCoverageRevisions: plan.budget.maximumOracleCoverageRevisions,
+    maximumFixtureRepairAttempts: plan.budget.maximumFixtureRepairAttempts
+});
+export const executeHistoricalRepositoryCaseGenerationV1 = Effect.fn("RepositoryFoundry.executeHistorical")(function* (input) {
+    const { map, qualification } = yield* resolveHistoricalRepositoryCaseContextV1(input);
+    const generation = yield* generateHistoricalRepositoryCaseV1(historicalCaseInput(input.plan, map, qualification.seed));
+    yield* reportFoundryStageV1("execute-complete", `status=${generation.benchmarkCase.status}`);
+    return {
+        version: 1,
+        plan: input.plan,
+        qualification,
+        generation
+    };
+});
+export const reconstructHistoricalRepositoryCaseCheckpointV1 = Effect.fn("RepositoryFoundry.reconstructCheckpoint")(function* (input) {
+    const { map, qualification } = yield* resolveHistoricalRepositoryCaseContextV1(input);
+    const checkpoint = yield* reconstructRepositoryGeneratedCaseCheckpointV1(historicalCaseInput(input.plan, map, qualification.seed));
+    return { version: 1, plan: input.plan, qualification, checkpoint };
+});
+export const makeRepositoryFoundry = Effect.gen(function* () {
+    const languageModel = yield* RepositoryFoundryLanguageModel;
+    return RepositoryFoundry.of({
+        planHistorical: planHistoricalRepositoryCaseGenerationV1,
+        executeHistorical: (input) => executeHistoricalRepositoryCaseGenerationV1(input).pipe(Effect.provideService(RepositoryFoundryLanguageModel, languageModel)),
+        smoke: smokeHistoricalRepositoryQualificationV1
+    });
+});
+export const RepositoryFoundryLive = Layer.effect(RepositoryFoundry, makeRepositoryFoundry);

package/dist/services/foundry-progress/service.d.ts

@@ -0,0 +1,62 @@
+import { Context, Effect, Layer } from "effect";
+import type { RepositoryFoundryError } from "../../errors.js";
+import { type RepositoryFoundryAuthoringArtifactV1, type RepositoryFoundryProgressEventV1, type RepositoryFoundryProgressSnapshotV1, type RepositoryFoundryProgressStageV1 } from "../../repository-foundry-progress-protocol.js";
+declare const RepositoryFoundryIdleStallError_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: "RepositoryFoundryIdleStallError";
+} & Readonly<A>;
+export declare class RepositoryFoundryIdleStallError extends RepositoryFoundryIdleStallError_base<{
+    readonly stage: RepositoryFoundryProgressStageV1;
+    readonly modelCalls: number;
+    readonly idleMs: number;
+    readonly idleStallMs: number;
+    readonly detail: string;
+}> {
+    get message(): string;
+}
+export type RepositoryFoundryProgressShape = {
+    readonly snapshot: Effect.Effect<RepositoryFoundryProgressSnapshotV1>;
+    readonly reportStage: (stage: RepositoryFoundryProgressStageV1, detail?: string) => Effect.Effect<RepositoryFoundryProgressEventV1>;
+    readonly reportModelCall: (input: {
+        readonly role: string;
+        readonly phase: "start" | "complete" | "failed";
+        readonly operationId?: string;
+        readonly callId?: string;
+    }) => Effect.Effect<RepositoryFoundryProgressEventV1>;
+    readonly reportHeartbeat: (input?: {
+        readonly role?: string;
+        readonly detail?: string;
+    }) => Effect.Effect<RepositoryFoundryProgressEventV1>;
+    /** Sync pulse for Responses SSE bytes; does not emit a durable line. */
+    readonly markActivitySync: () => void;
+    readonly recordAuthoringArtifact?: (artifact: RepositoryFoundryAuthoringArtifactV1) => Effect.Effect<void, RepositoryFoundryError>;
+};
+declare const RepositoryFoundryProgress_base: Context.ServiceClass<RepositoryFoundryProgress, "@velum-labs/routekit-eval-setup/RepositoryFoundryProgress", RepositoryFoundryProgressShape>;
+export declare class RepositoryFoundryProgress extends RepositoryFoundryProgress_base {
+}
+export type RepositoryFoundryProgressEmit = (event: RepositoryFoundryProgressEventV1) => Effect.Effect<void>;
+export type RepositoryFoundryArtifactEmit = (artifact: RepositoryFoundryAuthoringArtifactV1) => Effect.Effect<void, RepositoryFoundryError>;
+export declare const makeRepositoryFoundryProgress: (emit?: RepositoryFoundryProgressEmit, recordArtifact?: RepositoryFoundryArtifactEmit) => Effect.Effect<RepositoryFoundryProgressShape>;
+export declare const RepositoryFoundryProgressLive: (emit?: RepositoryFoundryProgressEmit, recordArtifact?: RepositoryFoundryArtifactEmit) => Layer.Layer<RepositoryFoundryProgress, never, never>;
+export declare const reportFoundryAuthoringArtifactV1: (artifact: RepositoryFoundryAuthoringArtifactV1) => Effect.Effect<void, RepositoryFoundryError>;
+/** No-op when the progress service is not provided. */
+export declare const reportFoundryStageV1: (stage: RepositoryFoundryProgressStageV1, detail?: string) => Effect.Effect<void>;
+export declare const reportFoundryModelCallV1: (input: {
+    readonly role: string;
+    readonly phase: "start" | "complete" | "failed";
+    readonly operationId?: string;
+    readonly callId?: string;
+}) => Effect.Effect<void>;
+export declare const reportFoundryHeartbeatV1: (input?: {
+    readonly role?: string;
+    readonly detail?: string;
+}) => Effect.Effect<void>;
+/**
+ * Fail closed when foundry execute progress is flat for `idleStallMs`.
+ * Wall time remains a separate hard ceiling outside this helper.
+ */
+export declare const withRepositoryFoundryIdleStall: <A, E, R>(effect: Effect.Effect<A, E, R>, input: {
+    readonly idleStallMs: number;
+    readonly wallTimeMs: number;
+}) => Effect.Effect<A, E | RepositoryFoundryIdleStallError, R | RepositoryFoundryProgress>;
+export declare const renderRepositoryFoundryProgressLineV1: (event: RepositoryFoundryProgressEventV1) => string;
+export {};

package/dist/services/foundry-progress/service.js

@@ -0,0 +1,149 @@
+import { Clock, Context, Data, Effect, Layer, Option } from "effect";
+import { boundRepositoryFoundryIdleStallMsV1, formatRepositoryFoundryProgressLineV1 } from "../../repository-foundry-progress-protocol.js";
+export class RepositoryFoundryIdleStallError extends Data.TaggedError("RepositoryFoundryIdleStallError") {
+    get message() {
+        return (`RouteKit repository foundry execute stalled: ${this.detail}; ` +
+            `stage=${this.stage} modelCalls=${String(this.modelCalls)} ` +
+            `idleMs=${String(this.idleMs)} idleStallMs=${String(this.idleStallMs)}`);
+    }
+}
+export class RepositoryFoundryProgress extends Context.Service()("@velum-labs/routekit-eval-setup/RepositoryFoundryProgress") {
+}
+const isoOf = (millis) => new Date(millis).toISOString();
+export const makeRepositoryFoundryProgress = (emit = () => Effect.void, recordArtifact = () => Effect.void) => Effect.gen(function* () {
+    const startedAt = yield* Clock.currentTimeMillis;
+    const mutable = {
+        stage: "execute-start",
+        modelCalls: 0,
+        lastProgressAtMs: startedAt,
+        lastEventKind: "stage"
+    };
+    const publish = (next, event) => Effect.gen(function* () {
+        mutable.stage = next.stage;
+        mutable.modelCalls = next.modelCalls;
+        mutable.lastProgressAtMs = next.lastProgressAtMs;
+        mutable.lastEventKind = next.lastEventKind;
+        const published = {
+            version: 1,
+            at: isoOf(next.lastProgressAtMs),
+            stage: next.stage,
+            modelCalls: next.modelCalls,
+            ...event
+        };
+        yield* emit(published);
+        return published;
+    });
+    return {
+        recordAuthoringArtifact: recordArtifact,
+        snapshot: Effect.sync(() => ({
+            stage: mutable.stage,
+            modelCalls: mutable.modelCalls,
+            lastProgressAtMs: mutable.lastProgressAtMs,
+            lastEventKind: mutable.lastEventKind
+        })),
+        markActivitySync: () => {
+            mutable.lastProgressAtMs = Date.now();
+            mutable.lastEventKind = "heartbeat";
+        },
+        reportStage: (stage, detail) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            return yield* publish({
+                stage,
+                modelCalls: mutable.modelCalls,
+                lastProgressAtMs: now,
+                lastEventKind: "stage"
+            }, {
+                kind: "stage",
+                ...(detail === undefined ? {} : { detail })
+            });
+        }),
+        reportModelCall: (input) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const modelCalls = input.phase === "complete" ? mutable.modelCalls + 1 : mutable.modelCalls;
+            return yield* publish({
+                stage: mutable.stage,
+                modelCalls,
+                lastProgressAtMs: now,
+                lastEventKind: "model-call"
+            }, {
+                kind: "model-call",
+                role: input.role,
+                phase: input.phase,
+                ...(input.operationId === undefined ? {} : { operationId: input.operationId }),
+                ...(input.callId === undefined ? {} : { callId: input.callId })
+            });
+        }),
+        reportHeartbeat: (input = {}) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            return yield* publish({
+                stage: mutable.stage,
+                modelCalls: mutable.modelCalls,
+                lastProgressAtMs: now,
+                lastEventKind: "heartbeat"
+            }, {
+                kind: "heartbeat",
+                phase: "activity",
+                ...(input.role === undefined ? {} : { role: input.role }),
+                ...(input.detail === undefined ? {} : { detail: input.detail })
+            });
+        })
+    };
+});
+export const RepositoryFoundryProgressLive = (emit, recordArtifact) => Layer.effect(RepositoryFoundryProgress, makeRepositoryFoundryProgress(emit, recordArtifact));
+export const reportFoundryAuthoringArtifactV1 = (artifact) => Effect.gen(function* () {
+    const progress = yield* Effect.serviceOption(RepositoryFoundryProgress);
+    if (Option.isNone(progress) || progress.value.recordAuthoringArtifact === undefined)
+        return;
+    yield* progress.value.recordAuthoringArtifact(artifact);
+});
+/** No-op when the progress service is not provided. */
+export const reportFoundryStageV1 = (stage, detail) => Effect.gen(function* () {
+    const progress = yield* Effect.serviceOption(RepositoryFoundryProgress);
+    if (Option.isNone(progress))
+        return;
+    yield* progress.value.reportStage(stage, detail);
+});
+export const reportFoundryModelCallV1 = (input) => Effect.gen(function* () {
+    const progress = yield* Effect.serviceOption(RepositoryFoundryProgress);
+    if (Option.isNone(progress))
+        return;
+    yield* progress.value.reportModelCall(input);
+});
+export const reportFoundryHeartbeatV1 = (input) => Effect.gen(function* () {
+    const progress = yield* Effect.serviceOption(RepositoryFoundryProgress);
+    if (Option.isNone(progress))
+        return;
+    yield* progress.value.reportHeartbeat(input);
+});
+const idlePollIntervalMs = (idleStallMs) => Math.max(1, Math.min(5_000, Math.floor(idleStallMs / 4)));
+/**
+ * Fail closed when foundry execute progress is flat for `idleStallMs`.
+ * Wall time remains a separate hard ceiling outside this helper.
+ */
+export const withRepositoryFoundryIdleStall = (effect, input) => {
+    const idleStallMs = boundRepositoryFoundryIdleStallMsV1(input.idleStallMs, input.wallTimeMs);
+    const pollMs = idlePollIntervalMs(idleStallMs);
+    return Effect.gen(function* () {
+        const progress = yield* RepositoryFoundryProgress;
+        const monitor = Effect.gen(function* () {
+            for (;;) {
+                yield* Effect.sleep(pollMs);
+                const snap = yield* progress.snapshot;
+                const now = yield* Clock.currentTimeMillis;
+                const idleMs = now - snap.lastProgressAtMs;
+                if (idleMs >= idleStallMs) {
+                    return yield* new RepositoryFoundryIdleStallError({
+                        stage: snap.stage,
+                        modelCalls: snap.modelCalls,
+                        idleMs,
+                        idleStallMs,
+                        detail: "silent post-turbo authoring with no stage or modelCalls progress " +
+                            "(hung call or stalled before first call); failing closed before the plan wall budget burns silent"
+                    });
+                }
+            }
+        });
+        return yield* Effect.raceFirst(effect, monitor);
+    });
+};
+export const renderRepositoryFoundryProgressLineV1 = formatRepositoryFoundryProgressLineV1;