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

package/dist/repository-specification-critique-protocol.d.ts

@@ -0,0 +1,189 @@
+import { Schema } from "effect";
+export declare const RepositorySpecificationCritiqueAxisV1: Schema.Literals<readonly ["missing-precondition", "unavailable-context", "multiple-interpretations", "hidden-answer-leakage", "unrealistic-phrasing", "unsupported-assumption"]>;
+export type RepositorySpecificationCritiqueAxisV1 = typeof RepositorySpecificationCritiqueAxisV1.Type;
+export declare const RepositorySpecificationCritiqueFindingV1: Schema.Struct<{
+    readonly axis: Schema.Literals<readonly ["missing-precondition", "unavailable-context", "multiple-interpretations", "hidden-answer-leakage", "unrealistic-phrasing", "unsupported-assumption"]>;
+    readonly severity: Schema.Literals<readonly ["blocker", "warning"]>;
+    readonly detail: Schema.String;
+}>;
+export type RepositorySpecificationCritiqueFindingV1 = typeof RepositorySpecificationCritiqueFindingV1.Type;
+export declare const RepositorySpecificationBehaviorCoverageV1: Schema.Struct<{
+    readonly behaviorId: Schema.String;
+    readonly outcome: Schema.Literals<readonly ["covered", "omitted", "uncertain"]>;
+    readonly detail: Schema.String;
+}>;
+export declare const RepositorySpecificationDimensionFitV1: Schema.Struct<{
+    readonly requestedDimension: Schema.String;
+    readonly outcome: Schema.Literals<readonly ["fit", "mismatch", "uncertain"]>;
+    readonly detail: Schema.String;
+    readonly evidencePaths: Schema.$Array<Schema.String>;
+}>;
+export declare const RepositorySpecificationReferenceEvidenceV1: Schema.Struct<{
+    readonly sourceId: Schema.String;
+    readonly startLine: Schema.Finite;
+    readonly endLine: Schema.Finite;
+}>;
+export declare const RepositorySpecificationReferenceScopeV1: Schema.Struct<{
+    readonly clauses: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["changed", "preserved"]>;
+        readonly behaviorIds: Schema.$Array<Schema.String>;
+        readonly description: Schema.String;
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+    }>>;
+    readonly unresolvedQuestions: Schema.$Array<Schema.String>;
+}>;
+export type RepositorySpecificationReferenceScopeV1 = typeof RepositorySpecificationReferenceScopeV1.Type;
+export declare const RepositorySpecificationReferenceCompatibilityV1: Schema.Struct<{
+    readonly outcome: Schema.Literals<readonly ["compatible", "contradictory", "uncertain"]>;
+    readonly detail: Schema.String;
+    readonly scopeCoverage: Schema.$Array<Schema.Struct<{
+        readonly scopeId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["supported", "contradictory", "uncertain"]>;
+        readonly detail: Schema.String;
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+    }>>;
+    readonly questionResolutions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly questionId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["answered", "not-required", "unresolved"]>;
+        readonly detail: Schema.String;
+        readonly affectedScopeIds: Schema.$Array<Schema.String>;
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly sourceId: Schema.String;
+            readonly startLine: Schema.Finite;
+            readonly endLine: Schema.Finite;
+        }>>;
+        readonly visibleScopeExclusion: Schema.optionalKey<Schema.Struct<{
+            readonly quotation: Schema.String;
+            readonly rationale: Schema.String;
+        }>>;
+    }>>>;
+}>;
+export type RepositorySpecificationReferenceCompatibilityV1 = typeof RepositorySpecificationReferenceCompatibilityV1.Type;
+export declare const RepositorySpecificationReviewV1: Schema.Struct<{
+    readonly reviewerId: Schema.String;
+    readonly reviewerKind: Schema.Literals<readonly ["independent-solver", "human-reviewer", "model-critic"]>;
+    readonly independentlyProduced: Schema.Boolean;
+    readonly verdict: Schema.Literals<readonly ["sufficient", "insufficient"]>;
+    readonly detail: Schema.String;
+    readonly criticalBehaviorCoverage: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly behaviorId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["covered", "omitted", "uncertain"]>;
+        readonly detail: Schema.String;
+    }>>>;
+    readonly dimensionFit: Schema.optionalKey<Schema.Struct<{
+        readonly requestedDimension: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["fit", "mismatch", "uncertain"]>;
+        readonly detail: Schema.String;
+        readonly evidencePaths: Schema.$Array<Schema.String>;
+    }>>;
+    readonly referenceCompatibility: Schema.optionalKey<Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["compatible", "contradictory", "uncertain"]>;
+        readonly detail: Schema.String;
+        readonly scopeCoverage: Schema.$Array<Schema.Struct<{
+            readonly scopeId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["supported", "contradictory", "uncertain"]>;
+            readonly detail: Schema.String;
+            readonly evidence: Schema.$Array<Schema.Struct<{
+                readonly sourceId: Schema.String;
+                readonly startLine: Schema.Finite;
+                readonly endLine: Schema.Finite;
+            }>>;
+        }>>;
+        readonly questionResolutions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly questionId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["answered", "not-required", "unresolved"]>;
+            readonly detail: Schema.String;
+            readonly affectedScopeIds: Schema.$Array<Schema.String>;
+            readonly evidence: Schema.$Array<Schema.Struct<{
+                readonly sourceId: Schema.String;
+                readonly startLine: Schema.Finite;
+                readonly endLine: Schema.Finite;
+            }>>;
+            readonly visibleScopeExclusion: Schema.optionalKey<Schema.Struct<{
+                readonly quotation: Schema.String;
+                readonly rationale: Schema.String;
+            }>>;
+        }>>>;
+    }>>;
+    readonly findings: Schema.$Array<Schema.Struct<{
+        readonly axis: Schema.Literals<readonly ["missing-precondition", "unavailable-context", "multiple-interpretations", "hidden-answer-leakage", "unrealistic-phrasing", "unsupported-assumption"]>;
+        readonly severity: Schema.Literals<readonly ["blocker", "warning"]>;
+        readonly detail: Schema.String;
+    }>>;
+}>;
+export type RepositorySpecificationReviewV1 = typeof RepositorySpecificationReviewV1.Type;
+export declare const RepositorySpecificationCritiqueV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly caseId: Schema.String;
+    readonly outcome: Schema.Literals<readonly ["pass", "fail", "review-required"]>;
+    readonly mechanicalFindings: Schema.$Array<Schema.Struct<{
+        readonly axis: Schema.Literals<readonly ["missing-precondition", "unavailable-context", "multiple-interpretations", "hidden-answer-leakage", "unrealistic-phrasing", "unsupported-assumption"]>;
+        readonly severity: Schema.Literals<readonly ["blocker", "warning"]>;
+        readonly detail: Schema.String;
+    }>>;
+    readonly reviews: Schema.$Array<Schema.Struct<{
+        readonly reviewerId: Schema.String;
+        readonly reviewerKind: Schema.Literals<readonly ["independent-solver", "human-reviewer", "model-critic"]>;
+        readonly independentlyProduced: Schema.Boolean;
+        readonly verdict: Schema.Literals<readonly ["sufficient", "insufficient"]>;
+        readonly detail: Schema.String;
+        readonly criticalBehaviorCoverage: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly behaviorId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["covered", "omitted", "uncertain"]>;
+            readonly detail: Schema.String;
+        }>>>;
+        readonly dimensionFit: Schema.optionalKey<Schema.Struct<{
+            readonly requestedDimension: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["fit", "mismatch", "uncertain"]>;
+            readonly detail: Schema.String;
+            readonly evidencePaths: Schema.$Array<Schema.String>;
+        }>>;
+        readonly referenceCompatibility: Schema.optionalKey<Schema.Struct<{
+            readonly outcome: Schema.Literals<readonly ["compatible", "contradictory", "uncertain"]>;
+            readonly detail: Schema.String;
+            readonly scopeCoverage: Schema.$Array<Schema.Struct<{
+                readonly scopeId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["supported", "contradictory", "uncertain"]>;
+                readonly detail: Schema.String;
+                readonly evidence: Schema.$Array<Schema.Struct<{
+                    readonly sourceId: Schema.String;
+                    readonly startLine: Schema.Finite;
+                    readonly endLine: Schema.Finite;
+                }>>;
+            }>>;
+            readonly questionResolutions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly questionId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["answered", "not-required", "unresolved"]>;
+                readonly detail: Schema.String;
+                readonly affectedScopeIds: Schema.$Array<Schema.String>;
+                readonly evidence: Schema.$Array<Schema.Struct<{
+                    readonly sourceId: Schema.String;
+                    readonly startLine: Schema.Finite;
+                    readonly endLine: Schema.Finite;
+                }>>;
+                readonly visibleScopeExclusion: Schema.optionalKey<Schema.Struct<{
+                    readonly quotation: Schema.String;
+                    readonly rationale: Schema.String;
+                }>>;
+            }>>>;
+        }>>;
+        readonly findings: Schema.$Array<Schema.Struct<{
+            readonly axis: Schema.Literals<readonly ["missing-precondition", "unavailable-context", "multiple-interpretations", "hidden-answer-leakage", "unrealistic-phrasing", "unsupported-assumption"]>;
+            readonly severity: Schema.Literals<readonly ["blocker", "warning"]>;
+            readonly detail: Schema.String;
+        }>>;
+    }>>;
+    readonly independentApprovalCount: Schema.Finite;
+    readonly rejectionReasons: Schema.$Array<Schema.String>;
+}>;
+export type RepositorySpecificationCritiqueV1 = typeof RepositorySpecificationCritiqueV1.Type;
+export declare function assertRepositorySpecificationCritiqueV1(value: unknown): asserts value is RepositorySpecificationCritiqueV1;

package/dist/repository-specification-critique-protocol.js

@@ -0,0 +1,103 @@
+import { Schema } from "effect";
+export const RepositorySpecificationCritiqueAxisV1 = Schema.Literals([
+    "missing-precondition",
+    "unavailable-context",
+    "multiple-interpretations",
+    "hidden-answer-leakage",
+    "unrealistic-phrasing",
+    "unsupported-assumption"
+]);
+export const RepositorySpecificationCritiqueFindingV1 = Schema.Struct({
+    axis: RepositorySpecificationCritiqueAxisV1,
+    severity: Schema.Literals(["blocker", "warning"]),
+    detail: Schema.String
+});
+export const RepositorySpecificationBehaviorCoverageV1 = Schema.Struct({
+    behaviorId: Schema.String,
+    outcome: Schema.Literals(["covered", "omitted", "uncertain"]),
+    detail: Schema.String
+});
+export const RepositorySpecificationDimensionFitV1 = Schema.Struct({
+    requestedDimension: Schema.String,
+    outcome: Schema.Literals(["fit", "mismatch", "uncertain"]),
+    detail: Schema.String,
+    evidencePaths: Schema.Array(Schema.String)
+});
+export const RepositorySpecificationReferenceEvidenceV1 = Schema.Struct({
+    sourceId: Schema.String,
+    startLine: Schema.Finite,
+    endLine: Schema.Finite
+});
+export const RepositorySpecificationReferenceScopeV1 = Schema.Struct({
+    clauses: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        kind: Schema.Literals(["changed", "preserved"]),
+        behaviorIds: Schema.Array(Schema.String),
+        description: Schema.String,
+        evidence: Schema.Array(RepositorySpecificationReferenceEvidenceV1)
+    })),
+    unresolvedQuestions: Schema.Array(Schema.String)
+});
+export const RepositorySpecificationReferenceCompatibilityV1 = Schema.Struct({
+    outcome: Schema.Literals(["compatible", "contradictory", "uncertain"]),
+    detail: Schema.String,
+    scopeCoverage: Schema.Array(Schema.Struct({
+        scopeId: Schema.String,
+        outcome: Schema.Literals(["supported", "contradictory", "uncertain"]),
+        detail: Schema.String,
+        evidence: Schema.Array(RepositorySpecificationReferenceEvidenceV1)
+    })),
+    questionResolutions: Schema.optionalKey(Schema.Array(Schema.Struct({
+        questionId: Schema.String,
+        outcome: Schema.Literals(["answered", "not-required", "unresolved"]),
+        detail: Schema.String,
+        affectedScopeIds: Schema.Array(Schema.String),
+        evidence: Schema.Array(RepositorySpecificationReferenceEvidenceV1),
+        visibleScopeExclusion: Schema.optionalKey(Schema.Struct({
+            quotation: Schema.String,
+            rationale: Schema.String
+        }))
+    })))
+});
+export const RepositorySpecificationReviewV1 = Schema.Struct({
+    reviewerId: Schema.String,
+    reviewerKind: Schema.Literals(["independent-solver", "human-reviewer", "model-critic"]),
+    independentlyProduced: Schema.Boolean,
+    verdict: Schema.Literals(["sufficient", "insufficient"]),
+    detail: Schema.String,
+    criticalBehaviorCoverage: Schema.optionalKey(Schema.Array(RepositorySpecificationBehaviorCoverageV1)),
+    dimensionFit: Schema.optionalKey(RepositorySpecificationDimensionFitV1),
+    referenceCompatibility: Schema.optionalKey(RepositorySpecificationReferenceCompatibilityV1),
+    findings: Schema.Array(RepositorySpecificationCritiqueFindingV1)
+});
+export const RepositorySpecificationCritiqueV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    caseId: Schema.String,
+    outcome: Schema.Literals(["pass", "fail", "review-required"]),
+    mechanicalFindings: Schema.Array(RepositorySpecificationCritiqueFindingV1),
+    reviews: Schema.Array(RepositorySpecificationReviewV1),
+    independentApprovalCount: Schema.Finite,
+    rejectionReasons: Schema.Array(Schema.String)
+});
+export function assertRepositorySpecificationCritiqueV1(value) {
+    const critique = Schema.decodeUnknownSync(RepositorySpecificationCritiqueV1)(value);
+    if (critique.caseId.trim().length === 0 ||
+        new Set(critique.reviews.map((review) => review.reviewerId)).size !== critique.reviews.length) {
+        throw new Error("repository specification critique requires a case id and unique reviewer ids");
+    }
+    const approvals = critique.reviews.filter((review) => review.independentlyProduced && review.verdict === "sufficient").length;
+    if (approvals !== critique.independentApprovalCount) {
+        throw new Error("repository specification critique approval count is inconsistent");
+    }
+    const blocker = critique.mechanicalFindings.some((finding) => finding.severity === "blocker") ||
+        critique.reviews.some((review) => review.verdict === "insufficient" ||
+            review.findings.some((finding) => finding.severity === "blocker"));
+    const expectedOutcome = blocker ? "fail" : approvals >= 2 ? "pass" : "review-required";
+    if (critique.outcome !== expectedOutcome) {
+        throw new Error("repository specification critique outcome is inconsistent with findings and reviews");
+    }
+    if ((critique.outcome === "pass" && critique.rejectionReasons.length > 0) ||
+        (critique.outcome !== "pass" && critique.rejectionReasons.length === 0)) {
+        throw new Error("repository specification critique rejection reasons are inconsistent");
+    }
+}

package/dist/repository-task-family-protocol.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from "effect";
+export declare const RepositoryTaskFamilyV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly id: Schema.String;
+    readonly capabilityId: Schema.String;
+    readonly jobStatement: Schema.String;
+    readonly lane: Schema.Literals<readonly ["request", "repository-agent"]>;
+    readonly seedIds: Schema.$Array<Schema.String>;
+    readonly inputStateFacets: Schema.$Array<Schema.String>;
+    readonly requestedChangeFacets: Schema.$Array<Schema.String>;
+    readonly observableFacets: Schema.$Array<Schema.String>;
+    readonly admissibleSolutionPolicy: Schema.Literals<readonly ["behavior-equivalent", "behavior-and-structure", "exact-artifact"]>;
+    readonly fixtureAxes: Schema.$Array<Schema.String>;
+    readonly adversaryFamilies: Schema.$Array<Schema.String>;
+    readonly excludedNearMisses: Schema.$Array<Schema.String>;
+    readonly repositoryCoverage: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+        readonly id: Schema.String;
+        readonly path: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+}>;
+export type RepositoryTaskFamilyV1 = typeof RepositoryTaskFamilyV1.Type;
+export declare function assertRepositoryTaskFamilyV1(value: unknown): asserts value is RepositoryTaskFamilyV1;

package/dist/repository-task-family-protocol.js

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+import { RepositoryEvidenceRefV1 } from "./repository-behavior-protocol.js";
+export const RepositoryTaskFamilyV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    id: Schema.String,
+    capabilityId: Schema.String,
+    jobStatement: Schema.String,
+    lane: Schema.Literals(["request", "repository-agent"]),
+    seedIds: Schema.Array(Schema.String),
+    inputStateFacets: Schema.Array(Schema.String),
+    requestedChangeFacets: Schema.Array(Schema.String),
+    observableFacets: Schema.Array(Schema.String),
+    admissibleSolutionPolicy: Schema.Literals([
+        "behavior-equivalent",
+        "behavior-and-structure",
+        "exact-artifact"
+    ]),
+    fixtureAxes: Schema.Array(Schema.String),
+    adversaryFamilies: Schema.Array(Schema.String),
+    excludedNearMisses: Schema.Array(Schema.String),
+    repositoryCoverage: Schema.Array(RepositoryEvidenceRefV1),
+    confidence: Schema.Literals(["high", "medium", "review-required"])
+});
+export function assertRepositoryTaskFamilyV1(value) {
+    const family = Schema.decodeUnknownSync(RepositoryTaskFamilyV1)(value);
+    if (family.id.trim().length === 0 ||
+        family.capabilityId.trim().length === 0 ||
+        family.jobStatement.trim().length === 0 ||
+        family.seedIds.length === 0 ||
+        family.observableFacets.length === 0 ||
+        family.adversaryFamilies.length === 0) {
+        throw new Error("repository task family requires identity, seed evidence, observables, and adversaries");
+    }
+    if (new Set(family.seedIds).size !== family.seedIds.length) {
+        throw new Error("repository task family seed ids must be unique");
+    }
+}