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

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

@@ -0,0 +1,384 @@
+import { Schema } from "effect";
+export declare const RepositoryTaskSeedSourceV1: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"historical-fix">;
+    readonly changeEpisodeId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"historical-feature">;
+    readonly changeEpisodeId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"historical-refactor">;
+    readonly changeEpisodeId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"existing-test">;
+    readonly testIds: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"public-api">;
+    readonly surfaceIds: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"schema-contract">;
+    readonly protocolIds: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"production-request">;
+    readonly requestId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"reviewed-synthetic-gap">;
+    readonly reviewId: Schema.String;
+}>]>;
+export type RepositoryTaskSeedSourceV1 = typeof RepositoryTaskSeedSourceV1.Type;
+export declare const RepositoryBehaviorClauseV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly description: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly evidence: 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>;
+    }>>;
+}>;
+export type RepositoryBehaviorClauseV1 = typeof RepositoryBehaviorClauseV1.Type;
+export declare const RepositorySeedObservationV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+    readonly subjectId: Schema.String;
+    readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+    readonly detail: Schema.String;
+}>;
+export type RepositorySeedObservationV1 = typeof RepositorySeedObservationV1.Type;
+export declare const RepositoryTaskSeedRiskV1: Schema.Literals<readonly ["ambiguous-intent", "bundled-change", "external-service", "flaky-baseline", "reference-only-oracle", "weak-test-delta", "unrealistic-mutation", "private-context", "cross-batch-instability", "review-required"]>;
+export type RepositoryTaskSeedRiskV1 = typeof RepositoryTaskSeedRiskV1.Type;
+export declare const RepositorySeedEnvironmentV1: Schema.Struct<{
+    readonly packageManager: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.Literal<"pnpm">;
+        readonly version: Schema.String;
+    }>>;
+    readonly lockfilePath: Schema.optionalKey<Schema.String>;
+    readonly protectedControlPaths: Schema.$Array<Schema.String>;
+    readonly trustedPreparationRecipes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+        readonly cwd: Schema.String;
+        readonly executable: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly timeoutMs: Schema.Finite;
+    }>>;
+    readonly candidateValidationRecipes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+        readonly cwd: Schema.String;
+        readonly executable: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly timeoutMs: Schema.Finite;
+    }>>;
+    readonly baselineGradeRecipes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+        readonly cwd: Schema.String;
+        readonly executable: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly timeoutMs: Schema.Finite;
+    }>>;
+    readonly gradeRecipes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+        readonly cwd: Schema.String;
+        readonly executable: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly timeoutMs: Schema.Finite;
+    }>>;
+}>;
+export type RepositorySeedEnvironmentV1 = typeof RepositorySeedEnvironmentV1.Type;
+export declare const RepositoryTaskSeedV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly id: Schema.String;
+    readonly status: Schema.Literals<readonly ["candidate", "qualified", "rejected"]>;
+    readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"historical-fix">;
+        readonly changeEpisodeId: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"historical-feature">;
+        readonly changeEpisodeId: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"historical-refactor">;
+        readonly changeEpisodeId: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"existing-test">;
+        readonly testIds: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"public-api">;
+        readonly surfaceIds: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"schema-contract">;
+        readonly protocolIds: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"production-request">;
+        readonly requestId: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"reviewed-synthetic-gap">;
+        readonly reviewId: Schema.String;
+    }>]>;
+    readonly summary: Schema.String;
+    readonly capabilityEvidence: 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 initialState: Schema.Struct<{
+        readonly commit: Schema.String;
+        readonly parentCommit: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly targetBehavior: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly evidence: 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 referenceCommit: Schema.optionalKey<Schema.String>;
+    readonly baselineObservations: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+        readonly subjectId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+        readonly detail: Schema.String;
+    }>>;
+    readonly preChangeObservations: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+        readonly subjectId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+        readonly detail: Schema.String;
+    }>>;
+    readonly postChangeObservations: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+        readonly subjectId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+        readonly detail: Schema.String;
+    }>>;
+    readonly candidateTestIds: Schema.$Array<Schema.String>;
+    readonly environment: Schema.Struct<{
+        readonly packageManager: Schema.optionalKey<Schema.Struct<{
+            readonly name: Schema.Literal<"pnpm">;
+            readonly version: Schema.String;
+        }>>;
+        readonly lockfilePath: Schema.optionalKey<Schema.String>;
+        readonly protectedControlPaths: Schema.$Array<Schema.String>;
+        readonly trustedPreparationRecipes: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+            readonly cwd: Schema.String;
+            readonly executable: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly timeoutMs: Schema.Finite;
+        }>>;
+        readonly candidateValidationRecipes: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+            readonly cwd: Schema.String;
+            readonly executable: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly timeoutMs: Schema.Finite;
+        }>>;
+        readonly baselineGradeRecipes: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+            readonly cwd: Schema.String;
+            readonly executable: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly timeoutMs: Schema.Finite;
+        }>>;
+        readonly gradeRecipes: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+            readonly cwd: Schema.String;
+            readonly executable: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly timeoutMs: Schema.Finite;
+        }>>;
+    }>;
+    readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+    readonly risks: Schema.$Array<Schema.Literals<readonly ["ambiguous-intent", "bundled-change", "external-service", "flaky-baseline", "reference-only-oracle", "weak-test-delta", "unrealistic-mutation", "private-context", "cross-batch-instability", "review-required"]>>;
+    readonly rejectionReasons: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryTaskSeedV1 = typeof RepositoryTaskSeedV1.Type;
+export declare const RepositorySeedQualificationPhaseV1: Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>;
+export type RepositorySeedQualificationPhaseV1 = typeof RepositorySeedQualificationPhaseV1.Type;
+export declare const RepositorySeedQualificationBatchV1: Schema.Struct<{
+    readonly batch: Schema.Finite;
+    readonly status: Schema.Literals<readonly ["qualified", "rejected"]>;
+    readonly phaseSignatures: Schema.$Array<Schema.Struct<{
+        readonly phase: Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>;
+        readonly signatures: Schema.$Array<Schema.String>;
+    }>>;
+    readonly rejectionReasons: Schema.$Array<Schema.String>;
+}>;
+export type RepositorySeedQualificationBatchV1 = typeof RepositorySeedQualificationBatchV1.Type;
+export declare const RepositorySeedCrossBatchStabilityReportV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly seedId: Schema.String;
+    readonly batchesRequired: Schema.Finite;
+    readonly repetitionsPerBatch: Schema.Finite;
+    readonly stable: Schema.Boolean;
+    readonly batches: Schema.$Array<Schema.Struct<{
+        readonly batch: Schema.Finite;
+        readonly status: Schema.Literals<readonly ["qualified", "rejected"]>;
+        readonly phaseSignatures: Schema.$Array<Schema.Struct<{
+            readonly phase: Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>;
+            readonly signatures: Schema.$Array<Schema.String>;
+        }>>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>>;
+    readonly divergentPhases: Schema.$Array<Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>>;
+    readonly failureSignatures: Schema.$Array<Schema.Struct<{
+        readonly signature: Schema.String;
+        readonly count: Schema.Finite;
+    }>>;
+    readonly rejectionReasons: Schema.$Array<Schema.String>;
+}>;
+export type RepositorySeedCrossBatchStabilityReportV1 = typeof RepositorySeedCrossBatchStabilityReportV1.Type;
+export declare const RepositorySeedCrossBatchQualificationV1: Schema.Struct<{
+    readonly seed: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly id: Schema.String;
+        readonly status: Schema.Literals<readonly ["candidate", "qualified", "rejected"]>;
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-fix">;
+            readonly changeEpisodeId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-feature">;
+            readonly changeEpisodeId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-refactor">;
+            readonly changeEpisodeId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"existing-test">;
+            readonly testIds: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"public-api">;
+            readonly surfaceIds: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"schema-contract">;
+            readonly protocolIds: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"production-request">;
+            readonly requestId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"reviewed-synthetic-gap">;
+            readonly reviewId: Schema.String;
+        }>]>;
+        readonly summary: Schema.String;
+        readonly capabilityEvidence: 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 initialState: Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly parentCommit: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly targetBehavior: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly evidence: 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 referenceCommit: Schema.optionalKey<Schema.String>;
+        readonly baselineObservations: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+            readonly subjectId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+        }>>;
+        readonly preChangeObservations: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+            readonly subjectId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+        }>>;
+        readonly postChangeObservations: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+            readonly subjectId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+        }>>;
+        readonly candidateTestIds: Schema.$Array<Schema.String>;
+        readonly environment: Schema.Struct<{
+            readonly packageManager: Schema.optionalKey<Schema.Struct<{
+                readonly name: Schema.Literal<"pnpm">;
+                readonly version: Schema.String;
+            }>>;
+            readonly lockfilePath: Schema.optionalKey<Schema.String>;
+            readonly protectedControlPaths: Schema.$Array<Schema.String>;
+            readonly trustedPreparationRecipes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                readonly cwd: Schema.String;
+                readonly executable: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly timeoutMs: Schema.Finite;
+            }>>;
+            readonly candidateValidationRecipes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                readonly cwd: Schema.String;
+                readonly executable: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly timeoutMs: Schema.Finite;
+            }>>;
+            readonly baselineGradeRecipes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                readonly cwd: Schema.String;
+                readonly executable: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly timeoutMs: Schema.Finite;
+            }>>;
+            readonly gradeRecipes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                readonly cwd: Schema.String;
+                readonly executable: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly timeoutMs: Schema.Finite;
+            }>>;
+        }>;
+        readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+        readonly risks: Schema.$Array<Schema.Literals<readonly ["ambiguous-intent", "bundled-change", "external-service", "flaky-baseline", "reference-only-oracle", "weak-test-delta", "unrealistic-mutation", "private-context", "cross-batch-instability", "review-required"]>>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>;
+    readonly stability: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly seedId: Schema.String;
+        readonly batchesRequired: Schema.Finite;
+        readonly repetitionsPerBatch: Schema.Finite;
+        readonly stable: Schema.Boolean;
+        readonly batches: Schema.$Array<Schema.Struct<{
+            readonly batch: Schema.Finite;
+            readonly status: Schema.Literals<readonly ["qualified", "rejected"]>;
+            readonly phaseSignatures: Schema.$Array<Schema.Struct<{
+                readonly phase: Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>;
+                readonly signatures: Schema.$Array<Schema.String>;
+            }>>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>>;
+        readonly divergentPhases: Schema.$Array<Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>>;
+        readonly failureSignatures: Schema.$Array<Schema.Struct<{
+            readonly signature: Schema.String;
+            readonly count: Schema.Finite;
+        }>>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>;
+}>;
+export type RepositorySeedCrossBatchQualificationV1 = typeof RepositorySeedCrossBatchQualificationV1.Type;
+export declare function assertRepositoryTaskSeedV1(value: unknown): asserts value is RepositoryTaskSeedV1;
+export declare function assertRepositorySeedCrossBatchQualificationV1(value: unknown): asserts value is RepositorySeedCrossBatchQualificationV1;

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

@@ -0,0 +1,236 @@
+import { Schema } from "effect";
+import { RepositoryCommandRecipeV1, RepositoryEvidenceRefV1 } from "./repository-behavior-protocol.js";
+export const RepositoryTaskSeedSourceV1 = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("historical-fix"),
+        changeEpisodeId: Schema.String
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("historical-feature"),
+        changeEpisodeId: Schema.String
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("historical-refactor"),
+        changeEpisodeId: Schema.String
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("existing-test"),
+        testIds: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("public-api"),
+        surfaceIds: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("schema-contract"),
+        protocolIds: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("production-request"),
+        requestId: Schema.String
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("reviewed-synthetic-gap"),
+        reviewId: Schema.String
+    })
+]);
+export const RepositoryBehaviorClauseV1 = Schema.Struct({
+    id: Schema.String,
+    description: Schema.String,
+    critical: Schema.Boolean,
+    evidence: Schema.Array(RepositoryEvidenceRefV1)
+});
+export const RepositorySeedObservationV1 = Schema.Struct({
+    id: Schema.String,
+    kind: Schema.Literals([
+        "test-command",
+        "schema",
+        "property",
+        "event-trace",
+        "structural"
+    ]),
+    subjectId: Schema.String,
+    outcome: Schema.Literals(["pass", "fail", "unknown"]),
+    detail: Schema.String
+});
+export const RepositoryTaskSeedRiskV1 = Schema.Literals([
+    "ambiguous-intent",
+    "bundled-change",
+    "external-service",
+    "flaky-baseline",
+    "reference-only-oracle",
+    "weak-test-delta",
+    "unrealistic-mutation",
+    "private-context",
+    "cross-batch-instability",
+    "review-required"
+]);
+export const RepositorySeedEnvironmentV1 = Schema.Struct({
+    packageManager: Schema.optionalKey(Schema.Struct({
+        name: Schema.Literal("pnpm"),
+        version: Schema.String
+    })),
+    lockfilePath: Schema.optionalKey(Schema.String),
+    protectedControlPaths: Schema.Array(Schema.String),
+    trustedPreparationRecipes: Schema.Array(RepositoryCommandRecipeV1),
+    candidateValidationRecipes: Schema.Array(RepositoryCommandRecipeV1),
+    baselineGradeRecipes: Schema.Array(RepositoryCommandRecipeV1),
+    gradeRecipes: Schema.Array(RepositoryCommandRecipeV1)
+});
+export const RepositoryTaskSeedV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    id: Schema.String,
+    status: Schema.Literals(["candidate", "qualified", "rejected"]),
+    source: RepositoryTaskSeedSourceV1,
+    summary: Schema.String,
+    capabilityEvidence: Schema.Array(RepositoryEvidenceRefV1),
+    initialState: Schema.Struct({
+        commit: Schema.String,
+        parentCommit: Schema.optionalKey(Schema.String)
+    }),
+    targetBehavior: Schema.Array(RepositoryBehaviorClauseV1),
+    referenceCommit: Schema.optionalKey(Schema.String),
+    baselineObservations: Schema.Array(RepositorySeedObservationV1),
+    preChangeObservations: Schema.Array(RepositorySeedObservationV1),
+    postChangeObservations: Schema.Array(RepositorySeedObservationV1),
+    candidateTestIds: Schema.Array(Schema.String),
+    environment: RepositorySeedEnvironmentV1,
+    confidence: Schema.Literals(["high", "medium", "review-required"]),
+    risks: Schema.Array(RepositoryTaskSeedRiskV1),
+    rejectionReasons: Schema.Array(Schema.String)
+});
+export const RepositorySeedQualificationPhaseV1 = Schema.Literals([
+    "baseline",
+    "pre-change",
+    "post-change"
+]);
+export const RepositorySeedQualificationBatchV1 = Schema.Struct({
+    batch: Schema.Finite,
+    status: Schema.Literals(["qualified", "rejected"]),
+    phaseSignatures: Schema.Array(Schema.Struct({
+        phase: RepositorySeedQualificationPhaseV1,
+        signatures: Schema.Array(Schema.String)
+    })),
+    rejectionReasons: Schema.Array(Schema.String)
+});
+export const RepositorySeedCrossBatchStabilityReportV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    seedId: Schema.String,
+    batchesRequired: Schema.Finite,
+    repetitionsPerBatch: Schema.Finite,
+    stable: Schema.Boolean,
+    batches: Schema.Array(RepositorySeedQualificationBatchV1),
+    divergentPhases: Schema.Array(RepositorySeedQualificationPhaseV1),
+    failureSignatures: Schema.Array(Schema.Struct({
+        signature: Schema.String,
+        count: Schema.Finite
+    })),
+    rejectionReasons: Schema.Array(Schema.String)
+});
+export const RepositorySeedCrossBatchQualificationV1 = Schema.Struct({
+    seed: RepositoryTaskSeedV1,
+    stability: RepositorySeedCrossBatchStabilityReportV1
+});
+export function assertRepositoryTaskSeedV1(value) {
+    const seed = Schema.decodeUnknownSync(RepositoryTaskSeedV1)(value);
+    if (seed.id.trim().length === 0 || seed.summary.trim().length === 0) {
+        throw new Error("repository task seed id and summary must be non-empty");
+    }
+    if (seed.targetBehavior.length === 0 ||
+        !seed.targetBehavior.some((clause) => clause.critical) ||
+        new Set(seed.targetBehavior.map((clause) => clause.id)).size !==
+            seed.targetBehavior.length) {
+        throw new Error("repository task seed requires unique behavior clauses and one critical clause");
+    }
+    if (seed.status === "qualified" &&
+        (seed.preChangeObservations.length === 0 ||
+            seed.baselineObservations.length === 0 ||
+            seed.baselineObservations.some((observation) => observation.outcome !== "pass") ||
+            seed.postChangeObservations.length === 0 ||
+            seed.preChangeObservations.some((observation) => observation.outcome === "unknown") ||
+            seed.preChangeObservations.every((observation) => observation.outcome !== "fail") ||
+            seed.postChangeObservations.some((observation) => observation.outcome !== "pass") ||
+            seed.rejectionReasons.length > 0)) {
+        throw new Error("qualified repository task seed requires reproduced pre-change failure and post-change success");
+    }
+    if (seed.status === "rejected" && seed.rejectionReasons.length === 0) {
+        throw new Error("rejected repository task seed requires a rejection reason");
+    }
+    const environmentRecipeIds = [
+        ...seed.environment.trustedPreparationRecipes,
+        ...seed.environment.candidateValidationRecipes,
+        ...seed.environment.baselineGradeRecipes,
+        ...seed.environment.gradeRecipes
+    ].map((recipe) => recipe.id);
+    if (seed.environment.baselineGradeRecipes.length === 0 ||
+        seed.environment.gradeRecipes.length === 0 ||
+        environmentRecipeIds.some((id) => id.trim().length === 0) ||
+        new Set(environmentRecipeIds).size !== environmentRecipeIds.length) {
+        throw new Error("repository task seed environment requires executable baseline and strong grade recipes with globally unique recipe ids");
+    }
+    if (seed.status === "qualified") {
+        // Older qualification projected static-validation failures onto unstarted
+        // grade recipes. Preserve their diagnostics, but never accept them as proof
+        // that the reviewed tests actually distinguish the two revisions.
+        if ([...seed.baselineObservations, ...seed.preChangeObservations, ...seed.postChangeObservations]
+            .some((row) => row.kind === "test-command" &&
+            /(?:^|;\s*)gradeExecuted=false(?:;|$)/u.test(row.detail))) {
+            throw new Error("qualified repository task seed requires executed grading, not compilation or setup failure");
+        }
+        const baselineGradeRecipeIds = seed.environment.baselineGradeRecipes.map((recipe) => recipe.id);
+        const gradeRecipeIds = seed.environment.gradeRecipes.map((recipe) => recipe.id);
+        const baselineCoversEveryBaselineRecipe = baselineGradeRecipeIds.every((recipeId) => seed.baselineObservations.some((observation) => observation.subjectId === recipeId));
+        const strongPhasesCoverEveryStrongRecipe = [
+            seed.preChangeObservations,
+            seed.postChangeObservations
+        ].every((observations) => gradeRecipeIds.every((recipeId) => observations.some((observation) => observation.subjectId === recipeId)));
+        const everyGradeRecipeReproducesFailure = gradeRecipeIds.every((recipeId) => seed.preChangeObservations.some((observation) => observation.subjectId === recipeId &&
+            observation.outcome === "fail"));
+        if (!baselineCoversEveryBaselineRecipe ||
+            !strongPhasesCoverEveryStrongRecipe ||
+            !everyGradeRecipeReproducesFailure) {
+            throw new Error("qualified repository task seed requires baseline evidence for every baseline recipe and pre-change/post-change evidence for every strong grade recipe");
+        }
+    }
+    if ((seed.environment.packageManager === undefined) !==
+        (seed.environment.lockfilePath === undefined)) {
+        throw new Error("repository task seed package manager and lockfile evidence must be recorded together");
+    }
+    if (seed.environment.packageManager !== undefined &&
+        (!/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?$/u.test(seed.environment.packageManager.version) ||
+            seed.environment.lockfilePath?.trim().length === 0 ||
+            seed.environment.trustedPreparationRecipes.length === 0)) {
+        throw new Error("repository task seed package manager evidence requires an exact version, lockfile, and trusted preparation");
+    }
+    if (new Set(seed.environment.protectedControlPaths).size !==
+        seed.environment.protectedControlPaths.length ||
+        seed.environment.protectedControlPaths.some((path) => path.trim().length === 0 ||
+            path.startsWith("/") ||
+            path.includes("\\") ||
+            path.split("/").some((part) => part === "" || part === "." || part === ".."))) {
+        throw new Error("repository task seed protected control paths must be unique canonical repository-relative paths");
+    }
+}
+export function assertRepositorySeedCrossBatchQualificationV1(value) {
+    const qualification = Schema.decodeUnknownSync(RepositorySeedCrossBatchQualificationV1)(value);
+    const { seed, stability } = qualification;
+    if (stability.seedId !== seed.id ||
+        !Number.isInteger(stability.batchesRequired) ||
+        stability.batchesRequired < 2 ||
+        !Number.isInteger(stability.repetitionsPerBatch) ||
+        stability.repetitionsPerBatch < 2 ||
+        stability.batches.length !== stability.batchesRequired ||
+        stability.batches.some((batch, index) => batch.batch !== index + 1 ||
+            batch.phaseSignatures.length !== 3 ||
+            new Set(batch.phaseSignatures.map((phase) => phase.phase)).size !== 3)) {
+        throw new Error("cross-batch seed qualification requires ordered complete batches");
+    }
+    if (stability.stable !==
+        (stability.rejectionReasons.length === 0 &&
+            stability.divergentPhases.length === 0 &&
+            stability.batches.every((batch) => batch.status === "qualified")) ||
+        (stability.stable && seed.status !== "qualified") ||
+        (!stability.stable && seed.status !== "rejected")) {
+        throw new Error("cross-batch seed qualification status is inconsistent with its evidence");
+    }
+}

package/dist/repository-trajectory-protocol.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+export declare const RepositoryTrajectoryPolicyV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly caseId: Schema.String;
+    readonly purpose: Schema.Literal<"routing-signal">;
+    readonly validationRecipeIds: Schema.$Array<Schema.String>;
+    readonly protectedPaths: Schema.$Array<Schema.String>;
+    readonly thresholds: Schema.Struct<{
+        readonly maximumToolCalls: Schema.Finite;
+        readonly maximumFailedToolCalls: Schema.Finite;
+        readonly maximumRepeatedFailedActions: Schema.Finite;
+    }>;
+    readonly requirements: Schema.Struct<{
+        readonly passingValidationAfterLastMutation: Schema.Boolean;
+        readonly noProtectedPathMutations: Schema.Boolean;
+    }>;
+    readonly rationale: Schema.String;
+}>;
+export type RepositoryTrajectoryPolicyV1 = typeof RepositoryTrajectoryPolicyV1.Type;
+export declare function assertRepositoryTrajectoryPolicyV1(value: unknown): asserts value is RepositoryTrajectoryPolicyV1;