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

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

@@ -0,0 +1,177 @@
+import { Context, Effect, Layer } from "effect";
+import { RepositoryFoundryError } from "../../errors.js";
+import { evaluateRepositoryOracleAdequacyV1 } from "../../repository-quality-policy.js";
+import { assertRepositoryTrajectoryPolicyV1 } from "../../repository-trajectory-protocol.js";
+import { compileReviewedHiddenFixtureSuiteV1 } from "../fixture-builder/service.js";
+import { buildHistoricalHiddenOracleV1 } from "../oracle-builder/service.js";
+import { evaluateRepositoryBenchmarkDraftV1 } from "../quality-gate/service.js";
+import { critiqueRepositoryTaskSpecificationV1 } from "../specification-critic/service.js";
+import { deriveRepositoryTaskFamiliesV1 } from "../task-family/service.js";
+const fail = (detail) => new RepositoryFoundryError({
+    operation: "compile-reviewed-case",
+    detail
+});
+const sortedUnique = (values) => [...new Set(values)].sort();
+const sameStrings = (left, right) => JSON.stringify(sortedUnique(left)) === JSON.stringify(sortedUnique(right));
+const assertBlueprintShape = (seed, blueprint) => {
+    if (seed.status !== "qualified" || seed.referenceCommit === undefined) {
+        throw fail("a reviewed historical case requires a replay-qualified seed with a reference commit");
+    }
+    if (blueprint.caseId.trim().length === 0 ||
+        blueprint.visible.id !== blueprint.caseId ||
+        blueprint.finalFixtureSuite.caseId !== blueprint.caseId) {
+        throw fail("the reviewed case, visible task, and final fixture suite must share one non-empty case id");
+    }
+    if (blueprint.visible.lane !== "repository-agent") {
+        throw fail("reviewed historical repository cases must use the repository-agent lane");
+    }
+    if (blueprint.trajectoryPolicy !== undefined) {
+        assertRepositoryTrajectoryPolicyV1(blueprint.trajectoryPolicy);
+        if (blueprint.trajectoryPolicy.caseId !== blueprint.caseId) {
+            throw fail("the reviewed trajectory policy must share the reviewed case id");
+        }
+    }
+    if (blueprint.visible.checkoutCommit !== seed.initialState.commit) {
+        throw fail("the reviewed visible task must expose the replay-qualified pre-task checkout");
+    }
+    const solutionIds = blueprint.solutions.map((solution) => solution.id);
+    if (solutionIds.some((id) => id.trim().length === 0) ||
+        new Set(solutionIds).size !== solutionIds.length) {
+        throw fail("the reviewed strong solution population requires unique ids");
+    }
+    const weak = blueprint.weakOracleTrial;
+    if (weak === undefined)
+        return;
+    if (weak.fixtureSuite !== undefined && weak.fixtureSuite.caseId !== blueprint.caseId) {
+        throw fail("the weak oracle fixture suite must share the reviewed case id");
+    }
+    const weakSolutionIds = weak.solutions.map((solution) => solution.id);
+    if (new Set(weakSolutionIds).size !== weakSolutionIds.length) {
+        throw fail("the reviewed weak solution population requires unique ids");
+    }
+    const expectedEscapeIds = sortedUnique(weak.expectedFalseAcceptedSolutionIds);
+    if (expectedEscapeIds.length === 0) {
+        throw fail("a weak oracle trial must name at least one reproduced false acceptance");
+    }
+    const strongSolutionIds = new Set(solutionIds);
+    for (const escapeId of expectedEscapeIds) {
+        const weakSolution = weak.solutions.find((solution) => solution.id === escapeId);
+        if (weakSolution === undefined || weakSolution.expectedClass !== "wrong") {
+            throw fail(`weak oracle escape ${JSON.stringify(escapeId)} must identify a plausible wrong solution`);
+        }
+        if (!strongSolutionIds.has(escapeId)) {
+            throw fail(`weak oracle escape ${JSON.stringify(escapeId)} must remain in the strengthened tournament`);
+        }
+    }
+};
+export class HistoricalCase extends Context.Service()("@velum-labs/routekit-eval-setup/HistoricalCase") {
+}
+export const compileReviewedHistoricalCaseV1 = Effect.fn("HistoricalCase.compileReviewed")(function* (input) {
+    assertBlueprintShape(input.seed, input.blueprint);
+    const families = yield* deriveRepositoryTaskFamiliesV1({
+        map: input.map,
+        seeds: [input.seed]
+    });
+    const family = families.find((candidate) => candidate.seedIds.includes(input.seed.id));
+    if (family === undefined) {
+        return yield* fail("the replay-qualified seed has no derived task family");
+    }
+    if (family.lane !== input.blueprint.visible.lane || !family.seedIds.includes(input.seed.id)) {
+        return yield* fail("the visible task is not aligned with the seed's derived task family");
+    }
+    const finalFixtureSuite = yield* compileReviewedHiddenFixtureSuiteV1({
+        caseId: input.blueprint.caseId,
+        seed: input.seed,
+        suite: input.blueprint.finalFixtureSuite
+    });
+    const specificationCritique = yield* critiqueRepositoryTaskSpecificationV1({
+        repositoryRoot: input.repositoryRoot,
+        seed: input.seed,
+        family,
+        visible: input.blueprint.visible,
+        reviews: input.blueprint.specificationReviews,
+        ...(input.blueprint.requestedDimension === undefined
+            ? {}
+            : { requestedDimension: input.blueprint.requestedDimension })
+    });
+    if (specificationCritique.outcome !== "pass") {
+        return yield* fail(`the reviewed visible task is not sufficiently specified: ${specificationCritique.rejectionReasons.join("; ")}`);
+    }
+    const repetitions = Math.max(2, Math.min(input.blueprint.oracleRepetitions ?? 2, 5));
+    let weakOracle;
+    let weakAdequacy;
+    const weakTrial = input.blueprint.weakOracleTrial;
+    if (weakTrial !== undefined) {
+        const fixtureSuite = weakTrial.fixtureSuite === undefined
+            ? undefined
+            : yield* compileReviewedHiddenFixtureSuiteV1({
+                caseId: input.blueprint.caseId,
+                seed: input.seed,
+                suite: weakTrial.fixtureSuite
+            });
+        weakOracle = yield* buildHistoricalHiddenOracleV1({
+            repositoryRoot: input.repositoryRoot,
+            caseId: input.blueprint.caseId,
+            seed: input.seed,
+            additionalSolutions: weakTrial.solutions,
+            ...(input.blueprint.oracleConcurrency === undefined
+                ? {}
+                : { oracleConcurrency: input.blueprint.oracleConcurrency }),
+            ...(fixtureSuite === undefined ? {} : { hiddenFixtureSuite: fixtureSuite }),
+            ...(input.blueprint.structuralClauses === undefined
+                ? {}
+                : { structuralClauses: input.blueprint.structuralClauses }),
+            repetitions
+        });
+        weakAdequacy = evaluateRepositoryOracleAdequacyV1(weakOracle);
+        if (!sameStrings(weakAdequacy.falseAcceptedSolutionIds, weakTrial.expectedFalseAcceptedSolutionIds) ||
+            weakAdequacy.falseRejectedSolutionIds.length > 0 ||
+            weakAdequacy.unstableSolutionIds.length > 0) {
+            return yield* fail([
+                "the weak oracle trial did not reproduce the reviewed hill-climb evidence",
+                `expectedFalseAccepts=${sortedUnique(weakTrial.expectedFalseAcceptedSolutionIds).join(",")}`,
+                `actualFalseAccepts=${weakAdequacy.falseAcceptedSolutionIds.join(",")}`,
+                `falseRejects=${weakAdequacy.falseRejectedSolutionIds.join(",")}`,
+                `unstable=${weakAdequacy.unstableSolutionIds.join(",")}`
+            ].join("; "));
+        }
+    }
+    const hidden = yield* buildHistoricalHiddenOracleV1({
+        repositoryRoot: input.repositoryRoot,
+        caseId: input.blueprint.caseId,
+        seed: input.seed,
+        additionalSolutions: input.blueprint.solutions,
+        ...(input.blueprint.oracleConcurrency === undefined
+            ? {}
+            : { oracleConcurrency: input.blueprint.oracleConcurrency }),
+        hiddenFixtureSuite: finalFixtureSuite,
+        ...(input.blueprint.structuralClauses === undefined
+            ? {}
+            : { structuralClauses: input.blueprint.structuralClauses }),
+        repetitions
+    });
+    const benchmarkCase = yield* evaluateRepositoryBenchmarkDraftV1({
+        map: input.map,
+        seed: input.seed,
+        family,
+        visible: input.blueprint.visible,
+        hidden,
+        specificationCritique,
+        ...(input.blueprint.trajectoryPolicy === undefined
+            ? {}
+            : { trajectoryPolicy: input.blueprint.trajectoryPolicy })
+    });
+    return {
+        seed: input.seed,
+        family,
+        specificationCritique,
+        ...(weakOracle === undefined ? {} : { weakOracle }),
+        ...(weakAdequacy === undefined ? {} : { weakAdequacy }),
+        hidden,
+        benchmarkCase
+    };
+});
+export const makeHistoricalCase = Effect.succeed(HistoricalCase.of({
+    compileReviewed: compileReviewedHistoricalCaseV1
+}));
+export const HistoricalCaseLive = Layer.effect(HistoricalCase, makeHistoricalCase);

package/dist/services/improvement-loop/service.d.ts

@@ -0,0 +1,59 @@
+import { Context, Effect, Layer } from "effect";
+import { RepositoryFoundryError } from "../../errors.js";
+import type { RepositoryValidatedBenchmarkLibraryV1 } from "../../repository-benchmark-protocol.js";
+import { type RepositoryFoundryImprovementCycleV1, type RepositoryFoundryImprovementDraftV1 } from "../../repository-improvement-protocol.js";
+export type ImprovementLoopShape = {
+    readonly compileCycle: (input: {
+        readonly cycleId: string;
+        readonly library: RepositoryValidatedBenchmarkLibraryV1;
+        readonly auditedCoreCaseIds: readonly string[];
+        readonly drafts: readonly RepositoryFoundryImprovementDraftV1[];
+    }) => Effect.Effect<RepositoryFoundryImprovementCycleV1, RepositoryFoundryError>;
+};
+declare const ImprovementLoop_base: Context.ServiceClass<ImprovementLoop, "@velum-labs/routekit-eval-setup/ImprovementLoop", ImprovementLoopShape>;
+export declare class ImprovementLoop extends ImprovementLoop_base {
+}
+export declare const compileRepositoryFoundryImprovementCycleV1: (input: {
+    readonly cycleId: string;
+    readonly library: RepositoryValidatedBenchmarkLibraryV1;
+    readonly auditedCoreCaseIds: readonly string[];
+    readonly drafts: readonly RepositoryFoundryImprovementDraftV1[];
+}) => Effect.Effect<{
+    readonly version: 1;
+    readonly cycleId: string;
+    readonly inputCaseIds: readonly string[];
+    readonly records: readonly {
+        readonly version: 1;
+        readonly id: string;
+        readonly trigger: "superseded" | "new-authentic-work" | "oracle-escape" | "false-rejection" | "coverage-gap" | "instability" | "environment-drift" | "contract-drift" | "realism-drift" | "semantic-duplicate";
+        readonly action: "add-seed" | "add-fixture" | "strengthen-oracle" | "add-valid-alternative" | "regenerate-specification" | "quarantine-case" | "retire-case";
+        readonly summary: string;
+        readonly affectedCaseIds: readonly string[];
+        readonly evidence: readonly {
+            readonly kind: "symbol" | "package" | "public-surface" | "protocol" | "schema" | "test" | "command" | "history-episode" | "workload-signal" | "documentation";
+            readonly id: string;
+            readonly path?: string | undefined;
+        }[];
+        readonly reviews: readonly {
+            readonly reviewerId: string;
+            readonly independentlyProduced: boolean;
+            readonly verdict: "approve" | "reject";
+            readonly detail: string;
+        }[];
+        readonly decision: "rejected" | "applied";
+        readonly rejectionReasons: readonly string[];
+    }[];
+    readonly lifecycle: readonly {
+        readonly caseId: string;
+        readonly reason: string;
+        readonly state: "active" | "audited-core" | "quarantined" | "retired";
+        readonly improvementRecordId?: string | undefined;
+    }[];
+    readonly activeCaseIds: readonly string[];
+    readonly auditedCoreCaseIds: readonly string[];
+    readonly quarantinedCaseIds: readonly string[];
+    readonly retiredCaseIds: readonly string[];
+}, RepositoryFoundryError, never>;
+export declare const makeImprovementLoop: Effect.Effect<ImprovementLoopShape, never, never>;
+export declare const ImprovementLoopLive: Layer.Layer<ImprovementLoop, never, never>;
+export {};

package/dist/services/improvement-loop/service.js

@@ -0,0 +1,176 @@
+import { Context, Effect, Layer } from "effect";
+import { RepositoryFoundryError } from "../../errors.js";
+import { assertRepositoryFoundryImprovementCycleV1 } from "../../repository-improvement-protocol.js";
+const ALLOWED_ACTIONS = {
+    "new-authentic-work": new Set(["add-seed"]),
+    "oracle-escape": new Set([
+        "add-fixture",
+        "strengthen-oracle",
+        "quarantine-case"
+    ]),
+    "false-rejection": new Set([
+        "add-valid-alternative",
+        "strengthen-oracle",
+        "quarantine-case"
+    ]),
+    "coverage-gap": new Set([
+        "add-seed",
+        "add-fixture",
+        "regenerate-specification"
+    ]),
+    instability: new Set(["quarantine-case"]),
+    "environment-drift": new Set(["quarantine-case", "retire-case"]),
+    "contract-drift": new Set([
+        "regenerate-specification",
+        "quarantine-case",
+        "retire-case"
+    ]),
+    "realism-drift": new Set([
+        "regenerate-specification",
+        "quarantine-case",
+        "retire-case"
+    ]),
+    "semantic-duplicate": new Set(["retire-case"]),
+    superseded: new Set(["retire-case"])
+};
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "compile-improvement-cycle",
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const compileRecord = (draft, knownCaseIds, auditedCoreCaseIds, lifecycleChangedCaseIds) => {
+    const reviewerIds = new Set(draft.reviews
+        .filter((review) => review.independentlyProduced)
+        .map((review) => review.reviewerId));
+    const lifecycleAction = draft.action === "quarantine-case" || draft.action === "retire-case";
+    const rejectionReasons = [
+        ...(draft.id.trim().length === 0 ? ["improvement id is empty"] : []),
+        ...(draft.summary.trim().length === 0
+            ? ["improvement summary is empty"]
+            : []),
+        ...(ALLOWED_ACTIONS[draft.trigger].has(draft.action)
+            ? []
+            : [
+                `action ${JSON.stringify(draft.action)} is invalid for trigger ${JSON.stringify(draft.trigger)}`
+            ]),
+        ...(draft.reviews.some((review) => review.verdict === "reject")
+            ? ["an independent review rejected the proposed improvement"]
+            : []),
+        ...(reviewerIds.size >= 2 &&
+            draft.reviews.filter((review) => review.independentlyProduced && review.verdict === "approve").length >= 2
+            ? []
+            : ["two distinct independent approvals are required"]),
+        ...(lifecycleAction && draft.affectedCaseIds.length === 0
+            ? ["lifecycle improvements require an affected case"]
+            : []),
+        ...draft.affectedCaseIds
+            .filter((caseId) => !knownCaseIds.has(caseId))
+            .map((caseId) => `affected case is unknown: ${caseId}`),
+        ...(lifecycleAction
+            ? draft.affectedCaseIds
+                .filter((caseId) => auditedCoreCaseIds.has(caseId))
+                .map((caseId) => `audited core case cannot be silently removed: ${caseId}`)
+            : []),
+        ...(lifecycleAction
+            ? draft.affectedCaseIds
+                .filter((caseId) => lifecycleChangedCaseIds.has(caseId))
+                .map((caseId) => `case already has a lifecycle decision in this cycle: ${caseId}`)
+            : [])
+    ];
+    return {
+        version: 1,
+        ...draft,
+        decision: rejectionReasons.length === 0 ? "applied" : "rejected",
+        rejectionReasons
+    };
+};
+export class ImprovementLoop extends Context.Service()("@velum-labs/routekit-eval-setup/ImprovementLoop") {
+}
+export const compileRepositoryFoundryImprovementCycleV1 = Effect.fn("ImprovementLoop.compileCycle")(function* (input) {
+    if (input.cycleId.trim().length === 0) {
+        return yield* failure("improvement cycle id is empty");
+    }
+    const inputCaseIds = input.library.cases.map((benchmarkCase) => benchmarkCase.id);
+    const knownCaseIds = new Set(inputCaseIds);
+    const auditedCoreCaseIds = new Set(input.auditedCoreCaseIds);
+    const unknownCoreCaseIds = [...auditedCoreCaseIds].filter((caseId) => !knownCaseIds.has(caseId));
+    if (unknownCoreCaseIds.length > 0) {
+        return yield* failure(`audited core contains unknown cases: ${unknownCoreCaseIds.join(", ")}`);
+    }
+    const draftIds = new Set(input.drafts.map((draft) => draft.id));
+    if (draftIds.size !== input.drafts.length) {
+        return yield* failure("improvement draft ids must be unique");
+    }
+    const lifecycleChangedCaseIds = new Set();
+    const records = [];
+    for (const draft of input.drafts) {
+        const record = compileRecord(draft, knownCaseIds, auditedCoreCaseIds, lifecycleChangedCaseIds);
+        records.push(record);
+        if (record.decision === "applied" &&
+            (record.action === "quarantine-case" ||
+                record.action === "retire-case")) {
+            for (const caseId of record.affectedCaseIds) {
+                lifecycleChangedCaseIds.add(caseId);
+            }
+        }
+    }
+    const lifecycle = inputCaseIds
+        .map((caseId) => {
+        const record = records.find((candidate) => candidate.decision === "applied" &&
+            (candidate.action === "quarantine-case" ||
+                candidate.action === "retire-case") &&
+            candidate.affectedCaseIds.includes(caseId));
+        if (record?.action === "quarantine-case") {
+            return {
+                caseId,
+                state: "quarantined",
+                improvementRecordId: record.id,
+                reason: record.summary
+            };
+        }
+        if (record?.action === "retire-case") {
+            return {
+                caseId,
+                state: "retired",
+                improvementRecordId: record.id,
+                reason: record.summary
+            };
+        }
+        if (auditedCoreCaseIds.has(caseId)) {
+            return {
+                caseId,
+                state: "audited-core",
+                reason: "Retained as a reviewed generator-regression case."
+            };
+        }
+        return {
+            caseId,
+            state: "active",
+            reason: "Accepted and active in the validated library."
+        };
+    })
+        .sort((left, right) => left.caseId.localeCompare(right.caseId));
+    const byState = (state) => lifecycle
+        .filter((entry) => entry.state === state)
+        .map((entry) => entry.caseId);
+    const cycle = {
+        version: 1,
+        cycleId: input.cycleId,
+        inputCaseIds: [...inputCaseIds].sort(),
+        records,
+        lifecycle,
+        activeCaseIds: byState("active"),
+        auditedCoreCaseIds: byState("audited-core"),
+        quarantinedCaseIds: byState("quarantined"),
+        retiredCaseIds: byState("retired")
+    };
+    yield* Effect.try({
+        try: () => assertRepositoryFoundryImprovementCycleV1(cycle),
+        catch: (cause) => failure("compiled improvement cycle failed validation", cause)
+    });
+    return cycle;
+});
+export const makeImprovementLoop = Effect.succeed(ImprovementLoop.of({
+    compileCycle: compileRepositoryFoundryImprovementCycleV1
+}));
+export const ImprovementLoopLive = Layer.effect(ImprovementLoop, makeImprovementLoop);

package/dist/services/language-model/service.d.ts

@@ -0,0 +1,52 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import { RepositoryFoundryError } from "../../errors.js";
+import { EvalAuthoringTransport } from "../../project-authoring.js";
+import { type RepositoryFoundryModelCallV1, type RepositoryFoundryModelPlanV1, type RepositoryFoundryModelRoleV1, type RepositoryFoundryReasoningEffortV1 } from "../../repository-language-model-protocol.js";
+export type RepositoryFoundryStructuredGenerationV1<A> = {
+    readonly value: A;
+    readonly call: RepositoryFoundryModelCallV1;
+};
+export type RepositoryStructuredModelAssignmentV1<Role extends string> = {
+    readonly role: Role;
+    readonly model: string;
+    readonly reasoningEffort: RepositoryFoundryReasoningEffortV1;
+};
+export type RepositoryAssignedStructuredGenerationV1<A, Role extends string> = {
+    readonly value: A;
+    readonly call: {
+        readonly operationId: string;
+        readonly role: Role;
+        readonly model: string;
+        readonly reasoningEffort: RepositoryFoundryReasoningEffortV1;
+        readonly callId?: string;
+    };
+};
+export type RepositoryFoundryLanguageModelShape = {
+    readonly generateAssignedStructured: <A, Role extends string>(input: {
+        readonly assignment: RepositoryStructuredModelAssignmentV1<Role>;
+        readonly operationId: string;
+        readonly instructions: string;
+        readonly input: unknown;
+        readonly schemaName: string;
+        readonly outputSchema: Schema.Codec<A, unknown, never, unknown>;
+        readonly maximumOutputTokens: number;
+        readonly reviewInputVersion?: 2;
+    }) => Effect.Effect<RepositoryAssignedStructuredGenerationV1<A, Role>, RepositoryFoundryError>;
+    readonly generateStructured: <A>(input: {
+        readonly plan: RepositoryFoundryModelPlanV1;
+        readonly role: RepositoryFoundryModelRoleV1;
+        readonly operationId: string;
+        readonly instructions: string;
+        readonly input: unknown;
+        readonly schemaName: string;
+        readonly outputSchema: Schema.Codec<A, unknown, never, unknown>;
+        readonly maximumOutputTokens: number;
+        readonly reviewInputVersion?: 2;
+    }) => Effect.Effect<RepositoryFoundryStructuredGenerationV1<A>, RepositoryFoundryError>;
+};
+declare const RepositoryFoundryLanguageModel_base: Context.ServiceClass<RepositoryFoundryLanguageModel, "@velum-labs/routekit-eval-setup/RepositoryFoundryLanguageModel", RepositoryFoundryLanguageModelShape>;
+export declare class RepositoryFoundryLanguageModel extends RepositoryFoundryLanguageModel_base {
+}
+export declare const makeRepositoryFoundryLanguageModel: Effect.Effect<RepositoryFoundryLanguageModelShape, never, EvalAuthoringTransport>;
+export declare const RepositoryFoundryLanguageModelLive: Layer.Layer<RepositoryFoundryLanguageModel, never, EvalAuthoringTransport>;
+export {};

package/dist/services/language-model/service.js

@@ -0,0 +1,194 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import { evalAuthoringRequestByteLimit, evalAuthoringResponsesRequestBody } from "../../adapters/authoring-responses-request.js";
+import { encodeRepositoryReviewEvidenceV2, REPOSITORY_REVIEW_EVIDENCE_V2_INSTRUCTIONS } from "../../adapters/repository-review-evidence.js";
+import { strictAuthoringSchema } from "../../adapters/strict-authoring-schema.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { EvalAuthoringTransport } from "../../project-authoring.js";
+import { assertRepositoryFoundryModelPlanV1, repositoryFoundryModelAssignmentV1 } from "../../repository-language-model-protocol.js";
+import { reportFoundryAuthoringArtifactV1, reportFoundryModelCallV1 } from "../foundry-progress/service.js";
+export class RepositoryFoundryLanguageModel extends Context.Service()("@velum-labs/routekit-eval-setup/RepositoryFoundryLanguageModel") {
+}
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "invoke-language-model",
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const malformedResponse = (modelResponseFailure, detail, cause) => new RepositoryFoundryError({
+    operation: "invoke-language-model",
+    modelResponseFailure,
+    detail,
+    cause
+});
+const detailOf = (cause) => cause instanceof Error && cause.message.trim().length > 0 ? cause.message : String(cause);
+export const makeRepositoryFoundryLanguageModel = Effect.gen(function* () {
+    const transport = yield* EvalAuthoringTransport;
+    const generateAssignedStructured = (input) => Effect.gen(function* () {
+        yield* Effect.try({
+            try: () => {
+                if (input.assignment.role.trim().length === 0 ||
+                    input.assignment.model.trim().length === 0 ||
+                    input.assignment.reasoningEffort.trim().length === 0 ||
+                    input.operationId.trim().length === 0 ||
+                    input.instructions.trim().length === 0 ||
+                    input.schemaName.trim().length === 0 ||
+                    !Number.isInteger(input.maximumOutputTokens) ||
+                    input.maximumOutputTokens < 1) {
+                    throw new Error("repository foundry model request requires a bounded, named assignment");
+                }
+            },
+            catch: (cause) => failure("repository foundry model request failed validation", cause)
+        });
+        const strictSchema = yield* Effect.try({
+            try: () => {
+                const document = Schema.toJsonSchemaDocument(input.outputSchema);
+                return strictAuthoringSchema(Object.keys(document.definitions).length === 0
+                    ? document.schema
+                    : {
+                        ...document.schema,
+                        $defs: document.definitions
+                    });
+            },
+            catch: (cause) => failure("repository foundry output schema is not strict-provider compatible", cause)
+        });
+        const jsonSchema = strictSchema.jsonSchema;
+        const request = yield* Effect.try({
+            try: () => {
+                const original = {
+                    operationId: input.operationId,
+                    model: input.assignment.model,
+                    instructions: input.instructions,
+                    input: JSON.stringify(input.input),
+                    schemaName: input.schemaName,
+                    jsonSchema,
+                    maximumOutputTokens: input.maximumOutputTokens,
+                    foundryRole: input.assignment.role,
+                    reasoningEffort: input.assignment.reasoningEffort,
+                    ...(input.reviewInputVersion === undefined
+                        ? {}
+                        : { reviewInputVersion: input.reviewInputVersion })
+                };
+                const requestByteLimit = evalAuthoringRequestByteLimit(original);
+                if (Buffer.byteLength(evalAuthoringResponsesRequestBody(original)) <= requestByteLimit)
+                    return original;
+                const sourceBases = new Set();
+                const collect = (value) => {
+                    if (Array.isArray(value)) {
+                        for (const entry of value)
+                            collect(entry);
+                    }
+                    else if (value !== null && typeof value === "object") {
+                        const record = value;
+                        if (typeof record.content === "string")
+                            sourceBases.add(record.content);
+                        for (const entry of Object.values(record))
+                            collect(entry);
+                    }
+                };
+                const originalInput = JSON.parse(original.input);
+                collect(originalInput);
+                const compact = {
+                    ...original,
+                    instructions: `${original.instructions}\n\n${REPOSITORY_REVIEW_EVIDENCE_V2_INSTRUCTIONS}`,
+                    input: JSON.stringify(encodeRepositoryReviewEvidenceV2(originalInput, [...sourceBases]))
+                };
+                if (Buffer.byteLength(evalAuthoringResponsesRequestBody(compact)) > requestByteLimit)
+                    throw new Error("complete role evidence exceeds the bounded request after lossless compaction");
+                return compact;
+            },
+            catch: (cause) => failure(`language-model role ${input.assignment.role} input preparation failed: ${detailOf(cause)}`, cause)
+        });
+        yield* reportFoundryModelCallV1({
+            role: input.assignment.role,
+            operationId: input.operationId,
+            phase: "start"
+        });
+        const completion = yield* (transport.completeDetailed === undefined
+            ? transport.complete(request).pipe(Effect.map((text) => ({ text })), Effect.mapError((cause) => failure(`language-model role ${input.assignment.role} failed: ${detailOf(cause)}`, cause)))
+            : transport
+                .completeDetailed(request)
+                .pipe(Effect.mapError((cause) => failure(`language-model role ${input.assignment.role} failed: ${detailOf(cause)}`, cause)))).pipe(Effect.tapError(() => reportFoundryModelCallV1({
+            role: input.assignment.role,
+            operationId: input.operationId,
+            phase: "failed"
+        })), Effect.onInterrupt(() => reportFoundryModelCallV1({
+            role: input.assignment.role,
+            operationId: input.operationId,
+            phase: "failed"
+        })));
+        const callId = !("callId" in completion) || completion.callId === undefined
+            ? undefined
+            : completion.callId;
+        // A returned response consumed a provider call even when JSON decoding,
+        // schema validation, or durable artifact recording subsequently fails.
+        yield* reportFoundryModelCallV1({
+            role: input.assignment.role,
+            operationId: input.operationId,
+            phase: "complete",
+            ...(callId === undefined ? {} : { callId })
+        });
+        const artifact = {
+            version: 1,
+            operationId: input.operationId,
+            role: input.assignment.role,
+            model: input.assignment.model,
+            reasoningEffort: input.assignment.reasoningEffort,
+            schemaName: input.schemaName,
+            validation: "received",
+            request: {
+                instructions: request.instructions,
+                input: JSON.parse(request.input),
+                jsonSchema,
+                maximumOutputTokens: input.maximumOutputTokens
+            },
+            response: {
+                text: completion.text,
+                ...(callId === undefined ? {} : { callId })
+            }
+        };
+        yield* reportFoundryAuthoringArtifactV1(artifact);
+        const parsed = yield* Effect.try({
+            try: () => JSON.parse(completion.text),
+            catch: (cause) => malformedResponse("invalid-json", `language-model role ${input.assignment.role} returned invalid JSON`, cause)
+        });
+        const normalized = yield* Effect.try({
+            try: () => strictSchema.normalizeResponse(parsed),
+            catch: (cause) => malformedResponse("normalization", "repository foundry structured response could not restore optional fields", cause)
+        });
+        const value = yield* Schema.decodeUnknownEffect(input.outputSchema)(normalized).pipe(Effect.mapError((cause) => malformedResponse("schema", `language-model role ${input.assignment.role} violated ${input.schemaName}`, cause)));
+        yield* reportFoundryAuthoringArtifactV1({ ...artifact, validation: "validated", value });
+        return {
+            value,
+            call: {
+                operationId: input.operationId,
+                role: input.assignment.role,
+                model: input.assignment.model,
+                reasoningEffort: input.assignment.reasoningEffort,
+                ...(callId === undefined ? {} : { callId })
+            }
+        };
+    });
+    const generateStructured = (input) => Effect.gen(function* () {
+        yield* Effect.try({
+            try: () => assertRepositoryFoundryModelPlanV1(input.plan),
+            catch: (cause) => failure("repository foundry model request failed validation", cause)
+        });
+        const assignment = repositoryFoundryModelAssignmentV1(input.plan, input.role);
+        return yield* generateAssignedStructured({
+            assignment,
+            operationId: input.operationId,
+            instructions: input.instructions,
+            input: input.input,
+            schemaName: input.schemaName,
+            outputSchema: input.outputSchema,
+            maximumOutputTokens: input.maximumOutputTokens,
+            ...(input.reviewInputVersion === undefined
+                ? {}
+                : { reviewInputVersion: input.reviewInputVersion })
+        });
+    });
+    return RepositoryFoundryLanguageModel.of({
+        generateAssignedStructured,
+        generateStructured
+    });
+});
+export const RepositoryFoundryLanguageModelLive = Layer.effect(RepositoryFoundryLanguageModel, makeRepositoryFoundryLanguageModel);