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

package/dist/services/foundry-v2/service.d.ts

@@ -0,0 +1,54 @@
+import { Effect } from "effect";
+import type { PipelinePortsV2, PipelineScientificIdentityV2 } from "../../case-pipeline-protocol-v2.js";
+import type { RepositoryBehaviorMapV1 } from "../../repository-behavior-protocol.js";
+import { type CasePipelineRunResultV2 } from "../case-pipeline-v2/service.js";
+export type FoundryCaseV2 = {
+    readonly identity: PipelineScientificIdentityV2;
+    readonly map: RepositoryBehaviorMapV1;
+};
+export type FoundryRunInputV2 = {
+    readonly cases: readonly FoundryCaseV2[];
+    readonly runtimeRootFor: (identity: PipelineScientificIdentityV2) => string;
+    readonly attemptGenerationFor: (identity: PipelineScientificIdentityV2) => number;
+    readonly ports: PipelinePortsV2;
+    readonly concurrency?: number;
+};
+export type FoundryRunResultV2 = {
+    readonly cases: readonly CasePipelineRunResultV2[];
+    readonly admitted: number;
+    readonly rejected: number;
+    readonly exhausted: number;
+    readonly failed: number;
+};
+/**
+ * Host-composable repository foundry. Scientific identity and durable
+ * checkpoints live outside disposable runtime paths; the existing V1 stage
+ * implementation remains the only scientific implementation.
+ */
+export declare const runFoundryV2: (input: FoundryRunInputV2) => Effect.Effect<{
+    cases: {
+        identityDigest: string;
+        runtimeRoot: string;
+        attemptGeneration: number;
+        checkpoints: readonly {
+            readonly kind: "stage" | "loop" | "terminal";
+            readonly version: 2;
+            readonly stage: "seed" | "spec" | "oracle" | "controls" | "tournament" | "challenge" | "admit";
+            readonly checkpointId: string;
+            readonly identityDigest: string;
+            readonly attemptGeneration: number;
+            readonly sequence: number;
+            readonly parentDigest: string;
+            readonly payloadDigest: string;
+            readonly payloadBytes: number;
+            readonly createdAt: string;
+            readonly loopName?: string | undefined;
+            readonly loopIteration?: number | undefined;
+        }[];
+        result: import("../case-pipeline/service.js").CasePipelineRunResultV1;
+    }[];
+    admitted: number;
+    rejected: number;
+    exhausted: number;
+    failed: number;
+}, import("../../errors.js").RepositoryFoundryError, never>;

package/dist/services/foundry-v2/service.js

@@ -0,0 +1,28 @@
+import { Effect } from "effect";
+import { runCasePipelineV2 } from "../case-pipeline-v2/service.js";
+/**
+ * Host-composable repository foundry. Scientific identity and durable
+ * checkpoints live outside disposable runtime paths; the existing V1 stage
+ * implementation remains the only scientific implementation.
+ */
+export const runFoundryV2 = Effect.fn("FoundryV2.run")(function* (input) {
+    const concurrency = input.concurrency ?? 1;
+    if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 64) {
+        return yield* Effect.die(new Error("foundry V2 concurrency must be between 1 and 64"));
+    }
+    const cases = yield* Effect.forEach(input.cases, ({ identity, map }) => runCasePipelineV2({
+        identity,
+        map,
+        runtimeRoot: input.runtimeRootFor(identity),
+        attemptGeneration: input.attemptGenerationFor(identity),
+        ports: input.ports
+    }), { concurrency });
+    const count = (status) => cases.filter(({ result }) => result.state.status === status).length;
+    return {
+        cases,
+        admitted: count("admitted"),
+        rejected: count("rejected"),
+        exhausted: count("exhausted"),
+        failed: count("failed")
+    };
+});

package/dist/services/grounded-authoring/service.d.ts

@@ -0,0 +1,126 @@
+import { Effect, Schema } from "effect";
+import { type PipelineWorkCheckpointStoreV1, type HostFeedbackFindingV1, type PipelineBudgetExhaustedError } from "../../case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { type RepositoryFoundryReasoningEffortV1 } from "../../repository-language-model-protocol.js";
+import type { RepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import { type RepositoryFoundryLanguageModelShape } from "../language-model/service.js";
+/**
+ * Host-driven tool loop for grounded authoring. Every turn is one structured
+ * call whose output is either a tool request against the pinned Git trees or
+ * a submission. The host executes tool requests, appends the observation to a
+ * bounded transcript, and calls the same role again. Model text is never
+ * gated by host heuristics: a submission is accepted only by the caller's
+ * executed validation, and shortfalls come back as findings, not failures.
+ */
+export declare const GROUNDED_READ_BYTES_PER_TURN = 64000;
+export declare const GROUNDED_INPUT_BYTES_LIMIT = 160000;
+export declare const GROUNDED_FULL_RESULT_WINDOW = 2;
+export declare const GROUNDED_DEFAULT_MAX_TURNS = 24;
+export declare const GROUNDED_LIST_LIMIT = 400;
+export declare const GROUNDED_SEARCH_RESULT_LIMIT = 200;
+export declare const GROUNDED_SEARCH_PATTERN_LIMIT = 200;
+export declare const GROUNDED_SEARCH_MATCHES_PER_FILE = 50;
+export declare const GROUNDED_OUTPUT_TAIL_CHARS = 12000;
+export declare const GROUNDED_CLOSEST_PATHS = 10;
+export declare const GROUNDED_MAX_TOOL_TURNS_BEFORE_SUBMIT = 5;
+export declare const GROUNDED_MAX_TOOL_TURNS_AFTER_FINDINGS = 2;
+export declare const GROUNDED_AUTHORING_UNRESOLVED_PREFIX = "grounded-authoring-unresolved";
+export declare const GroundedCommitRefV1: Schema.Literals<readonly ["initial", "reference"]>;
+export type GroundedCommitRefV1 = typeof GroundedCommitRefV1.Type;
+export declare const GroundedReadFilesActionV1: Schema.Struct<{
+    readonly action: Schema.Literal<"read_files">;
+    readonly commit: Schema.Literals<readonly ["initial", "reference"]>;
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly reason: Schema.String;
+}>;
+export declare const GroundedReadRangeActionV1: Schema.Struct<{
+    readonly action: Schema.Literal<"read_range">;
+    readonly commit: Schema.Literals<readonly ["initial", "reference"]>;
+    readonly path: Schema.String;
+    readonly offset: Schema.Finite;
+    readonly length: Schema.Finite;
+}>;
+export declare const GroundedListFilesActionV1: Schema.Struct<{
+    readonly action: Schema.Literal<"list_files">;
+    readonly commit: Schema.Literals<readonly ["initial", "reference"]>;
+    readonly prefix: Schema.optionalKey<Schema.String>;
+    readonly glob: Schema.optionalKey<Schema.String>;
+}>;
+export declare const GroundedSearchActionV1: Schema.Struct<{
+    readonly action: Schema.Literal<"search">;
+    readonly commit: Schema.Literals<readonly ["initial", "reference"]>;
+    readonly pattern: Schema.String;
+    readonly pathPrefix: Schema.optionalKey<Schema.String>;
+    readonly maxResults: Schema.optionalKey<Schema.Finite>;
+}>;
+export declare const GroundedRunFixtureActionV1: Schema.Struct<{
+    readonly action: Schema.Literal<"run_fixture">;
+    readonly fixtureId: Schema.String;
+    readonly testPath: Schema.String;
+    readonly content: Schema.String;
+    readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+    readonly kind: Schema.Literals<readonly ["historical-regression", "boundary", "counterfactual", "metamorphic"]>;
+    readonly description: Schema.String;
+    readonly expectedBehavior: Schema.String;
+}>;
+export type GroundedToolActionV1 = typeof GroundedReadFilesActionV1.Type | typeof GroundedReadRangeActionV1.Type | typeof GroundedListFilesActionV1.Type | typeof GroundedSearchActionV1.Type | typeof GroundedRunFixtureActionV1.Type;
+export type GroundedSubmitActionV1<A> = {
+    readonly action: "submit";
+    readonly result: A;
+};
+export type GroundedTurnActionV1<A> = GroundedToolActionV1 | GroundedSubmitActionV1<A>;
+/** Recorded when a received response did not decode; the model sees its own raw text. */
+export type GroundedInvalidActionV1 = {
+    readonly action: "invalid";
+};
+export type GroundedTurnRecordV1<A> = {
+    readonly turn: number;
+    readonly operationId: string;
+    readonly action: GroundedTurnActionV1<A> | GroundedInvalidActionV1;
+    readonly result: unknown;
+    readonly resultBytes: number;
+};
+export type GroundedAuthoringToolsV1 = {
+    readonly repositoryRoot: string;
+    readonly commits: {
+        readonly initial: string;
+        readonly reference: string;
+    };
+    /** Test paths the fixture runner may target; defaults to the seed's reviewed test paths. */
+    readonly allowedTestPaths?: ReadonlySet<string>;
+    readonly seed?: RepositoryTaskSeedV1;
+    readonly runFixture?: boolean;
+};
+export type GroundedStructuredGenerationInputV1<A, R> = {
+    /** The budgeted model from context; every turn is counted and ledgered through it. */
+    readonly languageModel: RepositoryFoundryLanguageModelShape;
+    readonly assignment: {
+        readonly role: string;
+        readonly model: string;
+        readonly reasoningEffort: RepositoryFoundryReasoningEffortV1;
+    };
+    readonly operationId: string;
+    readonly instructions: string;
+    /** JSON the model sees every turn. */
+    readonly task: unknown;
+    readonly outputSchema: Schema.Codec<A, unknown, never, unknown>;
+    readonly schemaName: string;
+    readonly tools: GroundedAuthoringToolsV1;
+    /** The case's existing durable work store; never a completed scientific gate. */
+    readonly checkpointStore?: PipelineWorkCheckpointStoreV1;
+    /** Empty findings accept the submission; anything else is returned to the model. */
+    readonly validateSubmission?: (value: A) => Effect.Effect<readonly HostFeedbackFindingV1[], RepositoryFoundryError | PipelineBudgetExhaustedError, R>;
+    readonly maxTurns?: number;
+    /** Internal harness override for focused tests; production callers use the bounded default. */
+    readonly maxToolTurnsBeforeSubmit?: number;
+    /** Internal harness override for focused tests; production callers use the bounded default. */
+    readonly maxToolTurnsAfterFindings?: number;
+    readonly maximumOutputTokens?: number;
+};
+export type GroundedStructuredGenerationResultV1<A> = {
+    readonly value: A;
+    readonly turns: number;
+    readonly transcript: readonly GroundedTurnRecordV1<A>[];
+};
+export declare const GROUNDED_TOOL_PROTOCOL_INSTRUCTIONS: string;
+export declare const groundedStructuredGenerationV1: <A, R = never>(input: GroundedStructuredGenerationInputV1<A, R>) => Effect.Effect<GroundedStructuredGenerationResultV1<A>, RepositoryFoundryError | PipelineBudgetExhaustedError, R>;