eval-quality 0.1.0

package/dist/core/schemas/rubric.js

@@ -0,0 +1,68 @@
+/** the rubric body a contract embeds, and the published Rubric artifact. */
+import { z } from 'zod';
+import { lineageFields } from './lineage.js';
+import { InteractionPointer } from './pointer.js';
+import { RubricCriterionId, RubricId } from './primitives.js';
+// AD-22 requires anchored scale levels but supplies no shape. Minted here as
+// an ordinal plus its anchor condition, nothing more; see the field
+// descriptions below for what stays unenforced in v0 and why.
+export const ScaleLevel = z.strictObject({
+    level: z
+        .int()
+        .describe('The ordinal this level sits at. A repeated ordinal is the one half the compiler closes, failing under `rubric-unanchored`, since two levels at one ordinal make the ordinal address two anchors. Magnitude, sign, ordering, and contiguity stay free everywhere, because a scale running -2 to 2 or 1, 3, 5 is an ordinary authoring choice.'),
+    anchor: z
+        .string()
+        .describe('The observable condition that anchors this level. AD-22 calls an unanchored scale a compile-time failure under `rubric-unanchored`, so the anchor is a declared field rather than a convention.'),
+});
+export const FailureModePenalty = z.strictObject({
+    name: z.string().min(1),
+    description: z
+        .string()
+        .describe("AD-22 requires named failure-mode penalties and states no magnitude. None is invented here: a penalty weight would be a scoring semantic no module below `score` has authority to mint, and AD-7 keeps weighted composites out of the reported result. AD-22's compile checks ship without one, so a penalty carries a name and a description and nothing else."),
+});
+export const RubricCriterion = z.strictObject({
+    id: RubricCriterionId,
+    text: z
+        .string()
+        .describe("A criterion whose wording matches the compiler's closed stated-reasoning vocabulary fails compilation under `rubric-scores-reasoning-prose`, so such a criterion must stay representable here. A blank text parses for the same reason and fails under `rubric-unanchored`."),
+    evidence: InteractionPointer.describe('Where the criterion is answerable from. A pointer that resolves nowhere is `rubric-evidence-unreachable`, a compile-time code, and is deliberately not a schema rejection.'),
+});
+/**
+ * The embeddable rubric body: the published `Rubric` artifact below adds
+ * `schemaVersion`, lineage, and a prior-art declaration on top of this.
+ */
+export const RubricBody = z
+    .strictObject({
+    id: RubricId,
+    scaleLevels: z
+        .array(ScaleLevel)
+        .nullable()
+        .describe('`null` and `[]` are both the unanchored shape `rubric-unanchored` fires on, and both must parse.'),
+    failureModePenalties: z
+        .array(FailureModePenalty)
+        .nullable()
+        .describe('Missing named penalties is `rubric-unanchored`, not a parse failure.'),
+    maxLength: z
+        .int()
+        .min(1)
+        .nullable()
+        .describe('An unbounded length is `null`, which is one of the shapes `rubric-unanchored` fires on.'),
+    criteria: z.array(RubricCriterion),
+})
+    .meta({
+    id: 'RubricBody',
+    description: 'The embeddable rubric body. Named so the shared body has a stable `$defs` key distinct from the published `Rubric` artifact, which is this body plus `schemaVersion` and AD-29 lineage; without the name the two collide in the published-schema drift check under a generated positional name.',
+});
+/**
+ * The published Rubric artifact: `RubricBody` above, spread flat, plus
+ * AD-11's version and AD-29's lineage.
+ */
+export const Rubric = z
+    .strictObject({
+    ...RubricBody.shape,
+    ...lineageFields,
+})
+    .meta({
+    id: 'Rubric',
+    description: "A published rubric, with no prior art: the experiments' evaluator-result and trace-label schemas belong to the deferred semantic layer and their names are not reused. AD-22's compile checks cover anchored scale levels, named failure-mode penalties, a bounded length, criteria that state a question, addressable rubric and criterion identifiers, and wording that matches the compiler's closed stated-reasoning vocabulary. All of them fire under `rubric-unanchored`, `rubric-evidence-unreachable`, and `rubric-scores-reasoning-prose` at compile time, so every shape those codes fire on parses here.",
+});

package/dist/core/schemas/scoring-policy.d.ts

@@ -0,0 +1,28 @@
+/** the published policy artifact the scorer reads its thresholds from. */
+import { z } from 'zod';
+/**
+ * A published artifact rather than constants, per the Consistency
+ * Conventions, so "the default" has an identity a no-op edit cannot move.
+ * No `.default()` anywhere: it would diverge the input- and output-mode
+ * exports by dropping the key from `required` only in input mode. `strictMode`
+ * and `corpusLocation` are deliberately absent: AD-14 fixes strict mode as a
+ * CLI flag and AD-8 puts the corpus behind `CorpusPort`, so either would give
+ * one concern two homes.
+ */
+export declare const ScoringPolicy: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    policyId: z.ZodString;
+    severityFloor: z.ZodEnum<{
+        critical: "critical";
+        low: "low";
+        material: "material";
+    }>;
+    confidenceThreshold: z.ZodNumber;
+    minimumTrialCount: z.ZodInt;
+    reExecutionCap: z.ZodInt;
+    remediationCap: z.ZodInt;
+    regexMatchStepBudget: z.ZodInt;
+}, z.core.$strict>;
+export type ScoringPolicy = z.infer<typeof ScoringPolicy>;

package/dist/core/schemas/scoring-policy.js

@@ -0,0 +1,51 @@
+/** the published policy artifact the scorer reads its thresholds from. */
+import { z } from 'zod';
+import { Severity } from './eval-contract.js';
+import { lineageFields } from './lineage.js';
+import { Identifier } from './primitives.js';
+/**
+ * A published artifact rather than constants, per the Consistency
+ * Conventions, so "the default" has an identity a no-op edit cannot move.
+ * No `.default()` anywhere: it would diverge the input- and output-mode
+ * exports by dropping the key from `required` only in input mode. `strictMode`
+ * and `corpusLocation` are deliberately absent: AD-14 fixes strict mode as a
+ * CLI flag and AD-8 puts the corpus behind `CorpusPort`, so either would give
+ * one concern two homes.
+ */
+export const ScoringPolicy = z
+    .strictObject({
+    ...lineageFields,
+    policyId: Identifier,
+    severityFloor: Severity.describe('AD-21 routes on this: a behavioural failure at or above the floor is FAIL and one below it is CONCERNS, and AD-7 makes it the one severity that constrains the dominance relation.'),
+    confidenceThreshold: z
+        .number()
+        .min(0)
+        .max(1)
+        .describe('The same closed unit interval a finding\'s `confidence` uses. AD-21\'s "a finding whose confidence falls below the policy threshold" compares the two, and two different scales would make that comparison meaningless.'),
+    minimumTrialCount: z
+        .int()
+        .min(1)
+        .describe('AD-6: repeated runs are trials, never retries. The published default artifact carries 3, "because that is what the instrument behind the measured effect used"; that number is recorded here and is deliberately not a schema default.'),
+    reExecutionCap: z
+        .int()
+        .min(0)
+        .describe('AD-6: exceeding the cap resolves under AD-21 as a statement that the harness is unfit, never that the contract is weak. The published default artifact carries 2.'),
+    remediationCap: z
+        .int()
+        .min(0)
+        .describe("AD-12's remediation cap. The published default artifact carries 3. AD-12 states the package validates rather than enforces it, which is why the Evidence Artifact records the cap's source as caller-attested."),
+    regexMatchStepBudget: z
+        .int()
+        .min(1)
+        .describe('AD-4: "a match-step budget from the scoring policy whose breach is a fault, not an outcome ' +
+        'state." The budget bounds a pure, static, pre-execution complexity estimate over the ' +
+        'declared pattern and the candidate string length, never a literal engine-internal step ' +
+        'count, and that length is whatever the system under test returned, which the contract ' +
+        'author does not control. The structural nested-quantifier rejection stays unconditional ' +
+        'and independent of this value, so a generous ceiling here does not weaken that real ' +
+        'backstop. The published default artifact carries 1000000.'),
+})
+    .meta({
+    id: 'ScoringPolicy',
+    description: 'The scoring policy, with no prior art. It carries the severity floor, confidence threshold, minimum trial count, re-execution cap, remediation cap, and a regex match-step budget that AD-6, AD-12, AD-4, and AD-21 read, and its digest is one of the five named inputs to AD-11\'s scoring version. It is a published artifact rather than a set of constants so that "the default" has an identity a result can name by digest.',
+});

package/dist/core/schemas/sealed-evaluator-brief.d.ts

@@ -0,0 +1,80 @@
+/** the only artifact that reaches the executing caller. */
+import { z } from 'zod';
+/**
+ * AD-3's generated evaluator-facing direction, keyed by the oracle it belongs
+ * to. The evaluator sees oracle identifiers but never step identifiers
+ * (AD-23 requires citing the oracle; AD-16 bars step identifiers), and
+ * carries no `behaviorId`: `Behavior.oracles` is an array, so two behaviours
+ * can cite one oracle and a single id here would not be truthful.
+ */
+export declare const BriefDirection: z.ZodObject<{
+    oracleId: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type BriefDirection = z.infer<typeof BriefDirection>;
+/**
+ * Interface identity only, no operation inventory: shipping one would hand
+ * the evaluator the action list AD-39 withholds, one artifact over from
+ * where AD-5's scripting-shape predicate looks. Withholding it costs nothing
+ * in practice: an isolation-manifest arm found a search parameter by trying
+ * `?search=`, `?query=`, and `?q=` in turn, and still caught the defect.
+ */
+export declare const BriefInterface: z.ZodObject<{
+    logicalId: z.ZodString;
+    kind: z.ZodEnum<{
+        api: "api";
+        cli: "cli";
+        mcp: "mcp";
+        web: "web";
+    }>;
+}, z.core.$strict>;
+export declare const SealedEvaluatorBrief: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    contractDigest: 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>>;
+    directions: z.ZodArray<z.ZodObject<{
+        oracleId: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    permittedInterfaces: z.ZodArray<z.ZodObject<{
+        logicalId: z.ZodString;
+        kind: z.ZodEnum<{
+            api: "api";
+            cli: "cli";
+            mcp: "mcp";
+            web: "web";
+        }>;
+    }, z.core.$strict>>;
+    scopedResources: z.ZodArray<z.ZodObject<{
+        reference: z.ZodString;
+        kind: 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>;
+    probeStepBound: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type SealedEvaluatorBrief = z.infer<typeof SealedEvaluatorBrief>;

package/dist/core/schemas/sealed-evaluator-brief.js

@@ -0,0 +1,59 @@
+/** the only artifact that reaches the executing caller. */
+import { z } from 'zod';
+import { Behavior, Budgets, ScopedResource } from './eval-contract.js';
+import { InterfaceKind } from './interface.js';
+import { lineageFields } from './lineage.js';
+import { Digest, Identifier, OracleId } from './primitives.js';
+/**
+ * AD-3's generated evaluator-facing direction, keyed by the oracle it belongs
+ * to. The evaluator sees oracle identifiers but never step identifiers
+ * (AD-23 requires citing the oracle; AD-16 bars step identifiers), and
+ * carries no `behaviorId`: `Behavior.oracles` is an array, so two behaviours
+ * can cite one oracle and a single id here would not be truthful.
+ */
+export const BriefDirection = z.strictObject({
+    oracleId: OracleId,
+    text: z
+        .string()
+        .min(1)
+        .describe('The generated prose. `seal` renders each evidence target as a descriptive reference derived from the step\'s operation and selection predicate, such as "the response you obtained when you sent an invalid identifier", never as the step identifier itself; the mapping from step to phrase is one-way. It never carries a prescribed action sequence.'),
+});
+/**
+ * Interface identity only, no operation inventory: shipping one would hand
+ * the evaluator the action list AD-39 withholds, one artifact over from
+ * where AD-5's scripting-shape predicate looks. Withholding it costs nothing
+ * in practice: an isolation-manifest arm found a search parameter by trying
+ * `?search=`, `?query=`, and `?q=` in turn, and still caught the defect.
+ */
+export const BriefInterface = z.strictObject({
+    logicalId: Identifier.describe('AD-35 binds the brief as it binds the contract: a logical interface identifier only, never a URL, host, or port. The brief is the artifact that actually reaches the executing caller, so a URL leaking onto it defeats the mapping AD-35 keeps outside the package.'),
+    kind: InterfaceKind,
+});
+export const SealedEvaluatorBrief = z
+    .strictObject({
+    ...lineageFields,
+    contractDigest: Digest.describe('Binds this brief to the contract it seals. The brief carries no contract identifier of its own and no identity field at all: every artifact that refers to a brief does so by `sealedBriefDigest`, so an identifier would be a second name nothing reads.'),
+    behaviors: z
+        .array(Behavior)
+        .min(1)
+        .describe("The contract's behaviours, carried through unchanged. At least one, on the contract's own reasoning: a brief with no behaviour directs nothing."),
+    directions: z
+        .array(BriefDirection)
+        .min(1)
+        .describe("AD-3's generated evaluator-facing directions, one per discharged oracle. At least one, on the same reasoning as `behaviors` above: a brief with no direction verifies nothing."),
+    permittedInterfaces: z.array(BriefInterface),
+    scopedResources: z
+        .array(ScopedResource)
+        .describe("AD-16's scoped resource references. Not nullable here, unlike on the contract: absent-versus-explicitly-empty is an AD-31 grading of a CALLER declaration, and this artifact is generated by `seal`, which always knows the answer. No scoped reference may resolve to a forbidden input; that resolution is `scoped-reference-resolves-forbidden` at compile time and is not a schema check."),
+    budgets: Budgets.describe("The contract's declared ceilings, carried because AD-16 says the caller who executes needs the ceilings the isolation manifest reports against. The manifest's own `resourceCeilings` is a different shape and a different concern: this is a declaration, that is a record of what the harness enforced."),
+    safetyLimits: z.array(z.string()),
+    probeStepBound: z
+        .int()
+        .min(0)
+        .nullable()
+        .describe("AD-16's declared bound on enumerated probe steps, carried through from the contract. The brief-side scripting audit reads it after generation and fires `brief-exceeds-scripting-bound` on any single direction whose rendered text carries more markers than the bound; counts are never summed across directions."),
+})
+    .meta({
+    id: 'SealedEvaluatorBrief',
+    description: "The sealed evaluator brief, with no prior art. AD-16 fixes what it carries: the contract's behaviours, the generated evaluator-facing directions of AD-3, permitted interfaces, and scoped resource references, plus budgets and safety limits. It also fixes what the brief never carries: author commentary, the interaction plan, or the plan's step identifiers, and never a prescribed action sequence. Those exclusions are structural rather than conventional: this object is strict, so a brief carrying `interactionPlan`, `commentary`, or a `stepId` fails with `unrecognized_keys`, and each of the three has its own reject fixture rather than resting on strictness alone. It carries no identity field of its own, because every artifact that refers to it does so by digest.",
+});

package/dist/core/schemas/sealed-run-record.d.ts

@@ -0,0 +1,382 @@
+/** the caller's inbound record of one sealed evaluator trial. */
+import { z } from 'zod';
+import { JsonValue } from './primitives.ts';
+/**
+ * AD-23's verbatim quotation, paired with the channel it came from: a
+ * quotation with no channel cannot be audited against its source observation
+ * (ADR-009 Decision 2).
+ */
+export declare const QuotedEvidence: z.ZodObject<{
+    quote: z.ZodString;
+    channel: z.ZodEnum<{
+        "call-inputs": "call-inputs";
+        "exit-code": "exit-code";
+        "response-body": "response-body";
+        "response-headers": "response-headers";
+        "response-status": "response-status";
+        stderr: "stderr";
+        stdout: "stdout";
+    }>;
+}, z.core.$strict>;
+/**
+ * `defect` findings additionally require observation identifiers and quoted
+ * evidence (AD-23). A nullable field can't express "required on this branch
+ * only", so this is a discriminated union, the house treatment for a
+ * conditional (AD-13).
+ */
+export declare const Finding: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    findingId: z.ZodString;
+    oracleId: z.ZodNullable<z.ZodString>;
+    probeId: z.ZodString;
+    behaviorId: z.ZodNullable<z.ZodString>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        low: "low";
+        material: "material";
+    }>;
+    summary: z.ZodString;
+    confidence: z.ZodNumber;
+    evidenceArtifacts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        storage: z.ZodLiteral<"public">;
+        path: z.ZodString;
+        privateRef: z.ZodNull;
+        digest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        storage: z.ZodLiteral<"private">;
+        path: z.ZodNull;
+        privateRef: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>], "storage">>;
+    findingType: z.ZodLiteral<"defect">;
+    observationIds: z.ZodArray<z.ZodString>;
+    quotedEvidence: z.ZodArray<z.ZodObject<{
+        quote: z.ZodString;
+        channel: z.ZodEnum<{
+            "call-inputs": "call-inputs";
+            "exit-code": "exit-code";
+            "response-body": "response-body";
+            "response-headers": "response-headers";
+            "response-status": "response-status";
+            stderr: "stderr";
+            stdout: "stdout";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    findingId: z.ZodString;
+    oracleId: z.ZodNullable<z.ZodString>;
+    probeId: z.ZodString;
+    behaviorId: z.ZodNullable<z.ZodString>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        low: "low";
+        material: "material";
+    }>;
+    summary: z.ZodString;
+    confidence: z.ZodNumber;
+    observationIds: z.ZodArray<z.ZodString>;
+    evidenceArtifacts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        storage: z.ZodLiteral<"public">;
+        path: z.ZodString;
+        privateRef: z.ZodNull;
+        digest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        storage: z.ZodLiteral<"private">;
+        path: z.ZodNull;
+        privateRef: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>], "storage">>;
+    findingType: z.ZodLiteral<"observation">;
+}, z.core.$strict>, z.ZodObject<{
+    findingId: z.ZodString;
+    oracleId: z.ZodNullable<z.ZodString>;
+    probeId: z.ZodString;
+    behaviorId: z.ZodNullable<z.ZodString>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        low: "low";
+        material: "material";
+    }>;
+    summary: z.ZodString;
+    confidence: z.ZodNumber;
+    observationIds: z.ZodArray<z.ZodString>;
+    evidenceArtifacts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        storage: z.ZodLiteral<"public">;
+        path: z.ZodString;
+        privateRef: z.ZodNull;
+        digest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        storage: z.ZodLiteral<"private">;
+        path: z.ZodNull;
+        privateRef: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>], "storage">>;
+    findingType: z.ZodLiteral<"confirmation">;
+}, z.core.$strict>], "findingType">;
+/**
+ * AD-23 requires one disposition per required oracle: held, violated, or
+ * not-attempted. The three words are AD-23's own vocabulary.
+ */
+export declare const ORACLE_DISPOSITIONS: readonly ['held', 'violated', 'not-attempted'];
+export declare const OracleDispositionValue: z.ZodEnum<{
+    held: "held";
+    "not-attempted": "not-attempted";
+    violated: "violated";
+}>;
+export declare const OracleDisposition: z.ZodObject<{
+    oracleId: z.ZodString;
+    disposition: z.ZodEnum<{
+        held: "held";
+        "not-attempted": "not-attempted";
+        violated: "violated";
+    }>;
+    observationIds: z.ZodArray<z.ZodString>;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A flat map would break pointer addressing: AD-26 keys `call-inputs` by
+ * transport channel, so a pointer like
+ * `/interactions/write/call-inputs/body/title` needs that segment to resolve
+ * against. A four-key strict object rather than a record over the transport
+ * enum, for the same reason as `RequestShape` and `InputBinding`: a record
+ * demands every enum member at parse time, but a real observation binds only
+ * a subset.
+ */
+export declare const ObservedCallInputs: z.ZodObject<{
+    path: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+    query: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+    header: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+    body: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+}, z.core.$strict>;
+/**
+ * One ingested observation, carrying AD-26's closed channel set so every
+ * pointer in the addressing grammar has something to resolve against.
+ *
+ * Observation ordering is deliberately absent (Owed item 2): ADR-006 forbids
+ * using array position as ordering, and the fix, a monotonic sequence, arrives
+ * as an additive `schemaVersion` bump under AD-11.
+ */
+export declare const Observation: z.ZodObject<{
+    observationId: z.ZodString;
+    operationId: z.ZodString;
+    provenance: z.ZodEnum<{
+        baseline: "baseline";
+        "evaluator-chosen": "evaluator-chosen";
+    }>;
+    callInputs: z.ZodObject<{
+        path: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+        query: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+        header: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+        body: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+    }, z.core.$strict>;
+    responseBody: z.ZodNullable<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    responseHeaders: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+    responseStatus: z.ZodNullable<z.ZodInt>;
+    stdout: z.ZodNullable<z.ZodString>;
+    stderr: z.ZodNullable<z.ZodString>;
+    exitCode: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type ObservedCallInputs = z.infer<typeof ObservedCallInputs>;
+export type Observation = z.infer<typeof Observation>;
+/**
+ * AD-17: judge results arrive inside the sealed run record and the package
+ * never calls a judge.
+ */
+export declare const JudgeResult: z.ZodObject<{
+    rubricId: z.ZodString;
+    criterionId: z.ZodString;
+    score: z.ZodNullable<z.ZodInt>;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/** the prior art's five members, with money as a string per AD-36. */
+export declare const ResourceUse: z.ZodObject<{
+    toolCalls: z.ZodInt;
+    inputTokens: z.ZodInt;
+    outputTokens: z.ZodInt;
+    wallClockSeconds: z.ZodNumber;
+    costUsd: z.ZodString;
+}, z.core.$strict>;
+/**
+ * AD-21's FAIL rung reads on evidence that is incomplete, over-truncated,
+ * unavailable, or internally inconsistent (AD-17), but no artifact declares
+ * those fields. Two of the four are caller statements and land here; the other
+ * two are derived and declared nowhere.
+ */
+export declare const EvidenceDisclosure: z.ZodObject<{
+    truncationBound: z.ZodNullable<z.ZodInt>;
+    reportedIncomplete: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const SealedRunRecord: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    parentDigest: z.ZodNullable<z.ZodString>;
+    revisionCount: z.ZodInt;
+    runId: z.ZodString;
+    conditionArm: z.ZodString;
+    trialIndex: z.ZodInt;
+    contractDigest: z.ZodString;
+    sealedBriefDigest: z.ZodString;
+    evaluatorConfigurationDigest: z.ZodString;
+    evaluatorRecommendation: z.ZodEnum<{
+        CONCERNS: "CONCERNS";
+        FAIL: "FAIL";
+        PASS: "PASS";
+    }>;
+    oracleDispositions: z.ZodArray<z.ZodObject<{
+        oracleId: z.ZodString;
+        disposition: z.ZodEnum<{
+            held: "held";
+            "not-attempted": "not-attempted";
+            violated: "violated";
+        }>;
+        observationIds: z.ZodArray<z.ZodString>;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    findings: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        findingId: z.ZodString;
+        oracleId: z.ZodNullable<z.ZodString>;
+        probeId: z.ZodString;
+        behaviorId: z.ZodNullable<z.ZodString>;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+        summary: z.ZodString;
+        confidence: z.ZodNumber;
+        evidenceArtifacts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            storage: z.ZodLiteral<"public">;
+            path: z.ZodString;
+            privateRef: z.ZodNull;
+            digest: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            storage: z.ZodLiteral<"private">;
+            path: z.ZodNull;
+            privateRef: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>], "storage">>;
+        findingType: z.ZodLiteral<"defect">;
+        observationIds: z.ZodArray<z.ZodString>;
+        quotedEvidence: z.ZodArray<z.ZodObject<{
+            quote: z.ZodString;
+            channel: z.ZodEnum<{
+                "call-inputs": "call-inputs";
+                "exit-code": "exit-code";
+                "response-body": "response-body";
+                "response-headers": "response-headers";
+                "response-status": "response-status";
+                stderr: "stderr";
+                stdout: "stdout";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        findingId: z.ZodString;
+        oracleId: z.ZodNullable<z.ZodString>;
+        probeId: z.ZodString;
+        behaviorId: z.ZodNullable<z.ZodString>;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+        summary: z.ZodString;
+        confidence: z.ZodNumber;
+        observationIds: z.ZodArray<z.ZodString>;
+        evidenceArtifacts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            storage: z.ZodLiteral<"public">;
+            path: z.ZodString;
+            privateRef: z.ZodNull;
+            digest: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            storage: z.ZodLiteral<"private">;
+            path: z.ZodNull;
+            privateRef: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>], "storage">>;
+        findingType: z.ZodLiteral<"observation">;
+    }, z.core.$strict>, z.ZodObject<{
+        findingId: z.ZodString;
+        oracleId: z.ZodNullable<z.ZodString>;
+        probeId: z.ZodString;
+        behaviorId: z.ZodNullable<z.ZodString>;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+        summary: z.ZodString;
+        confidence: z.ZodNumber;
+        observationIds: z.ZodArray<z.ZodString>;
+        evidenceArtifacts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            storage: z.ZodLiteral<"public">;
+            path: z.ZodString;
+            privateRef: z.ZodNull;
+            digest: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            storage: z.ZodLiteral<"private">;
+            path: z.ZodNull;
+            privateRef: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>], "storage">>;
+        findingType: z.ZodLiteral<"confirmation">;
+    }, z.core.$strict>], "findingType">>;
+    observations: z.ZodArray<z.ZodObject<{
+        observationId: z.ZodString;
+        operationId: z.ZodString;
+        provenance: z.ZodEnum<{
+            baseline: "baseline";
+            "evaluator-chosen": "evaluator-chosen";
+        }>;
+        callInputs: z.ZodObject<{
+            path: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+            query: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+            header: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+            body: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+        }, z.core.$strict>;
+        responseBody: z.ZodNullable<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        responseHeaders: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+        responseStatus: z.ZodNullable<z.ZodInt>;
+        stdout: z.ZodNullable<z.ZodString>;
+        stderr: z.ZodNullable<z.ZodString>;
+        exitCode: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>;
+    judgeResults: z.ZodArray<z.ZodObject<{
+        rubricId: z.ZodString;
+        criterionId: z.ZodString;
+        score: z.ZodNullable<z.ZodInt>;
+        note: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    actionsArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        storage: z.ZodLiteral<"public">;
+        path: z.ZodString;
+        privateRef: z.ZodNull;
+        digest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        storage: z.ZodLiteral<"private">;
+        path: z.ZodNull;
+        privateRef: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>], "storage">;
+    isolationManifestArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        storage: z.ZodLiteral<"public">;
+        path: z.ZodString;
+        privateRef: z.ZodNull;
+        digest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        storage: z.ZodLiteral<"private">;
+        path: z.ZodNull;
+        privateRef: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>], "storage">;
+    resourceUse: z.ZodObject<{
+        toolCalls: z.ZodInt;
+        inputTokens: z.ZodInt;
+        outputTokens: z.ZodInt;
+        wallClockSeconds: z.ZodNumber;
+        costUsd: z.ZodString;
+    }, z.core.$strict>;
+    evidenceDisclosure: z.ZodObject<{
+        truncationBound: z.ZodNullable<z.ZodInt>;
+        reportedIncomplete: z.ZodBoolean;
+    }, z.core.$strict>;
+    invalidReason: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type SealedRunRecord = z.infer<typeof SealedRunRecord>;