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

package/dist/repository-semantic-calibration.js

@@ -0,0 +1,581 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { strictAuthoringSchema } from "./adapters/strict-authoring-schema.js";
+import { RepositoryFoundryError } from "./errors.js";
+import { REPOSITORY_FOUNDRY_REQUEST_INPUT_CEILING } from "./repository-foundry-plan-protocol.js";
+import { assertRepositoryFoundryModelPlanV1, RepositoryFoundryModelPlanV1, repositoryFoundryModelAssignmentV1 } from "./repository-language-model-protocol.js";
+import { REPOSITORY_SEMANTIC_CALIBRATION_MAXIMUM_EXAMPLES, REPOSITORY_SEMANTIC_CALIBRATION_MAXIMUM_REPETITIONS, RepositorySemanticCalibrationExecutableCheckV1, RepositorySemanticCalibrationManifestV1, RepositorySemanticCalibrationObservationV1, RepositorySemanticCalibrationPlanV1, RepositorySemanticCalibrationReportV1 } from "./repository-semantic-calibration-protocol.js";
+import { executeRepositorySemanticReviewV1, prepareRepositorySemanticReviewV1, repositorySemanticReviewIndependenceFindingsV1 } from "./services/case-generation/service.js";
+const roles = ["solution-critic-a", "solution-critic-b"];
+const sha256 = (text) => createHash("sha256").update(text).digest("hex");
+const canonicalJson = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .filter((key) => record[key] !== undefined)
+            .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+            .join(",")}}`;
+    }
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        throw new Error("calibration requires JSON data");
+    return encoded;
+};
+const digestOf = (value) => sha256(canonicalJson(value));
+const requireValue = (condition, message) => {
+    if (!condition)
+        throw new Error(`semantic calibration: ${message}`);
+};
+const nonempty = (value) => value.trim().length > 0;
+const digest = (value) => /^[a-f0-9]{64}$/u.test(value);
+const identifier = (value) => /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u.test(value);
+const unique = (values) => values.every(nonempty) && new Set(values).size === values.length;
+const sameIds = (left, right) => unique(left) && left.length === right.length && left.every((id) => right.includes(id));
+const sourcePath = (value) => nonempty(value) &&
+    !value.includes("\\") &&
+    !value.includes("\0") &&
+    value.split("/").every((part) => !["", ".", "..", ".git"].includes(part));
+const decode = (schema, value) => Schema.decodeUnknownSync(schema, { onExcessProperty: "error" })(value);
+const freeze = (value) => {
+    if (value !== null && typeof value === "object") {
+        for (const entry of Object.values(value))
+            freeze(entry);
+        Object.freeze(value);
+    }
+    return value;
+};
+const detached = (value) => JSON.parse(JSON.stringify(value));
+export const repositorySemanticCalibrationInputDigestV1 = (input) => digestOf(input);
+export const repositorySemanticCalibrationExampleDigestV1 = (example) => digestOf({
+    id: example.id,
+    split: example.split,
+    repository: example.repository,
+    input: example.input,
+    adjudication: example.adjudication
+});
+const validateExample = (example) => {
+    const input = example.input;
+    requireValue(identifier(example.id), "example id must be a bounded identifier");
+    requireValue(nonempty(example.repository.id), "repository identity is missing");
+    requireValue(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(example.repository.commit), "repository commit must be an exact Git object id");
+    requireValue(input.visible.lane === "repository-agent" &&
+        input.visible.checkoutCommit === example.repository.commit &&
+        input.repositoryEnvironment.commit === example.repository.commit &&
+        input.repositoryEnvironment.localImports.commit === example.repository.commit, "development source and visible task must bind one exact repository commit");
+    requireValue(input.visible.lane === "repository-agent" && nonempty(input.visible.requestText), "a nonempty visible repository task is required");
+    requireValue(input.targetBehavior.length > 0 &&
+        unique(input.targetBehavior.map((clause) => clause.id)) &&
+        input.targetBehavior.every((clause) => nonempty(clause.description)), "explicit unique behavior clauses are required");
+    const behaviorIds = input.targetBehavior.map((clause) => clause.id);
+    const sources = [
+        ...input.preChangeSources,
+        ...input.repositoryEnvironment.sources,
+        ...input.repositoryEnvironment.localImports.sources
+    ];
+    requireValue(input.preChangeSources.length > 0 && sources.length <= 128, "development source context must be nonempty and bounded");
+    const sourceDigests = new Map();
+    for (const source of sources) {
+        requireValue(sourcePath(source.path), "source path must be canonical and repository-relative");
+        const sourceDigest = sha256(source.content);
+        requireValue(!sourceDigests.has(source.path) || sourceDigests.get(source.path) === sourceDigest, "the same pinned source path has conflicting contents");
+        sourceDigests.set(source.path, sourceDigest);
+    }
+    requireValue(sameIds(example.repository.sourceDigests.map((entry) => entry.path), [...sourceDigests.keys()]), "source digest inventory must cover the exact supplied sources");
+    for (const entry of example.repository.sourceDigests)
+        requireValue(digest(entry.sha256) && sourceDigests.get(entry.path) === entry.sha256, "pinned source digest mismatch");
+    requireValue(input.solutions.length >= 2 &&
+        input.solutions.length <= 32 &&
+        unique(input.solutions.map((solution) => solution.id)) &&
+        input.solutions.every((solution) => identifier(solution.id) && nonempty(solution.family)), "each example requires two to 32 uniquely identified development controls");
+    for (const solution of input.solutions) {
+        requireValue(solution.fileOverrides.length > 0 &&
+            unique(solution.fileOverrides.map((source) => source.path)) &&
+            solution.fileOverrides.every((source) => sourcePath(source.path)), "control overrides must be complete, uniquely named repository-relative files");
+    }
+    requireValue(input.comparisonSolutionIds.length === 2 &&
+        unique(input.comparisonSolutionIds) &&
+        input.comparisonSolutionIds.every((id) => input.solutions.some((solution) => solution.id === id)), "comparison membership must identify exactly two supplied controls independently of their labels");
+    if (input.behavioralScope !== undefined)
+        requireValue(unique(input.behavioralScope.map((clause) => clause.id)) &&
+            input.behavioralScope.every((clause) => nonempty(clause.description) &&
+                clause.behaviorIds.length > 0 &&
+                clause.behaviorIds.every((id) => behaviorIds.includes(id))), "behavioral scope must reference the supplied visible behavior");
+    const adjudication = example.adjudication;
+    requireValue(adjudication.inputDigest === repositorySemanticCalibrationInputDigestV1(input), "adjudication does not bind the exact development input");
+    requireValue(adjudication.adjudicatorIds.length > 0 &&
+        unique(adjudication.adjudicatorIds) &&
+        adjudication.generatorIdentities.length > 0 &&
+        unique(adjudication.generatorIdentities) &&
+        adjudication.adjudicatorIds.every((id) => !adjudication.generatorIdentities.includes(id)), "adjudication requires explicit identities separate from the example generators");
+    requireValue(Number.isFinite(Date.parse(adjudication.completedAt)), "adjudication completion timestamp is invalid");
+    requireValue(adjudication.evidence.length > 0 && unique(adjudication.evidence.map((entry) => entry.id)), "independent adjudication evidence is required");
+    const executableChecks = new Map();
+    for (const evidence of adjudication.evidence) {
+        requireValue(nonempty(evidence.content) &&
+            digest(evidence.sha256) &&
+            sha256(evidence.content) === evidence.sha256, "adjudication evidence digest mismatch");
+        if (evidence.kind === "executable-development-check") {
+            requireValue(nonempty(evidence.checkerSource) &&
+                digest(evidence.checkerSourceSha256) &&
+                sha256(evidence.checkerSource) === evidence.checkerSourceSha256, "independent checker source digest mismatch");
+            const check = decode(RepositorySemanticCalibrationExecutableCheckV1, JSON.parse(evidence.content));
+            requireValue(check.inputDigest === adjudication.inputDigest &&
+                check.checkerSourceDigest === evidence.checkerSourceSha256 &&
+                adjudication.adjudicatorIds.includes(check.checkerId) &&
+                unique(check.checks.map((entry) => entry.solutionId)) &&
+                check.checks.every((entry) => entry.repetitions >= 2 &&
+                    input.solutions.some((solution) => solution.id === entry.solutionId)), "executable adjudication must positively confirm pinned controls with repeated independent checks");
+            executableChecks.set(evidence.id, check);
+        }
+    }
+    requireValue(sameIds(adjudication.labels.map((label) => label.solutionId), input.solutions.map((solution) => solution.id)), "every control requires one adjudicated label");
+    for (const label of adjudication.labels) {
+        requireValue(nonempty(label.rationale) &&
+            label.evidenceIds.length > 0 &&
+            unique(label.evidenceIds) &&
+            label.evidenceIds.every((id) => adjudication.evidence.some((entry) => entry.id === id)) &&
+            unique(label.violatedBehaviorIds) &&
+            label.violatedBehaviorIds.every((id) => behaviorIds.includes(id)) &&
+            (label.expectedClass === "wrong"
+                ? label.violatedBehaviorIds.length > 0
+                : label.violatedBehaviorIds.length === 0), "labels require consistent visible behavior and explicit independent evidence");
+        if (adjudication.kind === "independent-human-development-adjudication") {
+            requireValue(label.evidenceIds.some((id) => adjudication.evidence.some((entry) => entry.id === id && entry.kind === "human-review")), "human adjudication requires human-review evidence for every expected label");
+        }
+        else {
+            requireValue(label.evidenceIds.some((id) => executableChecks
+                .get(id)
+                ?.checks.some((check) => check.solutionId === label.solutionId &&
+                check.classification === label.expectedClass &&
+                sameIds(check.violatedBehaviorIds, label.violatedBehaviorIds)) === true), "every executable-adjudicated label requires a matching positive independent check");
+        }
+    }
+    requireValue(example.exampleDigest === repositorySemanticCalibrationExampleDigestV1(example), "example digest is stale");
+};
+/** Adjudications and their evidence are deliberately absent from this projection. */
+const prepareCritic = (example, role, version) => prepareRepositorySemanticReviewV1({
+    role,
+    modelContext: {
+        ...(example.input.requestedDimension === undefined
+            ? {}
+            : { requestedDimension: example.input.requestedDimension }),
+        repositoryEnvironment: example.input.repositoryEnvironment,
+        ...(example.input.behavioralScope === undefined
+            ? {}
+            : {
+                targetBehavior: example.input.targetBehavior,
+                behavioralScope: example.input.behavioralScope
+            })
+    },
+    visible: example.input.visible,
+    targetBehavior: example.input.targetBehavior,
+    preChangeSources: example.input.preChangeSources,
+    solutions: example.input.solutions,
+    comparisonSolutionIds: example.input.comparisonSolutionIds,
+    ...(version === null ? {} : { validControlReviewVersion: version })
+});
+export const compileRepositorySemanticCalibrationPlanV1 = (input) => {
+    requireValue(Buffer.byteLength(JSON.stringify(input.manifest)) <= 8 * 1024 * 1024, "development manifest exceeds the bounded private input size");
+    const manifest = decode(RepositorySemanticCalibrationManifestV1, detached(input.manifest));
+    const modelPlan = decode(RepositoryFoundryModelPlanV1, detached(input.modelPlan));
+    assertRepositoryFoundryModelPlanV1(modelPlan);
+    requireValue([null, 1, 2].includes(input.validControlReviewVersion), "valid-control review policy must be explicitly frozen");
+    requireValue(Number.isSafeInteger(input.repetitions) &&
+        input.repetitions >= 2 &&
+        input.repetitions <= REPOSITORY_SEMANTIC_CALIBRATION_MAXIMUM_REPETITIONS, "repetitions must be between two and five");
+    requireValue(manifest.examples.length > 0 &&
+        manifest.examples.length <= REPOSITORY_SEMANTIC_CALIBRATION_MAXIMUM_EXAMPLES &&
+        unique(manifest.examples.map((example) => example.id)) &&
+        unique(manifest.examples.map((example) => example.exampleDigest)), "development examples must be nonempty, bounded, and unique");
+    for (const example of manifest.examples)
+        validateExample(example);
+    const labels = manifest.examples.flatMap((example) => example.adjudication.labels);
+    requireValue(manifest.thresholds.minimumScenarios > 0 &&
+        manifest.thresholds.minimumValidControls > 0 &&
+        manifest.thresholds.minimumWrongControls > 0 &&
+        manifest.examples.length >= manifest.thresholds.minimumScenarios &&
+        labels.filter((label) => label.expectedClass === "valid").length >=
+            manifest.thresholds.minimumValidControls &&
+        labels.filter((label) => label.expectedClass === "wrong").length >=
+            manifest.thresholds.minimumWrongControls, "the declared minimum development population must be present before calibration");
+    const criticModels = roles.map((role) => repositoryFoundryModelAssignmentV1(modelPlan, role).model);
+    for (const example of manifest.examples)
+        requireValue(example.adjudication.adjudicatorIds.every((id) => !criticModels.includes(id)), "the calibrated model cannot supply its own expected-label adjudication");
+    const preparedCritics = manifest.examples.flatMap((example) => roles.map((role) => {
+        const prepared = prepareCritic(example, role, input.validControlReviewVersion);
+        const document = Schema.toJsonSchemaDocument(prepared.outputSchema);
+        const schema = strictAuthoringSchema(Object.keys(document.definitions).length === 0
+            ? document.schema
+            : { ...document.schema, $defs: document.definitions }).jsonSchema;
+        return {
+            exampleId: example.id,
+            role,
+            model: repositoryFoundryModelAssignmentV1(modelPlan, role).model,
+            reasoningEffort: repositoryFoundryModelAssignmentV1(modelPlan, role).reasoningEffort,
+            inputDigest: sha256(JSON.stringify(prepared.input)),
+            instructionsDigest: sha256(prepared.instructions),
+            schemaName: prepared.schemaName,
+            schemaDigest: digestOf(schema),
+            maximumOutputTokens: prepared.maximumOutputTokens
+        };
+    }));
+    const callCount = preparedCritics.length * input.repetitions;
+    const body = {
+        version: 1,
+        policyVersion: 1,
+        purpose: "development-semantic-calibration",
+        admissionCredit: false,
+        manifest,
+        manifestDigest: digestOf(manifest),
+        modelPlan,
+        validControlReviewVersion: input.validControlReviewVersion,
+        repetitions: input.repetitions,
+        callCount,
+        maximumInputBytesPerCall: REPOSITORY_FOUNDRY_REQUEST_INPUT_CEILING,
+        requiredTotalInputTokens: callCount * REPOSITORY_FOUNDRY_REQUEST_INPUT_CEILING,
+        requiredTotalOutputTokens: input.repetitions *
+            preparedCritics.reduce((sum, critic) => sum + critic.maximumOutputTokens, 0),
+        maximumOutputTokensPerCall: Math.max(...preparedCritics.map((critic) => critic.maximumOutputTokens)),
+        preparedCritics
+    };
+    return freeze({ ...body, planDigest: digestOf(body) });
+};
+const checkedPlan = (value) => {
+    const candidate = decode(RepositorySemanticCalibrationPlanV1, value);
+    const expected = compileRepositorySemanticCalibrationPlanV1(candidate);
+    requireValue(canonicalJson(candidate) === canonicalJson(expected), "plan digest, prepared critic policy, models, inputs, or bounds are stale");
+    return expected;
+};
+export function assertRepositorySemanticCalibrationPlanV1(value) {
+    checkedPlan(value);
+}
+const predictionFailure = (example, reviews) => {
+    if (!sameIds(reviews.map((review) => review.solutionId), example.input.solutions.map((solution) => solution.id)))
+        return "review-population";
+    const behaviorIds = example.input.targetBehavior.map((clause) => clause.id);
+    if (reviews.some((review) => !unique(review.violatedBehaviorIds) ||
+        review.violatedBehaviorIds.some((id) => !behaviorIds.includes(id)) ||
+        (review.classification === "wrong" && review.violatedBehaviorIds.length === 0) ||
+        (review.classification === "valid" && review.violatedBehaviorIds.length !== 0)))
+        return "behavior-reference";
+    return undefined;
+};
+const reviewOutcome = (example, value, version, criticInput, callId) => {
+    const predictionProblem = predictionFailure(example, value.reviews);
+    if (predictionProblem !== undefined)
+        return { kind: "malformed", reason: predictionProblem };
+    if (value.reviews.some((review) => !nonempty(review.detail)))
+        return { kind: "malformed", reason: "review-rationale" };
+    const independence = value.implementationIndependence;
+    if (version !== null) {
+        try {
+            // The same production predicate validates ids, source references, duplicate
+            // features, and outcome consistency. Returned policy findings are NOT an
+            // adjudication of mechanism truth or benchmark admission.
+            repositorySemanticReviewIndependenceFindingsV1(value, example.input.comparisonSolutionIds.map((id) => example.input.solutions.find((solution) => solution.id === id)), "development calibration critic", version, criticInput);
+        }
+        catch {
+            return { kind: "malformed", reason: "independence-review" };
+        }
+    }
+    else if (independence !== undefined) {
+        return { kind: "malformed", reason: "independence-review" };
+    }
+    return {
+        kind: "classified",
+        reviews: value.reviews.map((review) => ({
+            solutionId: review.solutionId,
+            classification: review.classification,
+            violatedBehaviorIds: [...review.violatedBehaviorIds]
+        })),
+        ...(independence === undefined ? {} : { independence: independence.outcome }),
+        ...(callId === undefined ? {} : { callId })
+    };
+};
+const scheduled = (plan, operationId) => {
+    requireValue(identifier(operationId), "operation id must be a bounded identifier");
+    return plan.manifest.examples.flatMap((example) => Array.from({ length: plan.repetitions }, (_, index) => roles.map((role) => {
+        const binding = plan.preparedCritics.find((entry) => entry.exampleId === example.id && entry.role === role);
+        return {
+            exampleId: example.id,
+            exampleDigest: example.exampleDigest,
+            role,
+            repetition: index + 1,
+            operationId: `${operationId}:${plan.planDigest}:${example.id}:repeat-${String(index + 1)}:${role}`,
+            model: binding.model,
+            reasoningEffort: binding.reasoningEffort,
+            inputDigest: binding.inputDigest,
+            instructionsDigest: binding.instructionsDigest,
+            schemaDigest: binding.schemaDigest
+        };
+    })).flat());
+};
+const observationKey = (value) => `${value.exampleId}\0${value.role}\0${String(value.repetition)}`;
+const countObservations = (plan, observations) => {
+    const counts = {
+        scheduledCalls: observations.length,
+        classifiedCalls: 0,
+        malformedCalls: 0,
+        executionFailureCalls: 0,
+        notRunCalls: 0,
+        scheduledControls: 0,
+        unscoredControls: 0,
+        validAsValid: 0,
+        validAsWrong: 0,
+        validAsUncertain: 0,
+        wrongAsValid: 0,
+        wrongAsWrong: 0,
+        wrongAsUncertain: 0,
+        independenceIndependent: 0,
+        independenceCorrelated: 0,
+        independenceUncertain: 0,
+        repeatabilityGroups: 0,
+        stableClassificationGroups: 0,
+        changedClassificationGroups: 0,
+        incompleteClassificationGroups: 0
+    };
+    const cells = {
+        valid: { valid: "validAsValid", wrong: "validAsWrong", uncertain: "validAsUncertain" },
+        wrong: { valid: "wrongAsValid", wrong: "wrongAsWrong", uncertain: "wrongAsUncertain" }
+    };
+    for (const observation of observations) {
+        const example = plan.manifest.examples.find((entry) => entry.id === observation.exampleId);
+        counts.scheduledControls += example.input.solutions.length;
+        const outcome = observation.outcome;
+        if (outcome.kind !== "classified") {
+            counts.unscoredControls += example.input.solutions.length;
+            if (outcome.kind === "malformed")
+                counts.malformedCalls += 1;
+            else if (outcome.kind === "execution-failure")
+                counts.executionFailureCalls += 1;
+            else
+                counts.notRunCalls += 1;
+            continue;
+        }
+        counts.classifiedCalls += 1;
+        for (const review of outcome.reviews) {
+            const expected = example.adjudication.labels.find((label) => label.solutionId === review.solutionId).expectedClass;
+            counts[cells[expected][review.classification]] += 1;
+        }
+        if (outcome.independence === "independent")
+            counts.independenceIndependent += 1;
+        if (outcome.independence === "correlated")
+            counts.independenceCorrelated += 1;
+        if (outcome.independence === "uncertain")
+            counts.independenceUncertain += 1;
+    }
+    for (const example of plan.manifest.examples)
+        for (const role of roles) {
+            const repeated = observations.filter((entry) => entry.exampleId === example.id && entry.role === role);
+            if (repeated.length === 0)
+                continue;
+            for (const solution of example.input.solutions) {
+                counts.repeatabilityGroups += 1;
+                const predictions = repeated.flatMap((entry) => entry.outcome.kind === "classified"
+                    ? entry.outcome.reviews
+                        .filter((review) => review.solutionId === solution.id)
+                        .map((review) => review.classification)
+                    : []);
+                if (predictions.length !== plan.repetitions)
+                    counts.incompleteClassificationGroups += 1;
+                else if (new Set(predictions).size === 1)
+                    counts.stableClassificationGroups += 1;
+                else
+                    counts.changedClassificationGroups += 1;
+            }
+        }
+    return counts;
+};
+const limitations = [
+    "Development measurement only: no held-out generalization, benchmark admission, or routing credit.",
+    "Evidence and checker digests bind supplied adjudication provenance; artifact origin and actual execution require independent verification.",
+    "Manifest thresholds are predeclared and copied unchanged; this report does not manufacture a pass.",
+    "Repeatability measures classifications, not rationales; stable uncertainty is not semantic correctness.",
+    "Mechanism-independence accuracy and full valid-control admission are not established by executable correctness labels.",
+    "Separate role calls or similar mechanisms do not establish statistical independence.",
+    "This report is not exposure authority; the CLI must reconcile and close its strict upstream execution evidence."
+];
+export const compileRepositorySemanticCalibrationReportV1 = (input) => {
+    const plan = checkedPlan(input.plan);
+    const observations = decode(Schema.Array(RepositorySemanticCalibrationObservationV1), detached(input.observations));
+    const expected = scheduled(plan, input.operationId);
+    const byKey = new Map(observations.map((entry) => [observationKey(entry), entry]));
+    requireValue(observations.length === expected.length && byKey.size === observations.length, "report must retain exactly one observation for every scheduled critic call");
+    const ordered = expected.map((metadata) => {
+        const observation = byKey.get(observationKey(metadata));
+        requireValue(observation !== undefined, "report is missing a scheduled observation");
+        const { outcome, ...actual } = observation;
+        requireValue(canonicalJson(actual) === canonicalJson(metadata), "observation does not bind the exact example, role, repetition, model, or prepared policy");
+        if (outcome.kind === "classified") {
+            const example = plan.manifest.examples.find((entry) => entry.id === metadata.exampleId);
+            requireValue(predictionFailure(example, outcome.reviews) === undefined, "classified observation has malformed control predictions");
+            requireValue(plan.validControlReviewVersion === null
+                ? outcome.independence === undefined
+                : outcome.independence !== undefined, "classified observation uses the wrong independence policy");
+            requireValue(outcome.callId === undefined || nonempty(outcome.callId), "a returned call id must be nonempty");
+        }
+        return observation;
+    });
+    let executionStopped = false;
+    for (let index = 0; index < ordered.length; index += roles.length) {
+        const pair = ordered.slice(index, index + roles.length);
+        requireValue(executionStopped
+            ? pair.every((entry) => entry.outcome.kind === "not-run")
+            : pair.every((entry) => entry.outcome.kind !== "not-run"), "not-run observations must exactly follow the first execution-failure pair");
+        executionStopped ||= pair.some((entry) => entry.outcome.kind === "execution-failure");
+    }
+    const callIds = ordered.flatMap((entry) => entry.outcome.kind === "classified" && entry.outcome.callId !== undefined
+        ? [entry.outcome.callId]
+        : []);
+    requireValue(unique(callIds), "returned critic call ids cannot be reused");
+    const controls = plan.manifest.examples.flatMap((example) => example.adjudication.labels.map((label) => ({
+        exampleId: example.id,
+        exampleDigest: example.exampleDigest,
+        solutionId: label.solutionId,
+        controlDigest: digestOf({
+            repository: example.repository.id,
+            commit: example.repository.commit,
+            inputDigest: example.adjudication.inputDigest,
+            solution: example.input.solutions.find((solution) => solution.id === label.solutionId)
+        }),
+        expectedClass: label.expectedClass,
+        evidenceDigests: label.evidenceIds.map((id) => example.adjudication.evidence.find((entry) => entry.id === id).sha256)
+    })));
+    const validControls = controls.filter((entry) => entry.expectedClass === "valid").length;
+    const wrongControls = controls.length - validControls;
+    const body = {
+        version: 1,
+        policyVersion: 1,
+        purpose: "development-semantic-calibration",
+        admissionCredit: false,
+        planDigest: plan.planDigest,
+        manifestDigest: plan.manifestDigest,
+        operationId: input.operationId,
+        coverage: {
+            semanticCorrectness: "development-only",
+            mechanismIndependence: "unadjudicated",
+            fullValidControlAcceptance: "not-established"
+        },
+        thresholds: plan.manifest.thresholds,
+        denominators: {
+            scenarios: plan.manifest.examples.length,
+            models: new Set(plan.preparedCritics.map((entry) => entry.model)).size,
+            critics: roles.length,
+            repetitions: plan.repetitions,
+            distinctControls: controls.length,
+            distinctValidControls: validControls,
+            distinctWrongControls: wrongControls,
+            scheduledCalls: plan.callCount,
+            scheduledControlClassifications: controls.length * plan.repetitions * roles.length,
+            scheduledValidClassifications: validControls * plan.repetitions * roles.length,
+            scheduledWrongClassifications: wrongControls * plan.repetitions * roles.length
+        },
+        controls,
+        observations: ordered,
+        counts: countObservations(plan, ordered),
+        byRole: roles.map((role) => ({
+            role,
+            counts: countObservations(plan, ordered.filter((entry) => entry.role === role))
+        })),
+        limitations: [...limitations]
+    };
+    return freeze({ ...body, reportDigest: digestOf(body) });
+};
+export function assertRepositorySemanticCalibrationReportV1(input) {
+    const report = decode(RepositorySemanticCalibrationReportV1, input.report);
+    const expected = compileRepositorySemanticCalibrationReportV1({
+        plan: input.plan,
+        operationId: report.operationId,
+        observations: report.observations
+    });
+    requireValue(canonicalJson(report) === canonicalJson(expected), "report digest, counts, labels, provenance, thresholds, or denominators are inconsistent");
+}
+/**
+ * Composition only: the CLI owns immutable execution claims, strict submission
+ * authority, wall time, durable observation writes, and final evidence closure.
+ * No retries, repairs, generated labels, admission, or direct provider transport.
+ */
+export const executeRepositorySemanticCalibrationPlanV1 = Effect.fn("CaseGeneration.calibrateDevelopmentSemanticReview")(function* (input) {
+    const plan = yield* Effect.try({
+        try: () => checkedPlan(input.plan),
+        catch: (cause) => new RepositoryFoundryError({
+            operation: "plan-generation",
+            detail: "development semantic calibration plan failed validation",
+            cause
+        })
+    });
+    const schedule = yield* Effect.try({
+        try: () => scheduled(plan, input.operationId),
+        catch: (cause) => new RepositoryFoundryError({
+            operation: "plan-generation",
+            detail: "development semantic calibration operation identity is invalid",
+            cause
+        })
+    });
+    const observations = [];
+    let executionStopped = false;
+    for (let index = 0; index < schedule.length; index += roles.length) {
+        const pair = yield* Effect.all(schedule.slice(index, index + roles.length).map((metadata) => Effect.gen(function* () {
+            let outcome;
+            if (executionStopped) {
+                outcome = { kind: "not-run", reason: "prior-execution-failure" };
+            }
+            else {
+                const example = plan.manifest.examples.find((entry) => entry.id === metadata.exampleId);
+                const prepared = prepareCritic(example, metadata.role, plan.validControlReviewVersion);
+                outcome = yield* executeRepositorySemanticReviewV1({
+                    modelPlan: plan.modelPlan,
+                    operationId: metadata.operationId,
+                    prepared
+                }).pipe(Effect.matchEffect({
+                    // Required artifact/progress I/O is not a model observation. The
+                    // existing LM boundary owns invoke-language-model errors; failures
+                    // from other owners must retain their original typed cause.
+                    onFailure: (error) => error.operation !== "invoke-language-model"
+                        ? Effect.fail(error)
+                        : Effect.succeed(error.modelResponseFailure === undefined
+                            ? { kind: "execution-failure", errorOperation: error.operation }
+                            : { kind: "malformed", reason: error.modelResponseFailure }),
+                    onSuccess: (generation) => Effect.sync(() => {
+                        if (generation.call.operationId !== metadata.operationId ||
+                            generation.call.role !== metadata.role ||
+                            generation.call.model !== metadata.model ||
+                            generation.call.reasoningEffort !== metadata.reasoningEffort)
+                            return { kind: "execution-failure", errorOperation: "invoke-language-model" };
+                        let value;
+                        try {
+                            value = decode(prepared.outputSchema, generation.value);
+                        }
+                        catch {
+                            return { kind: "malformed", reason: "schema" };
+                        }
+                        return reviewOutcome(example, value, plan.validControlReviewVersion, prepared.input, generation.call.callId);
+                    })
+                }));
+            }
+            const observation = freeze({ ...metadata, outcome });
+            // Deliberately outside model-error classification. Required I/O failure
+            // propagates with its original typed cause and cannot earn report credit.
+            if (input.recordObservation !== undefined)
+                yield* input.recordObservation(observation);
+            return observation;
+        })), { concurrency: roles.length });
+        observations.push(...pair);
+        executionStopped ||= pair.some((entry) => entry.outcome.kind === "execution-failure");
+    }
+    return yield* Effect.try({
+        try: () => compileRepositorySemanticCalibrationReportV1({
+            plan,
+            operationId: input.operationId,
+            observations
+        }),
+        catch: (cause) => new RepositoryFoundryError({
+            operation: "execute-generation",
+            detail: "development semantic calibration report failed validation",
+            cause
+        })
+    });
+});