@velum-labs/routekit-eval-setup 1.4.0 → 1.5.1

package/dist/services/budgeted-model/service.js

@@ -0,0 +1,460 @@
+import { Clock, Context, Effect, Layer, Option, Ref, Schema } from "effect";
+import { HostFeedbackV1, checkpointDigestV1, PipelineBudgetExhaustedError } from "../../case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { RepositoryFoundryReasoningEffortV1, repositoryFoundryModelAssignmentV1 } from "../../repository-language-model-protocol.js";
+import { makeRepositoryFoundryProgress, reportFoundryHeartbeatV1, RepositoryFoundryProgress } from "../foundry-progress/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+/** Ref-backed accessor shared by the orchestrator and the budget wrapper. */
+export const makePipelineStateAccessorV1 = (initial) => Effect.map(Ref.make(initial), (ref) => ({
+    get: Ref.get(ref),
+    set: (state) => Ref.set(ref, state)
+}));
+export class PipelineBudgetTracker extends Context.Service()("@velum-labs/routekit-eval-setup/PipelineBudgetTracker") {
+}
+export const budgetSnapshotV1 = Effect.flatMap(PipelineBudgetTracker, (tracker) => tracker.snapshot);
+export const TRANSPORT_RETRY_BACKOFF_MS = [5_000, 15_000, 45_000, 90_000, 180_000];
+export const TRANSPORT_ERROR_MARKERS = [
+    "transport error",
+    "before response headers",
+    "econnrefused",
+    "econnreset",
+    "fetch failed",
+    "timed out",
+    "socket",
+    "5xx",
+    "502",
+    "503",
+    "504",
+    "429",
+    "stream"
+];
+export const STRUCTURED_OUTPUT_INVALID_PREFIX = "structured-output-invalid:";
+const RECEIVED_BUT_INVALID_MARKERS = [
+    "returned invalid json",
+    "violated ",
+    "could not restore optional fields"
+];
+const errorText = (error, depth = 0) => {
+    if (depth > 6 || error === null || error === undefined)
+        return "";
+    if (typeof error === "string")
+        return error;
+    if (typeof error !== "object")
+        return String(error);
+    const record = error;
+    return [
+        typeof record.message === "string" ? record.message : "",
+        typeof record.detail === "string" ? record.detail : "",
+        typeof record.code === "string" ? record.code : "",
+        errorText(record.cause, depth + 1)
+    ].join("\n");
+};
+/** Transport failures are retried and are never a terminal outcome of a case. */
+export const isTransportFailureV1 = (error) => {
+    const text = errorText(error).toLowerCase();
+    return TRANSPORT_ERROR_MARKERS.some((marker) => text.includes(marker));
+};
+export const isStructuredOutputInvalidV1 = (error) => error instanceof RepositoryFoundryError &&
+    error.operation === "invoke-language-model" &&
+    error.detail.startsWith(STRUCTURED_OUTPUT_INVALID_PREFIX);
+export const BUDGET_EXHAUSTED_PREFIX = "budget-exhausted:";
+/**
+ * The language-model shape only carries RepositoryFoundryError, so the wrapper
+ * fails with a tagged RepositoryFoundryError whose cause is the typed budget
+ * error. Substrate services propagate it unchanged; stage and orchestrator
+ * code unwraps it with `normalizePipelineFailureV1`.
+ */
+export const budgetExhaustedErrorOfV1 = (error) => {
+    if (error instanceof PipelineBudgetExhaustedError)
+        return error;
+    if (error instanceof RepositoryFoundryError &&
+        error.detail.startsWith(BUDGET_EXHAUSTED_PREFIX) &&
+        error.cause instanceof PipelineBudgetExhaustedError) {
+        return error.cause;
+    }
+    return undefined;
+};
+export const normalizePipelineFailureV1 = (error) => budgetExhaustedErrorOfV1(error) ?? error;
+const wrapExhausted = (error) => new RepositoryFoundryError({
+    operation: "invoke-language-model",
+    detail: `${BUDGET_EXHAUSTED_PREFIX} ${error.message}`,
+    cause: error
+});
+/** The raw response text the wrapper captured for a received-but-invalid response. */
+export const structuredOutputInvalidResponseTextV1 = (error) => {
+    const cause = error.cause;
+    if (typeof cause !== "object" || cause === null || !("responseText" in cause))
+        return undefined;
+    const text = cause.responseText;
+    return typeof text === "string" ? text : undefined;
+};
+const isReceivedButInvalid = (error) => {
+    if (isStructuredOutputInvalidV1(error))
+        return true;
+    const detail = error.detail.toLowerCase();
+    return RECEIVED_BUT_INVALID_MARKERS.some((marker) => detail.includes(marker));
+};
+const TRANSPORT_RETRY_BACKOFF_CAP_MS = 180_000;
+const backoffMs = (attempt) => TRANSPORT_RETRY_BACKOFF_MS[Math.min(Math.max(attempt - 1, 0), TRANSPORT_RETRY_BACKOFF_MS.length - 1)] ?? TRANSPORT_RETRY_BACKOFF_CAP_MS;
+const byteLength = (value) => {
+    const text = JSON.stringify(value);
+    return text === undefined ? 0 : Buffer.byteLength(text);
+};
+/**
+ * The inner language model reports receipt and raw response text through the
+ * progress service. Intercepting it makes accounting exact even when JSON
+ * decoding or schema validation fails afterwards; outer progress still sees
+ * every event.
+ */
+const interceptingProgress = (outer, observed) => Effect.gen(function* () {
+    const base = Option.isSome(outer) ? outer.value : yield* makeRepositoryFoundryProgress();
+    const forwardArtifact = base.recordAuthoringArtifact;
+    return {
+        ...base,
+        reportModelCall: (input) => Effect.gen(function* () {
+            if (input.phase === "complete") {
+                observed.received = true;
+                if (input.callId !== undefined)
+                    observed.callId = input.callId;
+            }
+            return yield* base.reportModelCall(input);
+        }),
+        recordAuthoringArtifact: (artifact) => Effect.gen(function* () {
+            observed.received = true;
+            observed.responseText = artifact.response.text;
+            if (artifact.response.callId !== undefined)
+                observed.callId = artifact.response.callId;
+            if (forwardArtifact !== undefined)
+                yield* forwardArtifact(artifact);
+        })
+    };
+});
+export const makeBudgetedLanguageModelV1 = Effect.fn("BudgetedModel.make")(function* (input) {
+    const now = input.now ?? Clock.currentTimeMillis;
+    const sleep = input.sleep ?? ((ms) => Effect.sleep(ms));
+    const initial = yield* input.state.get;
+    const baselineElapsedMs = initial.elapsedMs;
+    const elapsedNow = Effect.map(now, (at) => baselineElapsedMs + Math.max(0, at - input.startedAtMs));
+    const isoNow = Effect.map(now, (at) => new Date(at).toISOString());
+    const snapshot = Effect.gen(function* () {
+        const state = yield* input.state.get;
+        const elapsedMs = yield* elapsedNow;
+        return {
+            modelCalls: state.modelCalls,
+            elapsedMs,
+            remainingCalls: Math.max(0, input.budget.maxModelCalls - state.modelCalls),
+            remainingMs: Math.max(0, input.budget.maxWallMs - elapsedMs)
+        };
+    });
+    const exhausted = (modelCalls, elapsedMs, stage) => new PipelineBudgetExhaustedError({ budget: input.budget, modelCalls, elapsedMs, stage });
+    const assertAvailable = Effect.gen(function* () {
+        const state = yield* input.state.get;
+        const elapsedMs = yield* elapsedNow;
+        if (state.modelCalls >= input.budget.maxModelCalls || elapsedMs >= input.budget.maxWallMs) {
+            return yield* exhausted(state.modelCalls, elapsedMs, state.stage);
+        }
+    });
+    const recordReceived = Effect.gen(function* () {
+        const state = yield* input.state.get;
+        const elapsedMs = yield* elapsedNow;
+        const next = {
+            ...state,
+            modelCalls: state.modelCalls + 1,
+            elapsedMs,
+            updatedAt: yield* isoNow
+        };
+        yield* input.state.set(next);
+        yield* input.store.writeState(next);
+    });
+    const ledger = (entry) => Effect.gen(function* () {
+        const at = yield* isoNow;
+        yield* input.store.appendLedger({ at, ...entry });
+    });
+    const run = (request, invoke) => Effect.gen(function* () {
+        const outer = yield* Effect.serviceOption(RepositoryFoundryProgress);
+        const inputBytes = byteLength(request.input);
+        const identity = {
+            operationId: request.operationId,
+            role: request.role,
+            model: request.model
+        };
+        const callRecord = {
+            role: request.role,
+            model: request.model,
+            reasoningEffort: request.reasoningEffort,
+            operationId: request.operationId,
+            schemaName: request.schemaName,
+            instructions: request.instructions,
+            input: request.input,
+            maximumOutputTokens: request.maximumOutputTokens
+        };
+        for (let attempt = 1;; attempt += 1) {
+            yield* assertAvailable.pipe(Effect.mapError(wrapExhausted));
+            yield* ledger({ ...identity, phase: "start", attempt, inputBytes });
+            const observed = { received: false, responseText: undefined, callId: undefined };
+            const progress = yield* interceptingProgress(outer, observed);
+            const result = yield* invoke.pipe(Effect.provideService(RepositoryFoundryProgress, progress), Effect.result);
+            if (result._tag === "Success") {
+                const callId = result.success.call.callId ?? observed.callId;
+                const outputBytes = observed.responseText === undefined
+                    ? byteLength(result.success.value)
+                    : Buffer.byteLength(observed.responseText);
+                yield* recordReceived;
+                yield* ledger({
+                    ...identity,
+                    phase: "received",
+                    attempt,
+                    inputBytes,
+                    outputBytes,
+                    ...(callId === undefined ? {} : { callId })
+                });
+                yield* input.store.writeCall(request.operationId, attempt, {
+                    request: callRecord,
+                    response: {
+                        value: result.success.value,
+                        ...(observed.responseText === undefined ? {} : { text: observed.responseText }),
+                        ...(callId === undefined ? {} : { callId })
+                    }
+                });
+                yield* ledger({
+                    ...identity,
+                    phase: "validated",
+                    attempt,
+                    ...(callId === undefined ? {} : { callId })
+                });
+                return result.success;
+            }
+            const error = result.failure;
+            if (observed.received || isReceivedButInvalid(error)) {
+                // The provider answered; the answer did not decode. Count it, keep the
+                // raw text for feedback, and let the role try again with findings.
+                const callId = observed.callId;
+                yield* recordReceived;
+                yield* ledger({
+                    ...identity,
+                    phase: "received",
+                    attempt,
+                    inputBytes,
+                    ...(observed.responseText === undefined
+                        ? {}
+                        : { outputBytes: Buffer.byteLength(observed.responseText) }),
+                    ...(callId === undefined ? {} : { callId }),
+                    detail: error.detail
+                });
+                yield* input.store.writeCall(request.operationId, attempt, {
+                    request: callRecord,
+                    response: {
+                        ...(observed.responseText === undefined ? {} : { text: observed.responseText }),
+                        ...(callId === undefined ? {} : { callId }),
+                        error: error.detail
+                    }
+                });
+                yield* ledger({ ...identity, phase: "failed", attempt, detail: error.detail });
+                const detail = isStructuredOutputInvalidV1(error)
+                    ? error.detail
+                    : `${STRUCTURED_OUTPUT_INVALID_PREFIX} ${error.detail}`;
+                return yield* new RepositoryFoundryError({
+                    operation: "invoke-language-model",
+                    detail,
+                    cause: {
+                        ...(observed.responseText === undefined
+                            ? {}
+                            : { responseText: observed.responseText }),
+                        cause: error
+                    }
+                });
+            }
+            if (isTransportFailureV1(error)) {
+                const delayMs = backoffMs(attempt);
+                const current = yield* snapshot;
+                if (current.elapsedMs + delayMs >= input.budget.maxWallMs) {
+                    yield* ledger({
+                        ...identity,
+                        phase: "failed",
+                        attempt,
+                        detail: `wall budget cannot absorb a ${String(delayMs)}ms retry: ${error.detail}`
+                    });
+                    const state = yield* input.state.get;
+                    return yield* wrapExhausted(exhausted(current.modelCalls, current.elapsedMs, state.stage));
+                }
+                yield* ledger({
+                    ...identity,
+                    phase: "retry",
+                    attempt,
+                    detail: `transport failure, retrying in ${String(delayMs)}ms: ${error.detail}`
+                });
+                yield* sleep(delayMs);
+                continue;
+            }
+            yield* ledger({ ...identity, phase: "failed", attempt, detail: error.detail });
+            return yield* error;
+        }
+    });
+    const generateAssignedStructured = (request) => run({
+        role: request.assignment.role,
+        model: request.assignment.model,
+        reasoningEffort: request.assignment.reasoningEffort,
+        operationId: request.operationId,
+        instructions: request.instructions,
+        input: request.input,
+        schemaName: request.schemaName,
+        maximumOutputTokens: request.maximumOutputTokens
+    }, input.inner.generateAssignedStructured(request));
+    const generateStructured = (request) => Effect.gen(function* () {
+        const assignment = yield* Effect.try({
+            try: () => repositoryFoundryModelAssignmentV1(request.plan, request.role),
+            catch: (cause) => new RepositoryFoundryError({
+                operation: "invoke-language-model",
+                detail: "repository foundry model request failed validation",
+                cause
+            })
+        });
+        return yield* run({
+            role: assignment.role,
+            model: assignment.model,
+            reasoningEffort: assignment.reasoningEffort,
+            operationId: request.operationId,
+            instructions: request.instructions,
+            input: request.input,
+            schemaName: request.schemaName,
+            maximumOutputTokens: request.maximumOutputTokens
+        }, input.inner.generateStructured(request));
+    });
+    const languageModel = {
+        generateAssignedStructured,
+        generateStructured
+    };
+    const tracker = { budget: input.budget, snapshot, assertAvailable };
+    return { languageModel, tracker };
+});
+/** Provides both the wrapped language model and the budget tracker. */
+export const BudgetedLanguageModelLive = (input) => Layer.unwrap(Effect.map(makeBudgetedLanguageModelV1(input), ({ languageModel, tracker }) => Layer.mergeAll(Layer.succeed(RepositoryFoundryLanguageModel, languageModel), Layer.succeed(PipelineBudgetTracker, tracker))));
+export const FEEDBACK_LOOP_UNRESOLVED_PREFIX = "feedback-loop-unresolved:";
+export const DEFAULT_FEEDBACK_MAX_ATTEMPTS = 12;
+const augmentInput = (input, hostFeedback) => input !== null && typeof input === "object" && !Array.isArray(input)
+    ? { ...input, hostFeedback }
+    : { input, hostFeedback };
+/**
+ * Model proposes, host verifies, same role repairs. Shortfalls become
+ * hostFeedback instead of terminal failures; only the global budget bounds
+ * the loop. A received response and completed feedback survive interruption;
+ * resuming revalidates the response, never treats authoring as executed proof.
+ */
+export const generateWithFeedbackV1 = (input) => Effect.gen(function* () {
+    const languageModel = input.languageModel ?? (yield* RepositoryFoundryLanguageModel);
+    const maxAttempts = input.maxAttempts ?? DEFAULT_FEEDBACK_MAX_ATTEMPTS;
+    const assignment = input.assignment ??
+        repositoryFoundryModelAssignmentV1(input.plan, input.role);
+    const workName = `model-feedback-${checkpointDigestV1(input.operationId)}`;
+    const bindingDigest = checkpointDigestV1({
+        version: 1,
+        operationId: input.operationId,
+        assignment,
+        instructions: input.instructions,
+        input: input.input,
+        schema: Schema.toJsonSchemaDocument(input.outputSchema),
+        maximumOutputTokens: input.maximumOutputTokens,
+        validation: input.checkpoint?.binding ?? null
+    });
+    const workSchema = Schema.Struct({
+        version: Schema.Literal(1),
+        bindingDigest: Schema.String,
+        feedback: Schema.Array(HostFeedbackV1),
+        received: Schema.optionalKey(Schema.Struct({
+            attempt: Schema.Int,
+            value: input.outputSchema,
+            call: Schema.Struct({
+                operationId: Schema.String,
+                role: Schema.String,
+                model: Schema.String,
+                reasoningEffort: RepositoryFoundryReasoningEffortV1,
+                callId: Schema.optionalKey(Schema.String)
+            })
+        }))
+    });
+    const retained = input.checkpoint === undefined
+        ? Option.none()
+        : yield* input.checkpoint.store.readWorkCheckpoint(workName, workSchema);
+    const previous = Option.isSome(retained) && retained.value.bindingDigest === bindingDigest
+        ? retained.value
+        : undefined;
+    const operationOf = (attempt) => attempt === 1 ? input.operationId : `${input.operationId}:attempt-${String(attempt)}`;
+    if (previous !== undefined && (previous.feedback.some((packet, index) => packet.attempt !== index + 1) ||
+        (previous.received !== undefined && (previous.received.attempt !== previous.feedback.length + 1 ||
+            previous.received.call.operationId !== operationOf(previous.received.attempt))))) {
+        return yield* new RepositoryFoundryError({
+            operation: "checkpoint-store",
+            detail: "feedback authoring work has an invalid attempt sequence"
+        });
+    }
+    const feedback = [...(previous?.feedback ?? [])];
+    let received = previous?.received;
+    const save = () => input.checkpoint === undefined
+        ? Effect.void
+        : input.checkpoint.store.writeWorkCheckpoint(workName, {
+            version: 1, bindingDigest, feedback,
+            ...(received === undefined ? {} : { received })
+        }).pipe(Effect.uninterruptible);
+    if (previous !== undefined) {
+        yield* reportFoundryHeartbeatV1({
+            role: assignment.role,
+            detail: `feedback authoring restored; completedAttempts=${String(feedback.length)}; pendingAttempt=${String(received?.attempt ?? 0)}`
+        });
+    }
+    for (let attempt = feedback.length + 1; attempt <= maxAttempts; attempt += 1) {
+        const pending = feedback.at(-1);
+        const operationId = operationOf(attempt);
+        const payload = pending === undefined ? input.input : augmentInput(input.input, pending);
+        const common = {
+            operationId,
+            instructions: input.instructions,
+            input: payload,
+            schemaName: input.schemaName,
+            outputSchema: input.outputSchema,
+            maximumOutputTokens: input.maximumOutputTokens
+        };
+        const generate = input.assignment !== undefined
+            ? languageModel.generateAssignedStructured({ ...common, assignment: input.assignment })
+            : languageModel.generateStructured({ ...common, plan: input.plan, role: input.role });
+        if (received === undefined) {
+            yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+                const generated = yield* Effect.result(restore(generate));
+                if (generated._tag === "Failure") {
+                    const error = generated.failure;
+                    if (!isStructuredOutputInvalidV1(error))
+                        return yield* normalizePipelineFailureV1(error);
+                    feedback.push({
+                        attempt,
+                        findings: [{ kind: "schema", message: error.detail }],
+                        priorOutput: structuredOutputInvalidResponseTextV1(error) ?? null
+                    });
+                }
+                else {
+                    received = { attempt, ...generated.success };
+                }
+                yield* save();
+            }));
+        }
+        if (received === undefined)
+            continue;
+        const findings = yield* input.validate(received.value);
+        if (findings.length === 0) {
+            return {
+                value: received.value,
+                attempts: attempt,
+                call: received.call,
+                feedback
+            };
+        }
+        feedback.push({ attempt, findings, priorOutput: received.value });
+        received = undefined;
+        yield* save();
+    }
+    const last = feedback.at(-1)?.findings ?? [];
+    return yield* new RepositoryFoundryError({
+        operation: "invoke-language-model",
+        detail: `${FEEDBACK_LOOP_UNRESOLVED_PREFIX} ${last.length === 0
+            ? "no attempts were made"
+            : last.map((finding) => `${finding.kind}: ${finding.message}`).join("; ")}`
+    });
+});

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

@@ -0,0 +1,163 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import { RepositoryFoundryError } from "../../errors.js";
+import type { RepositoryBehaviorMapV1 } from "../../repository-behavior-protocol.js";
+import type { RepositoryCandidateVisibleTaskV1 } from "../../repository-benchmark-protocol.js";
+import type { RepositoryFoundryModelCallV1, RepositoryFoundryModelPlanV1 } from "../../repository-language-model-protocol.js";
+import { RepositorySpecificationContractFactReviewV1, type RepositorySpecificationAcceptedContractFactsV1 } from "../../repository-specification-contract-facts-protocol.js";
+import { RepositorySpecificationReferenceScopeV1, type RepositorySpecificationReviewV1 } from "../../repository-specification-critique-protocol.js";
+import type { RepositoryTaskFamilyV1 } from "../../repository-task-family-protocol.js";
+import type { RepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+declare const RepositoryAnalysisOutput: Schema.Struct<{
+    readonly summary: Schema.String;
+    readonly userObservableBehaviors: Schema.$Array<Schema.String>;
+    readonly constraints: Schema.$Array<Schema.String>;
+    readonly risks: Schema.$Array<Schema.String>;
+    readonly relevantPaths: Schema.$Array<Schema.String>;
+    readonly referenceScope: Schema.optionalKey<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 RepositoryAnalysisOutput = typeof RepositoryAnalysisOutput.Type;
+declare const RepositorySpecificationOutput: Schema.Struct<{
+    readonly requestText: Schema.String;
+    readonly constraints: Schema.$Array<Schema.String>;
+}>;
+export type RepositorySpecificationOutput = typeof RepositorySpecificationOutput.Type;
+declare const RepositorySpecificationReviewOutput: Schema.Struct<{
+    readonly verdict: Schema.Literals<readonly ["sufficient", "insufficient"]>;
+    readonly detail: Schema.String;
+    readonly criticalBehaviorCoverage: 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 RepositorySpecificationReviewOutput = typeof RepositorySpecificationReviewOutput.Type;
+type RepositoryAuthoredSpecificationReviewV1 = RepositorySpecificationReviewV1 & {
+    readonly contractFactReview?: RepositorySpecificationContractFactReviewV1;
+};
+export type RepositoryModelAuthoredCaseSpecificationV1 = {
+    readonly version: 1;
+    readonly caseId: string;
+    readonly analysis: RepositoryAnalysisOutput;
+    readonly contextSources: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    readonly visible: RepositoryCandidateVisibleTaskV1;
+    readonly reviews: readonly RepositoryAuthoredSpecificationReviewV1[];
+    readonly modelCalls: readonly RepositoryFoundryModelCallV1[];
+    readonly contractFacts?: RepositorySpecificationAcceptedContractFactsV1;
+    readonly groundedTargetBehavior?: RepositoryTaskSeedV1["targetBehavior"];
+    readonly referenceGrounding?: {
+        readonly beforeCommit: string;
+        readonly referenceCommit: string;
+        readonly sources: readonly PrivateReferenceSource[];
+        readonly scope: RepositorySpecificationReferenceScopeV1;
+    };
+    readonly specificationRevisions?: readonly {
+        readonly sequence: number;
+        readonly visible: RepositoryCandidateVisibleTaskV1;
+        readonly reviews: readonly RepositoryAuthoredSpecificationReviewV1[];
+        readonly rejectionReasons: readonly string[];
+        readonly contractFactsDigest?: string;
+    }[];
+};
+type RepositoryContextPathCandidate = {
+    readonly path: string;
+    readonly relationships: readonly string[];
+};
+export declare const repositoryGenerationContextCandidatesV1: (input: {
+    readonly map: RepositoryBehaviorMapV1;
+    readonly seed: RepositoryTaskSeedV1;
+}) => RepositoryContextPathCandidate[];
+export type CaseAuthoringShape = {
+    readonly authorSpecification: (input: {
+        readonly repositoryRoot: string;
+        readonly operationId: string;
+        readonly caseId: string;
+        readonly requestedDimension?: string;
+        readonly maximumSpecificationRevisions?: number;
+        readonly specificationContractFactsVersion?: 1;
+        readonly map: RepositoryBehaviorMapV1;
+        readonly seed: RepositoryTaskSeedV1;
+        readonly family: RepositoryTaskFamilyV1;
+        readonly modelPlan: RepositoryFoundryModelPlanV1;
+    }) => Effect.Effect<RepositoryModelAuthoredCaseSpecificationV1, import("../../errors.js").RepositoryFoundryError>;
+};
+declare const CaseAuthoring_base: Context.ServiceClass<CaseAuthoring, "@velum-labs/routekit-eval-setup/CaseAuthoring", CaseAuthoringShape>;
+export declare class CaseAuthoring extends CaseAuthoring_base {
+}
+export declare const authorRepositoryCaseSpecificationV1: (input: {
+    readonly repositoryRoot: string;
+    readonly operationId: string;
+    readonly caseId: string;
+    readonly requestedDimension?: string;
+    readonly maximumSpecificationRevisions?: number;
+    readonly specificationContractFactsVersion?: 1;
+    readonly map: RepositoryBehaviorMapV1;
+    readonly seed: RepositoryTaskSeedV1;
+    readonly family: RepositoryTaskFamilyV1;
+    readonly modelPlan: RepositoryFoundryModelPlanV1;
+}) => Effect.Effect<RepositoryModelAuthoredCaseSpecificationV1, RepositoryFoundryError, RepositoryFoundryLanguageModel>;
+type PrivateReferenceSource = {
+    readonly sourceId: string;
+    readonly phase: "before" | "after";
+    readonly path: string;
+    readonly content: string | null;
+};
+export declare const makeCaseAuthoring: Effect.Effect<CaseAuthoringShape, never, RepositoryFoundryLanguageModel>;
+export declare const CaseAuthoringLive: Layer.Layer<CaseAuthoring, never, RepositoryFoundryLanguageModel>;
+export {};