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

package/dist/repository-routing-benchmark-protocol.d.ts

@@ -0,0 +1,176 @@
+import { Schema } from "effect";
+export declare const RepositoryDimensionLabelReviewV1: Schema.Struct<{
+    readonly reviewerId: Schema.String;
+    readonly model: Schema.String;
+    readonly callId: Schema.optionalKey<Schema.String>;
+    readonly outcome: Schema.Literals<readonly ["approve", "reject"]>;
+    readonly primaryDimensionId: Schema.String;
+    readonly detail: Schema.String;
+    readonly evidenceIds: Schema.$Array<Schema.String>;
+    readonly independentLabel: Schema.Struct<{
+        readonly caseId: Schema.String;
+        readonly basisDigest: Schema.String;
+        readonly scores: Schema.$Array<Schema.Struct<{
+            readonly dimensionId: Schema.String;
+            readonly score: Schema.Finite;
+        }>>;
+        readonly unknownProbability: Schema.Finite;
+    }>;
+}>;
+export type RepositoryDimensionLabelReviewV1 = typeof RepositoryDimensionLabelReviewV1.Type;
+export declare const RepositoryReviewedDimensionLabelV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly caseId: Schema.String;
+    readonly basisDigest: Schema.String;
+    readonly authorModel: Schema.String;
+    readonly authorCallId: Schema.optionalKey<Schema.String>;
+    readonly authorDetail: Schema.String;
+    readonly authorEvidenceIds: Schema.$Array<Schema.String>;
+    readonly label: Schema.Struct<{
+        readonly caseId: Schema.String;
+        readonly basisDigest: Schema.String;
+        readonly scores: Schema.$Array<Schema.Struct<{
+            readonly dimensionId: Schema.String;
+            readonly score: Schema.Finite;
+        }>>;
+        readonly unknownProbability: Schema.Finite;
+    }>;
+    readonly reviews: Schema.$Array<Schema.Struct<{
+        readonly reviewerId: Schema.String;
+        readonly model: Schema.String;
+        readonly callId: Schema.optionalKey<Schema.String>;
+        readonly outcome: Schema.Literals<readonly ["approve", "reject"]>;
+        readonly primaryDimensionId: Schema.String;
+        readonly detail: Schema.String;
+        readonly evidenceIds: Schema.$Array<Schema.String>;
+        readonly independentLabel: Schema.Struct<{
+            readonly caseId: Schema.String;
+            readonly basisDigest: Schema.String;
+            readonly scores: Schema.$Array<Schema.Struct<{
+                readonly dimensionId: Schema.String;
+                readonly score: Schema.Finite;
+            }>>;
+            readonly unknownProbability: Schema.Finite;
+        }>;
+    }>>;
+}>;
+export type RepositoryReviewedDimensionLabelV1 = typeof RepositoryReviewedDimensionLabelV1.Type;
+export declare const RepositoryRoutingEligibilityPolicyV1: Schema.Struct<{
+    readonly activeDimensionThreshold: Schema.Finite;
+    readonly maximumUnknownProbability: Schema.Finite;
+    readonly minimumDominanceMargin: Schema.Finite;
+    readonly minimumCasesPerDimension: Schema.Finite;
+}>;
+export type RepositoryRoutingEligibilityPolicyV1 = typeof RepositoryRoutingEligibilityPolicyV1.Type;
+export declare const RepositoryRoutingCaseAssignmentV1: Schema.Struct<{
+    readonly caseId: Schema.String;
+    readonly basisDigest: Schema.String;
+    readonly labelDigest: Schema.String;
+    readonly primaryDimensionId: Schema.optionalKey<Schema.String>;
+    readonly primaryScore: Schema.Finite;
+    readonly secondaryScore: Schema.Finite;
+    readonly unknownProbability: Schema.Finite;
+    readonly eligible: Schema.Boolean;
+    readonly rejectionReasons: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryRoutingCaseAssignmentV1 = typeof RepositoryRoutingCaseAssignmentV1.Type;
+export declare const RepositoryRoutingDimensionSliceV1: Schema.Struct<{
+    readonly dimensionId: Schema.String;
+    readonly caseIds: Schema.$Array<Schema.String>;
+    readonly minimumRequired: Schema.Finite;
+    readonly routingReady: Schema.Boolean;
+}>;
+export type RepositoryRoutingDimensionSliceV1 = typeof RepositoryRoutingDimensionSliceV1.Type;
+export declare const RepositoryRoutingBenchmarkV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly basis: Schema.Struct<{
+        readonly version: Schema.Literal<3>;
+        readonly basisId: Schema.String;
+        readonly basisDigest: Schema.String;
+        readonly repositoryDigest: Schema.String;
+        readonly facetSnapshot: Schema.Struct<{
+            readonly repositoryId: Schema.String;
+            readonly repositoryDigest: Schema.String;
+            readonly name: Schema.String;
+            readonly purpose: Schema.String;
+            readonly languages: Schema.$Array<Schema.String>;
+            readonly frameworks: Schema.$Array<Schema.String>;
+            readonly components: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+                readonly purpose: Schema.String;
+                readonly paths: Schema.$Array<Schema.String>;
+            }>>;
+        }>;
+        readonly dimensions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly inclusions: Schema.$Array<Schema.String>;
+            readonly exclusions: Schema.$Array<Schema.String>;
+            readonly confusableDimensionIds: Schema.$Array<Schema.String>;
+            readonly boundaryRules: Schema.$Array<Schema.String>;
+            readonly repositoryFacets: Schema.Struct<{
+                readonly componentIds: Schema.$Array<Schema.String>;
+                readonly pathAnchors: Schema.$Array<Schema.String>;
+                readonly symbolAnchors: Schema.$Array<Schema.String>;
+            }>;
+            readonly positiveExamples: Schema.$Array<Schema.String>;
+            readonly negativeExamples: Schema.$Array<Schema.String>;
+            readonly codeSummaries: Schema.$Array<Schema.String>;
+            readonly representativeSnippets: Schema.$Array<Schema.String>;
+        }>>;
+        readonly provenance: Schema.Struct<{
+            readonly generatorVersion: Schema.String;
+            readonly recipeId: Schema.String;
+            readonly authorModel: Schema.optionalKey<Schema.String>;
+            readonly sourceDigests: Schema.$Array<Schema.String>;
+            readonly constructionTaskDigest: Schema.optionalKey<Schema.String>;
+            readonly origin: Schema.optionalKey<Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["generated", "incumbent-enriched", "repair"]>;
+                readonly sourceBasisId: Schema.optionalKey<Schema.String>;
+                readonly sourceBasisVersion: Schema.optionalKey<Schema.Finite>;
+            }>>;
+        }>;
+        readonly validation: Schema.optionalKey<Schema.Struct<{
+            readonly validationDatasetDigest: Schema.String;
+            readonly caseCount: Schema.Finite;
+            readonly activeMae: Schema.Finite;
+            readonly activeF1: Schema.Finite;
+            readonly topDimensionAgreement: Schema.Finite;
+            readonly unknownMae: Schema.Finite;
+            readonly referenceUnknownRate: Schema.Finite;
+            readonly selectionScore: Schema.Finite;
+        }>>;
+    }>;
+    readonly policy: Schema.Struct<{
+        readonly activeDimensionThreshold: Schema.Finite;
+        readonly maximumUnknownProbability: Schema.Finite;
+        readonly minimumDominanceMargin: Schema.Finite;
+        readonly minimumCasesPerDimension: Schema.Finite;
+    }>;
+    readonly assignments: Schema.$Array<Schema.Struct<{
+        readonly caseId: Schema.String;
+        readonly basisDigest: Schema.String;
+        readonly labelDigest: Schema.String;
+        readonly primaryDimensionId: Schema.optionalKey<Schema.String>;
+        readonly primaryScore: Schema.Finite;
+        readonly secondaryScore: Schema.Finite;
+        readonly unknownProbability: Schema.Finite;
+        readonly eligible: Schema.Boolean;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>>;
+    readonly dimensions: Schema.$Array<Schema.Struct<{
+        readonly dimensionId: Schema.String;
+        readonly caseIds: Schema.$Array<Schema.String>;
+        readonly minimumRequired: Schema.Finite;
+        readonly routingReady: Schema.Boolean;
+    }>>;
+    readonly eligibleCaseIds: Schema.$Array<Schema.String>;
+    readonly libraryOnlyCaseIds: Schema.$Array<Schema.String>;
+    readonly routingReady: Schema.Boolean;
+    readonly coverageGaps: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryRoutingBenchmarkV1 = typeof RepositoryRoutingBenchmarkV1.Type;
+export declare function assertRepositoryReviewedDimensionLabelV1(value: unknown): asserts value is RepositoryReviewedDimensionLabelV1;
+export declare function assertRepositoryRoutingEligibilityPolicyV1(value: unknown): asserts value is RepositoryRoutingEligibilityPolicyV1;

package/dist/repository-routing-benchmark-protocol.js

@@ -0,0 +1,103 @@
+import { DimensionScoreLabelV3, RoutingBasisV3 } from "@velum-labs/routekit-eval-contracts";
+import { Schema } from "effect";
+export const RepositoryDimensionLabelReviewV1 = Schema.Struct({
+    reviewerId: Schema.String,
+    model: Schema.String,
+    callId: Schema.optionalKey(Schema.String),
+    outcome: Schema.Literals(["approve", "reject"]),
+    primaryDimensionId: Schema.String,
+    detail: Schema.String,
+    evidenceIds: Schema.Array(Schema.String),
+    independentLabel: DimensionScoreLabelV3
+});
+export const RepositoryReviewedDimensionLabelV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    caseId: Schema.String,
+    basisDigest: Schema.String,
+    authorModel: Schema.String,
+    authorCallId: Schema.optionalKey(Schema.String),
+    authorDetail: Schema.String,
+    authorEvidenceIds: Schema.Array(Schema.String),
+    label: DimensionScoreLabelV3,
+    reviews: Schema.Array(RepositoryDimensionLabelReviewV1)
+});
+export const RepositoryRoutingEligibilityPolicyV1 = Schema.Struct({
+    activeDimensionThreshold: Schema.Finite,
+    maximumUnknownProbability: Schema.Finite,
+    minimumDominanceMargin: Schema.Finite,
+    minimumCasesPerDimension: Schema.Finite
+});
+export const RepositoryRoutingCaseAssignmentV1 = Schema.Struct({
+    caseId: Schema.String,
+    basisDigest: Schema.String,
+    labelDigest: Schema.String,
+    primaryDimensionId: Schema.optionalKey(Schema.String),
+    primaryScore: Schema.Finite,
+    secondaryScore: Schema.Finite,
+    unknownProbability: Schema.Finite,
+    eligible: Schema.Boolean,
+    rejectionReasons: Schema.Array(Schema.String)
+});
+export const RepositoryRoutingDimensionSliceV1 = Schema.Struct({
+    dimensionId: Schema.String,
+    caseIds: Schema.Array(Schema.String),
+    minimumRequired: Schema.Finite,
+    routingReady: Schema.Boolean
+});
+export const RepositoryRoutingBenchmarkV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    basis: RoutingBasisV3,
+    policy: RepositoryRoutingEligibilityPolicyV1,
+    assignments: Schema.Array(RepositoryRoutingCaseAssignmentV1),
+    dimensions: Schema.Array(RepositoryRoutingDimensionSliceV1),
+    eligibleCaseIds: Schema.Array(Schema.String),
+    libraryOnlyCaseIds: Schema.Array(Schema.String),
+    routingReady: Schema.Boolean,
+    coverageGaps: Schema.Array(Schema.String)
+});
+const GPT_56_SOL = /^[a-z0-9][a-z0-9._-]*\/gpt-5\.6-sol$/u;
+const GPT_56_TERRA = /^[a-z0-9][a-z0-9._-]*\/gpt-5\.6-terra$/u;
+const GPT_56_LUNA = /^[a-z0-9][a-z0-9._-]*\/gpt-5\.6-luna$/u;
+export function assertRepositoryReviewedDimensionLabelV1(value) {
+    const reviewed = Schema.decodeUnknownSync(RepositoryReviewedDimensionLabelV1)(value);
+    const reviewerIds = new Set(reviewed.reviews.map((review) => review.reviewerId));
+    const reviewerModels = new Set(reviewed.reviews.map((review) => review.model));
+    const hasTerra = reviewed.reviews.some((review) => GPT_56_TERRA.test(review.model));
+    const hasLuna = reviewed.reviews.some((review) => GPT_56_LUNA.test(review.model));
+    if (reviewed.caseId.trim().length === 0 ||
+        reviewed.basisDigest.trim().length === 0 ||
+        reviewed.label.caseId !== reviewed.caseId ||
+        reviewed.label.basisDigest !== reviewed.basisDigest ||
+        !GPT_56_SOL.test(reviewed.authorModel) ||
+        reviewed.authorDetail.trim().length === 0 ||
+        reviewed.authorEvidenceIds.length === 0 ||
+        reviewed.authorEvidenceIds.some((evidenceId) => evidenceId.trim().length === 0) ||
+        reviewed.reviews.length !== 2 ||
+        reviewerIds.size !== 2 ||
+        reviewerModels.size !== 2 ||
+        !hasTerra ||
+        !hasLuna ||
+        reviewed.reviews.some((review) => review.reviewerId.trim().length === 0 ||
+            review.primaryDimensionId.trim().length === 0 ||
+            review.detail.trim().length === 0 ||
+            review.evidenceIds.length === 0 ||
+            review.evidenceIds.some((evidenceId) => evidenceId.trim().length === 0) ||
+            review.independentLabel.caseId !== reviewed.caseId ||
+            review.independentLabel.basisDigest !== reviewed.basisDigest ||
+            [...review.independentLabel.scores].sort((left, right) => right.score - left.score || left.dimensionId.localeCompare(right.dimensionId))[0]?.dimensionId !== review.primaryDimensionId)) {
+        throw new Error("repository dimension labels require one GPT-5.6 Sol author and distinct Terra/Luna evidence-linked reviews");
+    }
+}
+export function assertRepositoryRoutingEligibilityPolicyV1(value) {
+    const policy = Schema.decodeUnknownSync(RepositoryRoutingEligibilityPolicyV1)(value);
+    const unitValues = [
+        policy.activeDimensionThreshold,
+        policy.maximumUnknownProbability,
+        policy.minimumDominanceMargin
+    ];
+    if (unitValues.some((entry) => entry < 0 || entry > 1) ||
+        !Number.isSafeInteger(policy.minimumCasesPerDimension) ||
+        policy.minimumCasesPerDimension < 1) {
+        throw new Error("repository routing eligibility policy requires unit-interval thresholds and a positive case minimum");
+    }
+}

package/dist/repository-routing-model-protocol.d.ts

@@ -0,0 +1,36 @@
+import { Schema } from "effect";
+import { RepositoryFoundryReasoningEffortV1 } from "./repository-language-model-protocol.js";
+export declare const REPOSITORY_ROUTING_MODEL_ROLES: readonly ["dimension-labeler", "dimension-critic-terra", "dimension-critic-luna"];
+export declare const RepositoryRoutingModelRoleV1: Schema.Literals<readonly ["dimension-labeler", "dimension-critic-terra", "dimension-critic-luna"]>;
+export type RepositoryRoutingModelRoleV1 = typeof RepositoryRoutingModelRoleV1.Type;
+export declare const RepositoryRoutingModelAssignmentV1: Schema.Struct<{
+    readonly role: Schema.Literals<readonly ["dimension-labeler", "dimension-critic-terra", "dimension-critic-luna"]>;
+    readonly model: Schema.String;
+    readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+}>;
+export type RepositoryRoutingModelAssignmentV1 = typeof RepositoryRoutingModelAssignmentV1.Type;
+export declare const RepositoryRoutingModelPlanV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly assignments: Schema.$Array<Schema.Struct<{
+        readonly role: Schema.Literals<readonly ["dimension-labeler", "dimension-critic-terra", "dimension-critic-luna"]>;
+        readonly model: Schema.String;
+        readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+    }>>;
+}>;
+export type RepositoryRoutingModelPlanV1 = typeof RepositoryRoutingModelPlanV1.Type;
+export declare const RepositoryRoutingModelCallV1: Schema.Struct<{
+    readonly operationId: Schema.String;
+    readonly role: Schema.Literals<readonly ["dimension-labeler", "dimension-critic-terra", "dimension-critic-luna"]>;
+    readonly model: Schema.String;
+    readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+    readonly callId: Schema.optionalKey<Schema.String>;
+}>;
+export type RepositoryRoutingModelCallV1 = typeof RepositoryRoutingModelCallV1.Type;
+export declare function assertRepositoryRoutingModelPlanV1(value: unknown): asserts value is RepositoryRoutingModelPlanV1;
+export declare function repositoryRoutingModelAssignmentV1(plan: RepositoryRoutingModelPlanV1, role: RepositoryRoutingModelRoleV1): RepositoryRoutingModelAssignmentV1;
+export declare function gpt56RepositoryRoutingModelPlanV1(input: {
+    readonly solModel: string;
+    readonly terraModel: string;
+    readonly lunaModel: string;
+    readonly reasoningEffort?: RepositoryFoundryReasoningEffortV1;
+}): RepositoryRoutingModelPlanV1;

package/dist/repository-routing-model-protocol.js

@@ -0,0 +1,89 @@
+import { Schema } from "effect";
+import { RepositoryFoundryReasoningEffortV1 } from "./repository-language-model-protocol.js";
+export const REPOSITORY_ROUTING_MODEL_ROLES = [
+    "dimension-labeler",
+    "dimension-critic-terra",
+    "dimension-critic-luna"
+];
+export const RepositoryRoutingModelRoleV1 = Schema.Literals(REPOSITORY_ROUTING_MODEL_ROLES);
+export const RepositoryRoutingModelAssignmentV1 = Schema.Struct({
+    role: RepositoryRoutingModelRoleV1,
+    model: Schema.String,
+    reasoningEffort: RepositoryFoundryReasoningEffortV1
+});
+export const RepositoryRoutingModelPlanV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    assignments: Schema.Array(RepositoryRoutingModelAssignmentV1)
+});
+export const RepositoryRoutingModelCallV1 = Schema.Struct({
+    operationId: Schema.String,
+    role: RepositoryRoutingModelRoleV1,
+    model: Schema.String,
+    reasoningEffort: RepositoryFoundryReasoningEffortV1,
+    callId: Schema.optionalKey(Schema.String)
+});
+const GPT_56_SOL = /^[a-z0-9][a-z0-9._-]*\/gpt-5\.6-sol$/u;
+const GPT_56_TERRA = /^[a-z0-9][a-z0-9._-]*\/gpt-5\.6-terra$/u;
+const GPT_56_LUNA = /^[a-z0-9][a-z0-9._-]*\/gpt-5\.6-luna$/u;
+const requiredModelFor = (role) => {
+    switch (role) {
+        case "dimension-labeler":
+            return GPT_56_SOL;
+        case "dimension-critic-terra":
+            return GPT_56_TERRA;
+        case "dimension-critic-luna":
+            return GPT_56_LUNA;
+    }
+};
+export function assertRepositoryRoutingModelPlanV1(value) {
+    const plan = Schema.decodeUnknownSync(RepositoryRoutingModelPlanV1)(value);
+    const byRole = new Map(plan.assignments.map((assignment) => [assignment.role, assignment]));
+    if (plan.assignments.length !== REPOSITORY_ROUTING_MODEL_ROLES.length ||
+        byRole.size !== plan.assignments.length ||
+        REPOSITORY_ROUTING_MODEL_ROLES.some((role) => !byRole.has(role))) {
+        throw new Error("repository routing model plan requires exactly one Sol labeler and distinct Terra/Luna critics");
+    }
+    for (const assignment of plan.assignments) {
+        if (!requiredModelFor(assignment.role).test(assignment.model)) {
+            throw new Error(`repository routing role ${assignment.role} requires its designated GPT-5.6 family model`);
+        }
+        if (assignment.reasoningEffort === "low" ||
+            assignment.reasoningEffort === "medium" ||
+            assignment.reasoningEffort === "ultra") {
+            throw new Error(`repository routing role ${assignment.role} requires high, xhigh, or max reasoning supported by all three GPT-5.6 models`);
+        }
+    }
+}
+export function repositoryRoutingModelAssignmentV1(plan, role) {
+    assertRepositoryRoutingModelPlanV1(plan);
+    const assignment = plan.assignments.find((candidate) => candidate.role === role);
+    if (assignment === undefined) {
+        throw new Error(`repository routing model role is unassigned: ${role}`);
+    }
+    return assignment;
+}
+export function gpt56RepositoryRoutingModelPlanV1(input) {
+    const reasoningEffort = input.reasoningEffort ?? "high";
+    const plan = {
+        version: 1,
+        assignments: [
+            {
+                role: "dimension-labeler",
+                model: input.solModel,
+                reasoningEffort
+            },
+            {
+                role: "dimension-critic-terra",
+                model: input.terraModel,
+                reasoningEffort
+            },
+            {
+                role: "dimension-critic-luna",
+                model: input.lunaModel,
+                reasoningEffort
+            }
+        ]
+    };
+    assertRepositoryRoutingModelPlanV1(plan);
+    return plan;
+}

package/dist/repository-routing-plan-protocol.d.ts

@@ -0,0 +1,112 @@
+import { Schema } from "effect";
+export declare const REPOSITORY_ROUTING_LABEL_SEMANTIC_CALLS = 3;
+export declare const REPOSITORY_ROUTING_LABEL_TRANSIENT_RETRIES = 3;
+export declare const REPOSITORY_ROUTING_LABEL_INPUT_CEILING = 512000;
+export declare const REPOSITORY_ROUTING_LABEL_OUTPUT_CEILING = 16384;
+export declare const REPOSITORY_ROUTING_LABEL_WALL_TIME_MS: number;
+export declare const RepositoryRoutingLabelingBudgetV1: Schema.Struct<{
+    readonly semanticModelCalls: Schema.Finite;
+    readonly plannedModelCalls: Schema.Finite;
+    readonly maximumTransientRetries: Schema.Finite;
+    readonly requiredTotalInputTokens: Schema.Finite;
+    readonly requiredTotalOutputTokens: Schema.Finite;
+    readonly perCallOutputTokens: Schema.Finite;
+    readonly wallTimeMs: Schema.Finite;
+}>;
+export type RepositoryRoutingLabelingBudgetV1 = typeof RepositoryRoutingLabelingBudgetV1.Type;
+export declare const RepositoryRoutingLabelingPlanV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly planDigest: Schema.String;
+    readonly foundryPlanDigest: Schema.String;
+    readonly caseId: Schema.String;
+    readonly behavioralFingerprint: Schema.String;
+    readonly basis: Schema.Struct<{
+        readonly version: Schema.Literal<3>;
+        readonly basisId: Schema.String;
+        readonly basisDigest: Schema.String;
+        readonly repositoryDigest: Schema.String;
+        readonly facetSnapshot: Schema.Struct<{
+            readonly repositoryId: Schema.String;
+            readonly repositoryDigest: Schema.String;
+            readonly name: Schema.String;
+            readonly purpose: Schema.String;
+            readonly languages: Schema.$Array<Schema.String>;
+            readonly frameworks: Schema.$Array<Schema.String>;
+            readonly components: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+                readonly purpose: Schema.String;
+                readonly paths: Schema.$Array<Schema.String>;
+            }>>;
+        }>;
+        readonly dimensions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly inclusions: Schema.$Array<Schema.String>;
+            readonly exclusions: Schema.$Array<Schema.String>;
+            readonly confusableDimensionIds: Schema.$Array<Schema.String>;
+            readonly boundaryRules: Schema.$Array<Schema.String>;
+            readonly repositoryFacets: Schema.Struct<{
+                readonly componentIds: Schema.$Array<Schema.String>;
+                readonly pathAnchors: Schema.$Array<Schema.String>;
+                readonly symbolAnchors: Schema.$Array<Schema.String>;
+            }>;
+            readonly positiveExamples: Schema.$Array<Schema.String>;
+            readonly negativeExamples: Schema.$Array<Schema.String>;
+            readonly codeSummaries: Schema.$Array<Schema.String>;
+            readonly representativeSnippets: Schema.$Array<Schema.String>;
+        }>>;
+        readonly provenance: Schema.Struct<{
+            readonly generatorVersion: Schema.String;
+            readonly recipeId: Schema.String;
+            readonly authorModel: Schema.optionalKey<Schema.String>;
+            readonly sourceDigests: Schema.$Array<Schema.String>;
+            readonly constructionTaskDigest: Schema.optionalKey<Schema.String>;
+            readonly origin: Schema.optionalKey<Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["generated", "incumbent-enriched", "repair"]>;
+                readonly sourceBasisId: Schema.optionalKey<Schema.String>;
+                readonly sourceBasisVersion: Schema.optionalKey<Schema.Finite>;
+            }>>;
+        }>;
+        readonly validation: Schema.optionalKey<Schema.Struct<{
+            readonly validationDatasetDigest: Schema.String;
+            readonly caseCount: Schema.Finite;
+            readonly activeMae: Schema.Finite;
+            readonly activeF1: Schema.Finite;
+            readonly topDimensionAgreement: Schema.Finite;
+            readonly unknownMae: Schema.Finite;
+            readonly referenceUnknownRate: Schema.Finite;
+            readonly selectionScore: Schema.Finite;
+        }>>;
+    }>;
+    readonly modelPlan: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly assignments: Schema.$Array<Schema.Struct<{
+            readonly role: Schema.Literals<readonly ["dimension-labeler", "dimension-critic-terra", "dimension-critic-luna"]>;
+            readonly model: Schema.String;
+            readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+        }>>;
+    }>;
+    readonly policy: Schema.Struct<{
+        readonly activeDimensionThreshold: Schema.Finite;
+        readonly maximumUnknownProbability: Schema.Finite;
+        readonly minimumDominanceMargin: Schema.Finite;
+        readonly minimumCasesPerDimension: Schema.Finite;
+    }>;
+    readonly budget: Schema.Struct<{
+        readonly semanticModelCalls: Schema.Finite;
+        readonly plannedModelCalls: Schema.Finite;
+        readonly maximumTransientRetries: Schema.Finite;
+        readonly requiredTotalInputTokens: Schema.Finite;
+        readonly requiredTotalOutputTokens: Schema.Finite;
+        readonly perCallOutputTokens: Schema.Finite;
+        readonly wallTimeMs: Schema.Finite;
+    }>;
+}>;
+export type RepositoryRoutingLabelingPlanV1 = typeof RepositoryRoutingLabelingPlanV1.Type;
+type PlanWithoutDigest = Omit<RepositoryRoutingLabelingPlanV1, "planDigest">;
+export declare const repositoryRoutingLabelingBudgetV1: () => RepositoryRoutingLabelingBudgetV1;
+export declare const repositoryRoutingLabelingPlanDigestV1: (plan: PlanWithoutDigest) => string;
+export declare function assertRepositoryRoutingLabelingPlanV1(value: unknown): asserts value is RepositoryRoutingLabelingPlanV1;
+export {};

package/dist/repository-routing-plan-protocol.js

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import { RoutingBasisV3 } from "@velum-labs/routekit-eval-contracts";
+import { Schema } from "effect";
+import { RepositoryRoutingEligibilityPolicyV1 } from "./repository-routing-benchmark-protocol.js";
+import { assertRepositoryRoutingModelPlanV1, RepositoryRoutingModelPlanV1 } from "./repository-routing-model-protocol.js";
+export const REPOSITORY_ROUTING_LABEL_SEMANTIC_CALLS = 3;
+export const REPOSITORY_ROUTING_LABEL_TRANSIENT_RETRIES = 3;
+export const REPOSITORY_ROUTING_LABEL_INPUT_CEILING = 512_000;
+export const REPOSITORY_ROUTING_LABEL_OUTPUT_CEILING = 16_384;
+export const REPOSITORY_ROUTING_LABEL_WALL_TIME_MS = 30 * 60_000;
+export const RepositoryRoutingLabelingBudgetV1 = Schema.Struct({
+    semanticModelCalls: Schema.Finite,
+    plannedModelCalls: Schema.Finite,
+    maximumTransientRetries: Schema.Finite,
+    requiredTotalInputTokens: Schema.Finite,
+    requiredTotalOutputTokens: Schema.Finite,
+    perCallOutputTokens: Schema.Finite,
+    wallTimeMs: Schema.Finite
+});
+export const RepositoryRoutingLabelingPlanV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    planDigest: Schema.String,
+    foundryPlanDigest: Schema.String,
+    caseId: Schema.String,
+    behavioralFingerprint: Schema.String,
+    basis: RoutingBasisV3,
+    modelPlan: RepositoryRoutingModelPlanV1,
+    policy: RepositoryRoutingEligibilityPolicyV1,
+    budget: RepositoryRoutingLabelingBudgetV1
+});
+const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+export const repositoryRoutingLabelingBudgetV1 = () => {
+    const plannedModelCalls = REPOSITORY_ROUTING_LABEL_SEMANTIC_CALLS + REPOSITORY_ROUTING_LABEL_TRANSIENT_RETRIES;
+    return {
+        semanticModelCalls: REPOSITORY_ROUTING_LABEL_SEMANTIC_CALLS,
+        plannedModelCalls,
+        maximumTransientRetries: REPOSITORY_ROUTING_LABEL_TRANSIENT_RETRIES,
+        requiredTotalInputTokens: plannedModelCalls * REPOSITORY_ROUTING_LABEL_INPUT_CEILING,
+        requiredTotalOutputTokens: plannedModelCalls * REPOSITORY_ROUTING_LABEL_OUTPUT_CEILING,
+        perCallOutputTokens: REPOSITORY_ROUTING_LABEL_OUTPUT_CEILING,
+        wallTimeMs: REPOSITORY_ROUTING_LABEL_WALL_TIME_MS
+    };
+};
+export const repositoryRoutingLabelingPlanDigestV1 = (plan) => digest(plan);
+export function assertRepositoryRoutingLabelingPlanV1(value) {
+    const plan = Schema.decodeUnknownSync(RepositoryRoutingLabelingPlanV1)(value);
+    assertRepositoryRoutingModelPlanV1(plan.modelPlan);
+    const integers = Object.values(plan.budget);
+    if (plan.foundryPlanDigest.trim().length === 0 ||
+        plan.caseId.trim().length === 0 ||
+        plan.behavioralFingerprint.trim().length === 0 ||
+        integers.some((entry) => !Number.isSafeInteger(entry) || entry < 0) ||
+        JSON.stringify(plan.budget) !== JSON.stringify(repositoryRoutingLabelingBudgetV1()) ||
+        plan.planDigest !==
+            repositoryRoutingLabelingPlanDigestV1((({ planDigest: _planDigest, ...withoutDigest }) => withoutDigest)(plan))) {
+        throw new Error("repository routing labeling plan identity or immutable budget is invalid");
+    }
+}

package/dist/repository-routing-quality-policy.d.ts

@@ -0,0 +1,9 @@
+import { type RoutingBasisV3 } from "@velum-labs/routekit-eval-contracts";
+import type { RepositoryValidatedBenchmarkLibraryV1 } from "./repository-benchmark-protocol.js";
+import { type RepositoryReviewedDimensionLabelV1, type RepositoryRoutingBenchmarkV1, type RepositoryRoutingEligibilityPolicyV1 } from "./repository-routing-benchmark-protocol.js";
+export declare function compileRepositoryRoutingBenchmarkV1(input: {
+    readonly basis: RoutingBasisV3;
+    readonly library: RepositoryValidatedBenchmarkLibraryV1;
+    readonly labels: readonly RepositoryReviewedDimensionLabelV1[];
+    readonly policy: RepositoryRoutingEligibilityPolicyV1;
+}): RepositoryRoutingBenchmarkV1;