eval-quality 0.1.0

package/dist/core/schemas/eval-contract.d.ts

@@ -0,0 +1,402 @@
+/** the Eval Contract: every declaration AD-19 requires, in one shape. */
+import { z } from 'zod';
+/**
+ * Consistency Conventions: external requirement and risk linkage is an opaque
+ * caller-supplied string paired with its scheme, so the entries are objects
+ * rather than bare identifiers.
+ */
+export declare const ExternalLink: z.ZodObject<{
+    scheme: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>;
+/**
+ * AD-19's three severity levels, exported so they are spelled once (six
+ * copies across the finding, seeded defect, outcome, coverage gap, and
+ * scoring-policy-floor sites would be the drift the Consistency Conventions
+ * warn about). Naming it changes no exported byte: an enum with no
+ * `.meta({ id })` inlines at each use site exactly as the literal did.
+ */
+export declare const SEVERITY_LEVELS: readonly ['low', 'material', 'critical'];
+export declare const Severity: z.ZodEnum<{
+    critical: "critical";
+    low: "low";
+    material: "material";
+}>;
+/** the three levels as a type, so a derived severity is declared once. */
+export type Severity = (typeof SEVERITY_LEVELS)[number];
+/**
+ * Coin flip (c), settled: linkage lives per behaviour rather than at contract
+ * level. See `requirementLinks` below for why; the Gate C fixture's
+ * contract-level `linkage` array does not survive that decision.
+ */
+export declare const Behavior: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        low: "low";
+        material: "material";
+    }>;
+    observableSuccessCriterion: z.ZodNullable<z.ZodString>;
+    requirementLinks: z.ZodArray<z.ZodObject<{
+        scheme: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    riskLinks: z.ZodArray<z.ZodObject<{
+        scheme: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    oracles: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * AD-16's scoped resource references. AD-19's declaration list omits them,
+ * AD-16 puts them on the sealed brief, and `scoped-reference-resolves-forbidden`
+ * fires on one, so a contract with no place for them makes that code
+ * unreachable. Both fields are opaque: no AD supplies a value space for `kind`,
+ * and inventing one here is the unshaped-declaration defect in reverse.
+ */
+export declare const ScopedResource: z.ZodObject<{
+    reference: z.ZodString;
+    kind: z.ZodString;
+}, z.core.$strict>;
+/** AD-16's mandatory floor, closed at the prior art's seven members. */
+export declare const FORBIDDEN_INPUT_FLOOR: readonly ['original-spec', 'source-code', 'repository', 'builder-transcript', 'implementation-logs', 'comparator-results', 'human-labels'];
+export declare const ForbiddenInput: z.ZodEnum<{
+    "builder-transcript": "builder-transcript";
+    "comparator-results": "comparator-results";
+    "human-labels": "human-labels";
+    "implementation-logs": "implementation-logs";
+    "original-spec": "original-spec";
+    repository: "repository";
+    "source-code": "source-code";
+}>;
+/** the seven members as a type, so `forbiddenInputAccounting` can key by them. */
+export type ForbiddenInput = (typeof FORBIDDEN_INPUT_FLOOR)[number];
+/**
+ * A sibling group's minimum membership. AD-19 permits "an explicit empty
+ * sibling group", which is read here as the empty group *list*: a group of one
+ * has no sibling to cross-check against, so it cannot make AD-20 rule 5
+ * relevant, while `[]` is the explicit answer that makes a genuinely
+ * sibling-free contract decidably clean.
+ */
+export declare const SIBLING_GROUP_MINIMUM = 2;
+export declare const SiblingGroups: z.ZodObject<{
+    operations: z.ZodArray<z.ZodArray<z.ZodString>>;
+    parameters: z.ZodArray<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const TestData: z.ZodObject<{
+    setup: z.ZodNullable<z.ZodString>;
+    cleanup: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const Budgets: z.ZodObject<{
+    maxToolCalls: z.ZodInt;
+    maxWallClockMinutes: z.ZodInt;
+    maxCostUsd: z.ZodString;
+}, z.core.$strict>;
+export declare const EvalContract: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    contractId: z.ZodString;
+    sourceSpecDigest: z.ZodNullable<z.ZodString>;
+    behaviors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+        observableSuccessCriterion: z.ZodNullable<z.ZodString>;
+        requirementLinks: z.ZodArray<z.ZodObject<{
+            scheme: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+        riskLinks: z.ZodArray<z.ZodObject<{
+            scheme: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+        oracles: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    oracles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        direction: z.ZodNullable<z.ZodObject<{
+            evidenceTargets: z.ZodArray<z.ZodString>;
+            relation: z.ZodEnum<{
+                absence: "absence";
+                all: "all";
+                any: "any";
+                containment: "containment";
+                "count-tolerance": "count-tolerance";
+                "covers-by-key": "covers-by-key";
+                "deep-equality": "deep-equality";
+                equality: "equality";
+                existence: "existence";
+                "for-all": "for-all";
+                "for-any": "for-any";
+                not: "not";
+                ordering: "ordering";
+                regex: "regex";
+                "set-membership": "set-membership";
+                shape: "shape";
+            }>;
+            polarity: z.ZodEnum<{
+                "expects-hold": "expects-hold";
+                "expects-violation": "expects-violation";
+            }>;
+            scope: z.ZodNullable<z.ZodString>;
+            negativeDomain: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        check: z.ZodNullable<z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>>;
+        polarity: z.ZodEnum<{
+            "expects-hold": "expects-hold";
+            "expects-violation": "expects-violation";
+        }>;
+        commentary: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    rubrics: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        scaleLevels: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            level: z.ZodInt;
+            anchor: z.ZodString;
+        }, z.core.$strict>>>;
+        failureModePenalties: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        maxLength: z.ZodNullable<z.ZodInt>;
+        criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            evidence: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    waivers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        rule: z.ZodNullable<z.ZodString>;
+        rationale: z.ZodNullable<z.ZodString>;
+        condition: z.ZodNullable<z.ZodString>;
+        approval: z.ZodNullable<z.ZodString>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    permittedInterfaces: z.ZodArray<z.ZodObject<{
+        logicalId: z.ZodString;
+        kind: z.ZodEnum<{
+            api: "api";
+            cli: "cli";
+            mcp: "mcp";
+            web: "web";
+        }>;
+        operations: z.ZodArray<z.ZodObject<{
+            operationId: z.ZodString;
+            method: z.ZodEnum<{
+                DELETE: "DELETE";
+                GET: "GET";
+                HEAD: "HEAD";
+                OPTIONS: "OPTIONS";
+                PATCH: "PATCH";
+                POST: "POST";
+                PUT: "PUT";
+            }>;
+            pathTemplate: z.ZodString;
+            stateChangeMarker: z.ZodBoolean;
+            requestShape: z.ZodObject<{
+                path: z.ZodObject<{
+                    requiredKeys: z.ZodArray<z.ZodString>;
+                    permittedKeys: z.ZodArray<z.ZodString>;
+                    types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                        array: "array";
+                        boolean: "boolean";
+                        null: "null";
+                        number: "number";
+                        object: "object";
+                        string: "string";
+                    }>>>;
+                }, z.core.$strict>;
+                query: z.ZodObject<{
+                    requiredKeys: z.ZodArray<z.ZodString>;
+                    permittedKeys: z.ZodArray<z.ZodString>;
+                    types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                        array: "array";
+                        boolean: "boolean";
+                        null: "null";
+                        number: "number";
+                        object: "object";
+                        string: "string";
+                    }>>>;
+                }, z.core.$strict>;
+                header: z.ZodObject<{
+                    requiredKeys: z.ZodArray<z.ZodString>;
+                    permittedKeys: z.ZodArray<z.ZodString>;
+                    types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                        array: "array";
+                        boolean: "boolean";
+                        null: "null";
+                        number: "number";
+                        object: "object";
+                        string: "string";
+                    }>>>;
+                }, z.core.$strict>;
+                body: z.ZodObject<{
+                    requiredKeys: z.ZodArray<z.ZodString>;
+                    permittedKeys: z.ZodArray<z.ZodString>;
+                    types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                        array: "array";
+                        boolean: "boolean";
+                        null: "null";
+                        number: "number";
+                        object: "object";
+                        string: "string";
+                    }>>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            responseDescriptor: z.ZodObject<{
+                requiredKeys: z.ZodArray<z.ZodString>;
+                permittedKeys: z.ZodArray<z.ZodString>;
+                types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
+                    array: "array";
+                    boolean: "boolean";
+                    null: "null";
+                    number: "number";
+                    object: "object";
+                    string: "string";
+                }>>>;
+                successIndicator: z.ZodNullable<z.ZodString>;
+                channelRoles: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                    collection: "collection";
+                    diagnostic: "diagnostic";
+                    payload: "payload";
+                    "success-indicator": "success-indicator";
+                }>>>;
+                collectionLocations: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    pointer: z.ZodString;
+                    expectedCardinality: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        mode: z.ZodLiteral<"exact">;
+                        count: z.ZodInt;
+                    }, z.core.$strict>, z.ZodObject<{
+                        mode: z.ZodLiteral<"at-most">;
+                        max: z.ZodInt;
+                    }, z.core.$strict>, z.ZodObject<{
+                        mode: z.ZodLiteral<"page-bounded">;
+                        max: z.ZodInt;
+                    }, z.core.$strict>], "mode">;
+                    referenceSet: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            volatilePointers: z.ZodArray<z.ZodString>;
+            sensitivityWitness: z.ZodNullable<z.ZodObject<{
+                witnessId: z.ZodString;
+                channel: z.ZodEnum<{
+                    body: "body";
+                    path: "path";
+                    query: "query";
+                }>;
+                legs: z.ZodArray<z.ZodObject<{
+                    legId: z.ZodString;
+                    inputs: z.ZodObject<{
+                        path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                        query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+                        header: z.ZodRecord<z.ZodString, z.ZodString>;
+                        body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"json">;
+                            value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"absent">;
+                        }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    referenceSets: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+        keys: z.ZodArray<z.ZodString>;
+        members: z.ZodArray<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+        commentary: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>;
+    siblingGroups: z.ZodNullable<z.ZodObject<{
+        operations: z.ZodArray<z.ZodArray<z.ZodString>>;
+        parameters: z.ZodArray<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    interactionPlan: z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        operationId: z.ZodString;
+        inputBinding: z.ZodObject<{
+            path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+            body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                matcher: z.ZodEnum<{
+                    any: "any";
+                    "type-violating": "type-violating";
+                }>;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>;
+        after: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    scopedResources: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        reference: z.ZodString;
+        kind: z.ZodString;
+    }, z.core.$strict>>>;
+    forbiddenInputs: z.ZodArray<z.ZodEnum<{
+        "builder-transcript": "builder-transcript";
+        "comparator-results": "comparator-results";
+        "human-labels": "human-labels";
+        "implementation-logs": "implementation-logs";
+        "original-spec": "original-spec";
+        repository: "repository";
+        "source-code": "source-code";
+    }>>;
+    testData: z.ZodObject<{
+        setup: z.ZodNullable<z.ZodString>;
+        cleanup: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    budgets: z.ZodObject<{
+        maxToolCalls: z.ZodInt;
+        maxWallClockMinutes: z.ZodInt;
+        maxCostUsd: z.ZodString;
+    }, z.core.$strict>;
+    safetyLimits: z.ZodArray<z.ZodString>;
+    requiredEvidence: z.ZodArray<z.ZodString>;
+    probeStepBound: z.ZodNullable<z.ZodInt>;
+    fixtureReset: z.ZodNullable<z.ZodObject<{
+        legId: z.ZodString;
+        interfaceId: z.ZodString;
+        operationId: z.ZodString;
+        inputs: z.ZodObject<{
+            path: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+            query: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+            header: z.ZodRecord<z.ZodString, z.ZodString>;
+            body: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"json">;
+                value: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"absent">;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EvalContract = z.infer<typeof EvalContract>;

package/dist/core/schemas/eval-contract.js

@@ -0,0 +1,147 @@
+/** the Eval Contract: every declaration AD-19 requires, in one shape. */
+import { z } from 'zod';
+import { PermittedInterface } from './interface.js';
+import { lineageFields } from './lineage.js';
+import { Oracle } from './oracle.js';
+import { InteractionStep } from './plan.js';
+import { BehaviorId, Digest, Identifier, KeyName, OracleId, UnsignedDecimalString, } from './primitives.js';
+import { ReferenceSetDeclaration } from './reference-set.js';
+import { RubricBody } from './rubric.js';
+import { FixtureReset } from './sensitivity-witness.js';
+import { Waiver } from './waiver.js';
+/**
+ * Consistency Conventions: external requirement and risk linkage is an opaque
+ * caller-supplied string paired with its scheme, so the entries are objects
+ * rather than bare identifiers.
+ */
+export const ExternalLink = z.strictObject({
+    scheme: z.string().min(1),
+    id: z.string().min(1),
+});
+/**
+ * AD-19's three severity levels, exported so they are spelled once (six
+ * copies across the finding, seeded defect, outcome, coverage gap, and
+ * scoring-policy-floor sites would be the drift the Consistency Conventions
+ * warn about). Naming it changes no exported byte: an enum with no
+ * `.meta({ id })` inlines at each use site exactly as the literal did.
+ */
+export const SEVERITY_LEVELS = ['low', 'material', 'critical'];
+export const Severity = z.enum(SEVERITY_LEVELS);
+/**
+ * Coin flip (c), settled: linkage lives per behaviour rather than at contract
+ * level. See `requirementLinks` below for why; the Gate C fixture's
+ * contract-level `linkage` array does not survive that decision.
+ */
+export const Behavior = z.strictObject({
+    id: BehaviorId,
+    description: z.string(),
+    severity: Severity,
+    observableSuccessCriterion: z
+        .string()
+        .nullable()
+        .describe('AD-19: what observable condition means this behaviour was met, which is not the nominated success indicator of any one operation. `null` is the shape `no-observable-success-criterion` fires on, and that code fires on exactly this condition and never on an empty oracle list.'),
+    requirementLinks: z
+        .array(ExternalLink)
+        .describe('Coin flip (c), settled: requirement and risk linkage lives per behaviour rather than at contract level, because `missing-requirement-linkage` fires when "a behaviour declares no requirement or risk identifier" and a contract-level array cannot make that predicate decidable per behaviour. Empty is legal, and both link arrays empty is exactly what the code fires on; a schema demanding non-empty makes it fire never.'),
+    riskLinks: z.array(ExternalLink),
+    oracles: z
+        .array(OracleId)
+        .describe("Identifiers of the oracles this behaviour is discharged by. Deliberately not refined against the contract's declared oracles: no AD-5 code names a behaviour citing an undeclared oracle, so it joins the cross-field rules with no code, unenforced in v0 rather than silently pushed into the schema."),
+});
+/**
+ * AD-16's scoped resource references. AD-19's declaration list omits them,
+ * AD-16 puts them on the sealed brief, and `scoped-reference-resolves-forbidden`
+ * fires on one, so a contract with no place for them makes that code
+ * unreachable. Both fields are opaque: no AD supplies a value space for `kind`,
+ * and inventing one here is the unshaped-declaration defect in reverse.
+ */
+export const ScopedResource = z.strictObject({
+    reference: z.string().min(1),
+    kind: z.string().min(1),
+});
+/** AD-16's mandatory floor, closed at the prior art's seven members. */
+export const FORBIDDEN_INPUT_FLOOR = [
+    'original-spec',
+    'source-code',
+    'repository',
+    'builder-transcript',
+    'implementation-logs',
+    'comparator-results',
+    'human-labels',
+];
+export const ForbiddenInput = z.enum(FORBIDDEN_INPUT_FLOOR);
+/**
+ * A sibling group's minimum membership. AD-19 permits "an explicit empty
+ * sibling group", which is read here as the empty group *list*: a group of one
+ * has no sibling to cross-check against, so it cannot make AD-20 rule 5
+ * relevant, while `[]` is the explicit answer that makes a genuinely
+ * sibling-free contract decidably clean.
+ */
+export const SIBLING_GROUP_MINIMUM = 2;
+export const SiblingGroups = z.strictObject({
+    operations: z.array(z.array(Identifier).min(SIBLING_GROUP_MINIMUM)),
+    parameters: z.array(z.array(KeyName).min(SIBLING_GROUP_MINIMUM)),
+});
+export const TestData = z.strictObject({
+    setup: z.string().nullable(),
+    cleanup: z.string().nullable(),
+});
+export const Budgets = z.strictObject({
+    maxToolCalls: z.int().min(0),
+    maxWallClockMinutes: z.int().min(0),
+    maxCostUsd: UnsignedDecimalString.describe('Money, so AD-36 carries it as a string in a declared format rather than as a JSON number. Constrained to the unsigned form: a negative ceiling is not a ceiling.'),
+});
+export const EvalContract = z
+    .strictObject({
+    // AD-11's schemaVersion and AD-29's lineage pair, spread from the leaf
+    // module every lineage-bearing artifact spreads from; the descriptions
+    // moved verbatim since rewriting them would change the export bytes.
+    // Spread rather than nested, so this shape and the reject fixtures
+    // naming `['schemaVersion']` or `['parentDigest']` stay unchanged.
+    ...lineageFields,
+    contractId: Identifier,
+    sourceSpecDigest: Digest.nullable().describe('AD-18 permits a digest where the content is forbidden, so the contract may name the specification it was authored against without carrying it.'),
+    behaviors: z
+        .array(Behavior)
+        .min(1)
+        .describe('US spelling, matching the prior art and both hand-authored contracts. A contract with no behaviour declares nothing to evaluate.'),
+    oracles: z
+        .array(Oracle)
+        .describe('No minimum. AD-19 is explicit that `no-observable-success-criterion` "never fires on an empty oracle list", so an empty list must parse.'),
+    rubrics: z
+        .array(RubricBody)
+        .describe('Empty is legal: a zero-rubric contract compiles clean.'),
+    waivers: z.array(Waiver),
+    permittedInterfaces: z
+        .array(PermittedInterface)
+        .describe('AD-35: logical identifiers only. No entry here is ever a URL, a host, or a port.'),
+    referenceSets: z
+        .record(Identifier, ReferenceSetDeclaration)
+        .nullable()
+        .describe('Caller-keyed by reference-set identifier. AD-31 grades an absent declaration and an explicit empty one differently, so `null`, `{}`, and a populated map are three distinct answers.'),
+    siblingGroups: SiblingGroups.nullable().describe('AD-20 rule 5 relevance reads this. `null` is absent, `{ "operations": [], "parameters": [] }` is the explicit empty answer AD-19 calls a declaration, and a populated group makes the rule relevant.'),
+    interactionPlan: z
+        .array(InteractionStep)
+        .describe('No maximum and no bound on `after` chains. `plan-exceeds-scripting-bound` needs the sixty-four-pair and eight-chain plans representable, and the compiler owns the graph predicate. An empty plan is the cheapest `unreachable-check-evidence` fixture.'),
+    scopedResources: z
+        .array(ScopedResource)
+        .nullable()
+        .describe('Absent, empty, and populated are three distinct answers. A reference at all is what `scoped-reference-resolves-forbidden` fires on.'),
+    forbiddenInputs: z
+        .array(ForbiddenInput)
+        .describe('A list short of the seven is `forbidden-input-floor-incomplete`, a coded compile-time error, so a short list must parse.'),
+    testData: TestData,
+    budgets: Budgets,
+    safetyLimits: z.array(z.string()),
+    requiredEvidence: z.array(z.string()),
+    probeStepBound: z
+        .int()
+        .min(0)
+        .nullable()
+        .describe("AD-16's declared bound on enumerated probe steps, which the brief-side scripting audit reads. No AD gives it a home and the Configuration convention's policy-artifact list omits it, so it lands here beside the other ceilings. The AD-5 code that audit fires is `brief-exceeds-scripting-bound`."),
+    fixtureReset: FixtureReset.nullable().describe("AD-10's per-run state reset, declared as the operation that performs it, so the reset is one more probe leg through the environment-probe port. `null` selects AD-10's repeated-read immutability branch, which is also the check that catches a volatile response field the contract failed to declare."),
+})
+    .meta({
+    id: 'EvalContract',
+    description: "The Eval Contract. Succeeds the prior-art `eval-contract` schema per AD-24. It carries every declaration AD-19 requires so that AD-31's fourteen relevance and satisfaction predicates are decidable from declarations alone. AD-10's sensitivity witnesses arrived in this version, on each operation, as the additive `schemaVersion` bump AD-11 requires; the bump is recorded in each new field's own description, since no reader in this version declares an expected version constant to compare against.",
+});

package/dist/core/schemas/evaluator-configuration.d.ts

@@ -0,0 +1,37 @@
+/** the evaluator's own configuration, digested into the scoring version. */
+import { z } from 'zod';
+/**
+ * AD-17's judge configuration. `modelSnapshot` is required and non-nullable
+ * here because the no-judge state is spelled once, as `null` on
+ * `judgeConfiguration` itself; letting this field be `null` too would create a
+ * second, indistinguishable way to say "no judge". `systemPromptDigest` stays
+ * nullable: a judge invoked with no system prompt of its own is still
+ * configured.
+ */
+export declare const JudgeConfiguration: z.ZodObject<{
+    modelSnapshot: z.ZodString;
+    systemPromptDigest: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const EvaluatorConfiguration: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    sealedBriefDigest: z.ZodString;
+    evaluatorIdentity: z.ZodString;
+    modelSnapshot: z.ZodString;
+    systemPromptDigest: z.ZodString;
+    decodingParameters: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
+    toolInventory: z.ZodArray<z.ZodString>;
+    permissionInventory: z.ZodArray<z.ZodString>;
+    budgets: z.ZodObject<{
+        maxToolCalls: z.ZodInt;
+        maxWallClockMinutes: z.ZodInt;
+        maxCostUsd: z.ZodString;
+    }, z.core.$strict>;
+    seed: z.ZodNullable<z.ZodInt>;
+    judgeConfiguration: z.ZodNullable<z.ZodObject<{
+        modelSnapshot: z.ZodString;
+        systemPromptDigest: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EvaluatorConfiguration = z.infer<typeof EvaluatorConfiguration>;

package/dist/core/schemas/evaluator-configuration.js

@@ -0,0 +1,43 @@
+/** the evaluator's own configuration, digested into the scoring version. */
+import { z } from 'zod';
+import { Budgets } from './eval-contract.js';
+import { lineageFields } from './lineage.js';
+import { Digest, JsonObjectValue } from './primitives.js';
+/**
+ * AD-17's judge configuration. `modelSnapshot` is required and non-nullable
+ * here because the no-judge state is spelled once, as `null` on
+ * `judgeConfiguration` itself; letting this field be `null` too would create a
+ * second, indistinguishable way to say "no judge". `systemPromptDigest` stays
+ * nullable: a judge invoked with no system prompt of its own is still
+ * configured.
+ */
+export const JudgeConfiguration = z.strictObject({
+    modelSnapshot: z.string().min(1),
+    systemPromptDigest: Digest.nullable().describe('`null` for a judge configured with no system prompt of its own. This is the only nullable member: the absent-judge state belongs to the field above, not to this shape.'),
+});
+export const EvaluatorConfiguration = z
+    .strictObject({
+    ...lineageFields,
+    sealedBriefDigest: Digest,
+    evaluatorIdentity: z
+        .string()
+        .min(1)
+        .describe('Opaque, and named so by AD-24. AD-18 excludes credentials, tokens, real names, email addresses, account identifiers, and transaction content from every artifact; no schema over an opaque string enforces that, so the prohibition is stated and recorded in the constraint ledger as not expressible.'),
+    modelSnapshot: z.string().min(1),
+    systemPromptDigest: Digest,
+    decodingParameters: JsonObjectValue.describe("AD-24's \"decoding and sampling parameters\", carried in the value container under the caller's own keys rather than as a minted enum of temperature and top-p. AD-2 forbids provider or model SDK knowledge in this package, so a closed parameter vocabulary would be knowledge the package is not allowed to have. `JsonObjectValue` sits inside AD-36's value domain, which matters because this artifact's digest enters the scoring version. One field, not two: \"decoding and sampling parameters\" is one concern under two words, and splitting it would draw a boundary no AD draws. Caller-keyed, but inside the value container rather than a control map, so it does not join the Conventions' caller-keyed list."),
+    toolInventory: z
+        .array(z.string())
+        .describe('AD-18 binds this field and `permissionInventory` hardest: a tool and permission inventory is exactly where a caller would paste an API key. The prohibition is not expressible over opaque strings and is recorded in the ledger.'),
+    permissionInventory: z.array(z.string()),
+    budgets: Budgets,
+    seed: z
+        .int()
+        .nullable()
+        .describe('AD-24\'s "seed where supported". "Where supported" is spelled `null`; an omitted key is not the convention.'),
+    judgeConfiguration: JudgeConfiguration.nullable().describe('`null` where no judge is configured, which is the ordinary case for a contract declaring no rubric.'),
+})
+    .meta({
+    id: 'EvaluatorConfiguration',
+    description: 'The evaluator\'s configuration, a first-class published artifact with no prior art. AD-24 fixes its field list: the sealed-brief digest, opaque evaluator identity, model snapshot, system-prompt digest, decoding and sampling parameters, tool and permission inventory, budgets, seed where supported, and judge configuration, "with the trial index deliberately excluded so trials pool into one scoring version". That exclusion is a requirement rather than an omission: because this object is strict, a `trialIndex` key fails with `unrecognized_keys` at the root, and a test asserts exactly that. The trial index lives on the Sealed Run Record instead. Ingest computes this artifact\'s digest and invalidates the run when it is absent or incomplete.',
+});