eval-quality 0.1.0 → 0.3.0

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

@@ -82,15 +82,45 @@ 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)),
 });
+/**
+ * A valueless test-data declaration, keyed by name. `kind` stays opaque for
+ * the reason `ScopedResource` above already records: no AD supplies a value
+ * space, and inventing one is the unshaped-declaration defect in reverse.
+ */
+const TestDataDeclaration = z.strictObject({ kind: z.string().min(1) });
 export const TestData = z.strictObject({
     setup: z.string().nullable(),
     cleanup: z.string().nullable(),
+    principals: z
+        .record(Identifier, TestDataDeclaration)
+        .nullable()
+        .describe("Owed item 3: the principals a `{ principal }` input binding may name. Caller-keyed by name, which makes a duplicate declaration unrepresentable, and valueless, since AD-19 forbids a credential value in a declaration and AD-18 keeps the name an opaque label. `null`, `{}`, and a populated map are three distinct answers, on `referenceSets`' own reasoning. A binding naming a key absent here still parses; it fires `undeclared-mandatory-input` at compile time in strict mode, because a cross-subtree constraint reaching from `interactionPlan` into this field cannot survive the export. Required, not optional, which makes this and `resources` below together the eval contract's `schemaVersion` 2 -> 3 BREAKING bump under AD-11, whose rule is that \"adding an optional field is a `schemaVersion` bump recorded in the field's own description; removing or retyping is breaking\". `null` is the legal spelling for a contract declaring none, but `TestData` is a `strictObject` and the key itself must be present, so no version-2 contract parses."),
+    resources: z
+        .record(Identifier, TestDataDeclaration)
+        .nullable()
+        .describe("Test-data resources, declared the same way as `principals` above. Any entry fires `scoped-reference-resolves-forbidden` at compile time exactly as a `scopedResources` entry does: a resource the contract points the evaluator at is a scoped reference wherever it is written down (AD-16). Required on the same terms as `principals`, and the other half of the eval contract's `schemaVersion` 2 -> 3 BREAKING bump under AD-11: `null` is the empty spelling and the key is mandatory."),
 });
 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.'),
 });
+/**
+ * The one `schemaVersion` this build reads.
+ *
+ * AD-11 says "readers accept an equal `schemaVersion` only and throw
+ * `schema-version-mismatch` outside that", and puts the comparison on the
+ * reader rather than in the schema: `lineage.ts` records that a `z.literal`
+ * would turn a version-2 artifact into an anonymous parse failure instead of
+ * AD-28's dedicated fault. That left the rule stated everywhere and performed
+ * nowhere for this artifact, so a contract stamped 3 parsed and compiled clean
+ * and its stale version travelled into the scoring version, which is the one
+ * number AD-11 exists to keep comparable.
+ *
+ * `compile` is the reader that performs it. The constant lives here beside the
+ * schema whose version it names, so the bump and the constant are one edit.
+ */
+export const EVAL_CONTRACT_SCHEMA_VERSION = 4;
 export const EvalContract = z
     .strictObject({
     // AD-11's schemaVersion and AD-29's lineage pair, spread from the leaf
@@ -114,7 +144,7 @@ export const EvalContract = z
     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.'),
+        .describe("AD-35: logical identifiers only. No entry here is ever a URL, a host, or a port. Discriminated on `kind`, which makes this field the eval contract's `schemaVersion` 3 -> 4 BREAKING bump under AD-11, whose rule is that \"adding an optional field is a `schemaVersion` bump recorded in the field's own description; removing or retyping is breaking\". The `api`, `web`, and `mcp` branches carry the shipped operation shape unchanged, so a version-3 contract's own bytes still parse on them; the `cli` branch carries a command operation, which declares a logical invocation instead of a method and a path template, four command input channels instead of the four transport channels, a nominated output channel for its one response descriptor, and the files it writes."),
     referenceSets: z
         .record(Identifier, ReferenceSetDeclaration)
         .nullable()
@@ -143,5 +173,5 @@ export const EvalContract = z
 })
     .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.",
+    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 on each operation as an additive `schemaVersion` bump; version 4 opens `permittedInterfaces` to a second interface kind, so a contract may describe a system under test that runs behind a command, and widens the interaction pointer's accepted language with the four command input channels and the `artifact` channel. The widening retypes nothing on its own, since every pointer legal under version 3 is still legal; it carries the same version because it ships in the same release as the retypes. Each bump is recorded in its own field's description, and `compile` compares the stamp against `EVAL_CONTRACT_SCHEMA_VERSION` and throws AD-28's `schema-version-mismatch` on anything else.",
 });

package/dist/core/schemas/evidence-artifact.d.ts

@@ -43,19 +43,22 @@ export type CheckResolutionValue = {
  */
 export declare const CheckResolution: z.ZodType<CheckResolutionValue>;
 /**
- * AD-11's five named inputs, transcribed so a reader can recompute the
- * digest and see what was compared (AD-8's "by digest and opaque reference,
- * never by content or path"). Named object rather than a concatenated tuple:
+ * AD-11's identity inputs, transcribed so a reader can recompute the digest
+ * and see what was compared (AD-8's "by digest and opaque reference, never
+ * by content or path"). Named object rather than a concatenated tuple:
  * revision 1 let two conforming scorers compute different versions from
  * identical inputs if they hashed a different ordering. The scorer computes
- * the scoring version over this shape.
+ * the scoring version over this shape. Six now, not five: `mode` is owed
+ * item 4's identity clause, superseding AD-11's original five-field
+ * sentence.
  */
-export declare const SCORING_VERSION_INPUT_NAMES: readonly ['contractSchemaVersion', 'corpusDigest', 'fixtureDigest', 'evaluatorConfigurationDigest', 'scoringPolicyDigest'];
+export declare const SCORING_VERSION_INPUT_NAMES: readonly ['contractSchemaVersion', 'corpusDigest', 'fixtureDigest', 'evaluatorConfigurationDigest', 'scoringPolicyDigest', 'mode'];
 export declare const ScoringVersionInputName: z.ZodEnum<{
     contractSchemaVersion: "contractSchemaVersion";
     corpusDigest: "corpusDigest";
     evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
     fixtureDigest: "fixtureDigest";
+    mode: "mode";
     scoringPolicyDigest: "scoringPolicyDigest";
 }>;
 export declare const ScoringVersionInputs: z.ZodObject<{
@@ -64,11 +67,17 @@ export declare const ScoringVersionInputs: z.ZodObject<{
     fixtureDigest: z.ZodString;
     evaluatorConfigurationDigest: z.ZodString;
     scoringPolicyDigest: z.ZodString;
+    mode: z.ZodEnum<{
+        "contract-scoring": "contract-scoring";
+        production: "production";
+    }>;
 }, z.core.$strict>;
 export declare const InvalidatedAttempt: z.ZodObject<{
     attempt: z.ZodInt;
     reason: z.ZodString;
 }, z.core.$strict>;
+/** exported so the trial-set reducer names this shape without importing Zod. */
+export type InvalidatedAttempt = z.infer<typeof InvalidatedAttempt>;
 /**
  * AD-6: "Every artifact records its trial count, its invalidated attempts, and
  * each attempt's reason, including on a PASS." None of the three is nullable,
@@ -83,6 +92,8 @@ export declare const Trials: z.ZodObject<{
         reason: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+/** exported so the ladder names this shape without importing Zod. */
+export type Trials = z.infer<typeof Trials>;
 export declare const Outcome: z.ZodObject<{
     oracleId: z.ZodString;
     probeId: z.ZodNullable<z.ZodString>;
@@ -119,6 +130,8 @@ export declare const Outcome: z.ZodObject<{
     selectedObservationIds: z.ZodArray<z.ZodString>;
     checkResolution: z.ZodNullable<z.ZodType<CheckResolutionValue, unknown, z.core.$ZodTypeInternals<CheckResolutionValue, unknown>>>;
 }, z.core.$strict>;
+/** exported so the dominance comparator names this shape without importing Zod. */
+export type Outcome = z.infer<typeof Outcome>;
 export declare const CoverageGap: z.ZodObject<{
     rule: z.ZodString;
     relevancePredicate: z.ZodString;
@@ -132,11 +145,54 @@ export declare const CoverageGap: z.ZodObject<{
 }, z.core.$strict>;
 /** the record as a type, so `core/coverage/` names it without importing Zod. */
 export type CoverageGap = z.infer<typeof CoverageGap>;
+/**
+ * Owed item 5's record for an ingested `defect` finding citing no oracle:
+ * AD-23 already retains the finding rather than discarding it, but nothing
+ * downstream consumed it until this `schemaVersion`. Mirrors `CoverageGap`'s
+ * shape and the `defect`-branch fields on `Finding` it is read from, but
+ * carries no relevance or satisfaction predicate: AD-31's coverage gap is a
+ * declaration AD-31 could not confirm was satisfied, while an uncited defect
+ * finding is a runtime observation an evaluator made outside every declared
+ * oracle, with no relevance predicate to name and no satisfaction predicate
+ * that failed. This is the version-3 bump: required, not optional, per owed
+ * item 5, so a producer that never emits it stops parsing rather than
+ * silently under-reporting the gap.
+ */
+export declare const UncitedFindingGap: z.ZodObject<{
+    findingId: z.ZodString;
+    observationIds: z.ZodArray<z.ZodString>;
+    quotedEvidence: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        quote: z.ZodString;
+        channel: z.ZodLiteral<"artifact">;
+        artifactId: z.ZodString;
+    }, z.core.$strict>, 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";
+        }>;
+        artifactId: z.ZodNull;
+    }, z.core.$strict>]>>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        low: "low";
+        material: "material";
+    }>;
+}, z.core.$strict>;
+/** exported so `core/score/ladder.ts` names this shape without importing Zod. */
+export type UncitedFindingGap = z.infer<typeof UncitedFindingGap>;
 export declare const ClassStrength: z.ZodObject<{
     caught: z.ZodInt;
     exercised: z.ZodInt;
     rate: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strict>;
+/** exported so the rate-vector builder names this shape without importing Zod. */
+export type ClassStrength = z.infer<typeof ClassStrength>;
 /**
  * A fixed three-key object instead of a map keyed by probe class. AD-7 is
  * explicit that "canary probes and clean controls never enter the vector", so
@@ -159,6 +215,8 @@ export declare const StrengthVector: z.ZodObject<{
         rate: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+/** exported so the rate-vector builder names this shape without importing Zod. */
+export type StrengthVector = z.infer<typeof StrengthVector>;
 export declare const Strength: z.ZodObject<{
     denominator: z.ZodString;
     basis: z.ZodEnum<{
@@ -185,6 +243,8 @@ export declare const Strength: z.ZodObject<{
     comparable: z.ZodBoolean;
     note: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
+/** exported so the dominance comparator names this shape without importing Zod. */
+export type Strength = z.infer<typeof Strength>;
 /**
  * AD-12's three named checks, transcribed from the same sentence the field
  * comes from: the package "validates a caller-presented lineage chain (length
@@ -221,13 +281,6 @@ export declare const EvidenceArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
     revisionCount: z.ZodInt;
     runId: z.ZodString;
     scoringVersion: z.ZodString;
-    scoringVersionInputs: z.ZodObject<{
-        contractSchemaVersion: z.ZodInt;
-        corpusDigest: z.ZodString;
-        fixtureDigest: z.ZodString;
-        evaluatorConfigurationDigest: z.ZodString;
-        scoringPolicyDigest: z.ZodString;
-    }, z.core.$strict>;
     comparabilityKey: z.ZodString;
     excludedProbeIds: z.ZodArray<z.ZodString>;
     exitCode: z.ZodInt;
@@ -237,6 +290,7 @@ export declare const EvidenceArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
         corpusDigest: "corpusDigest";
         evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
         fixtureDigest: "fixtureDigest";
+        mode: "mode";
         scoringPolicyDigest: "scoringPolicyDigest";
     }>>;
     trials: z.ZodObject<{
@@ -331,6 +385,14 @@ export declare const EvidenceArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
             noGap: z.ZodBoolean;
         }, z.core.$strict>;
     }, z.core.$strict>;
+    scoringVersionInputs: z.ZodObject<{
+        contractSchemaVersion: z.ZodInt;
+        corpusDigest: z.ZodString;
+        fixtureDigest: z.ZodString;
+        evaluatorConfigurationDigest: z.ZodString;
+        scoringPolicyDigest: z.ZodString;
+        mode: z.ZodLiteral<"production">;
+    }, z.core.$strict>;
     mode: z.ZodLiteral<"production">;
     productionVerdict: z.ZodEnum<{
         CONCERNS: "CONCERNS";
@@ -344,13 +406,6 @@ export declare const EvidenceArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
     revisionCount: z.ZodInt;
     runId: z.ZodString;
     scoringVersion: z.ZodString;
-    scoringVersionInputs: z.ZodObject<{
-        contractSchemaVersion: z.ZodInt;
-        corpusDigest: z.ZodString;
-        fixtureDigest: z.ZodString;
-        evaluatorConfigurationDigest: z.ZodString;
-        scoringPolicyDigest: z.ZodString;
-    }, z.core.$strict>;
     comparabilityKey: z.ZodString;
     excludedProbeIds: z.ZodArray<z.ZodString>;
     exitCode: z.ZodInt;
@@ -360,6 +415,7 @@ export declare const EvidenceArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
         corpusDigest: "corpusDigest";
         evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
         fixtureDigest: "fixtureDigest";
+        mode: "mode";
         scoringPolicyDigest: "scoringPolicyDigest";
     }>>;
     trials: z.ZodObject<{
@@ -454,6 +510,14 @@ export declare const EvidenceArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
             noGap: z.ZodBoolean;
         }, z.core.$strict>;
     }, z.core.$strict>;
+    scoringVersionInputs: z.ZodObject<{
+        contractSchemaVersion: z.ZodInt;
+        corpusDigest: z.ZodString;
+        fixtureDigest: z.ZodString;
+        evaluatorConfigurationDigest: z.ZodString;
+        scoringPolicyDigest: z.ZodString;
+        mode: z.ZodLiteral<"contract-scoring">;
+    }, z.core.$strict>;
     mode: z.ZodLiteral<"contract-scoring">;
     contractVerdict: z.ZodEnum<{
         CONCERNS: "CONCERNS";
@@ -461,6 +525,32 @@ export declare const EvidenceArtifact: z.ZodDiscriminatedUnion<[z.ZodObject<{
         PASS: "PASS";
         WAIVED: "WAIVED";
     }>;
+    uncitedFindingGaps: z.ZodArray<z.ZodObject<{
+        findingId: z.ZodString;
+        observationIds: z.ZodArray<z.ZodString>;
+        quotedEvidence: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            quote: z.ZodString;
+            channel: z.ZodLiteral<"artifact">;
+            artifactId: z.ZodString;
+        }, z.core.$strict>, 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";
+            }>;
+            artifactId: z.ZodNull;
+        }, z.core.$strict>]>>;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            low: "low";
+            material: "material";
+        }>;
+    }, z.core.$strict>>;
     systemRecommendationRecorded: z.ZodEnum<{
         CONCERNS: "CONCERNS";
         FAIL: "FAIL";

package/dist/core/schemas/evidence-artifact.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { Severity } from './eval-contract.js';
 import { lineageFields } from './lineage.js';
 import { Digest, FindingId, Identifier, OracleId, ProbeId, } from './primitives.js';
-import { OracleDispositionValue } from './sealed-run-record.js';
+import { OracleDispositionValue, QuotedEvidence, RunMode, } from './sealed-run-record.js';
 import { EvaluatorRecommendation, Verdict } from './verdict.js';
 /**
  * AD-6's closed twelve. Exported so a later reader can walk the list
@@ -52,12 +52,14 @@ export const CheckResolution = z
     description: "One node of an oracle's `check` tree as it resolved. AD-4's resolution is three-valued rather than two, and the introduction vocabulary has exactly one member because AD-4 closes the introduction set at one: an empty collection. `null` where the resolution is not `insufficient-evidence`. A leaf carries an empty `children` array.",
 });
 /**
- * AD-11's five named inputs, transcribed so a reader can recompute the
- * digest and see what was compared (AD-8's "by digest and opaque reference,
- * never by content or path"). Named object rather than a concatenated tuple:
+ * AD-11's identity inputs, transcribed so a reader can recompute the digest
+ * and see what was compared (AD-8's "by digest and opaque reference, never
+ * by content or path"). Named object rather than a concatenated tuple:
  * revision 1 let two conforming scorers compute different versions from
  * identical inputs if they hashed a different ordering. The scorer computes
- * the scoring version over this shape.
+ * the scoring version over this shape. Six now, not five: `mode` is owed
+ * item 4's identity clause, superseding AD-11's original five-field
+ * sentence.
  */
 export const SCORING_VERSION_INPUT_NAMES = [
     'contractSchemaVersion',
@@ -65,14 +67,44 @@ export const SCORING_VERSION_INPUT_NAMES = [
     'fixtureDigest',
     'evaluatorConfigurationDigest',
     'scoringPolicyDigest',
+    'mode',
 ];
 export const ScoringVersionInputName = z.enum(SCORING_VERSION_INPUT_NAMES);
+const SCORING_VERSION_MODE_DESCRIPTION = "Owed item 4's identity clause: mode enters AD-11's scoring version, superseding AD-11's five-field sentence. Read from the sealed run record, never re-derived, so two runs scored under one mode never collide with a version computed for the other. Required, not optional, which makes this the evidence artifact's `schemaVersion` 1 -> 2 BREAKING bump under AD-11, whose rule is that \"adding an optional field is a `schemaVersion` bump recorded in the field's own description; removing or retyping is breaking\". A version-1 artifact carries five scoring-version inputs where this one carries six, so it does not parse, and no version computed before the bump compares with one computed after it.";
 export const ScoringVersionInputs = z.strictObject({
     contractSchemaVersion: z.int().min(1),
     corpusDigest: Digest,
     fixtureDigest: Digest,
     evaluatorConfigurationDigest: Digest,
     scoringPolicyDigest: Digest,
+    mode: RunMode.describe(SCORING_VERSION_MODE_DESCRIPTION),
+});
+/**
+ * `scoringVersionInputs.mode` narrowed to the one value that agrees with
+ * `EvidenceArtifact`'s own branch discriminant (AD-11, AD-32), rather than a
+ * `.refine()` comparing the two fields. A refinement never exports, so the
+ * published document would keep admitting the disagreement, and the
+ * corpus-mutation generator synthesises witnesses for an untaken `oneOf`
+ * branch straight from that branch's own JSON Schema with no knowledge of a
+ * Zod-only cross-field rule -- verified: it produced two dozen genuine
+ * `zod=false published=true` disagreements this way. Narrowing the schema
+ * itself removes the gap at its source: a synthesised example for a
+ * `const`-typed field can only be that one value.
+ *
+ * Two named consts rather than one generic builder: a `<M extends
+ * RunModeValue>(mode: M)` helper builds each schema correctly, but TypeScript
+ * fails to preserve the per-call-site literal through `EvidenceArtifact`'s
+ * `z.discriminatedUnion` inference, so a fixture assigning the wrong branch's
+ * `mode` here compiles instead of erroring. Two concrete literals close that
+ * gap by construction; there is nothing generic left for the checker to lose.
+ */
+const productionScoringVersionInputs = ScoringVersionInputs.extend({
+    mode: z.literal('production').describe(SCORING_VERSION_MODE_DESCRIPTION),
+});
+const contractScoringVersionInputs = ScoringVersionInputs.extend({
+    mode: z
+        .literal('contract-scoring')
+        .describe(SCORING_VERSION_MODE_DESCRIPTION),
 });
 export const InvalidatedAttempt = z.strictObject({
     attempt: z.int().min(1),
@@ -115,6 +147,25 @@ export const CoverageGap = z.strictObject({
     satisfied: z.boolean(),
     severity: Severity,
 });
+/**
+ * Owed item 5's record for an ingested `defect` finding citing no oracle:
+ * AD-23 already retains the finding rather than discarding it, but nothing
+ * downstream consumed it until this `schemaVersion`. Mirrors `CoverageGap`'s
+ * shape and the `defect`-branch fields on `Finding` it is read from, but
+ * carries no relevance or satisfaction predicate: AD-31's coverage gap is a
+ * declaration AD-31 could not confirm was satisfied, while an uncited defect
+ * finding is a runtime observation an evaluator made outside every declared
+ * oracle, with no relevance predicate to name and no satisfaction predicate
+ * that failed. This is the version-3 bump: required, not optional, per owed
+ * item 5, so a producer that never emits it stops parsing rather than
+ * silently under-reporting the gap.
+ */
+export const UncitedFindingGap = z.strictObject({
+    findingId: FindingId,
+    observationIds: z.array(Identifier).min(1),
+    quotedEvidence: z.array(QuotedEvidence).min(1),
+    severity: Severity,
+});
 export const ClassStrength = z.strictObject({
     caught: z.int().min(0),
     exercised: z.int().min(0),
@@ -178,7 +229,7 @@ export const Remediation = z.strictObject({
 const evidenceCommonFields = {
     ...lineageFields,
     runId: z.string().min(1),
-    scoringVersion: Digest.describe('AD-11: computed by the scorer over the five named inputs below and never caller-supplied.'),
+    scoringVersion: Digest.describe('AD-11: computed by the scorer over the six named inputs below and never caller-supplied.'),
     scoringVersionInputs: ScoringVersionInputs,
     comparabilityKey: Digest.describe("AD-7's declared key: the scoring policy digest plus the corpus digest restricted to the probes both results cover. Deliberately weaker than the scoring version, so adding a probe narrows a comparison rather than voiding every prior result."),
     excludedProbeIds: z
@@ -192,7 +243,7 @@ const evidenceCommonFields = {
         .describe('Every condition that fired, in AD-21 terms. Free text by design: the rungs are prose in AD-21 and assigning them identifiers would be minting a vocabulary that AD has not. Each member is non-empty, on the same reasoning that `InvalidatedAttempt.reason` is: a condition that names itself with nothing has not been recorded. An empty array is legal and is what a PASS with no firing condition carries.'),
     callerAttestedInputs: z
         .array(ScoringVersionInputName)
-        .describe('Which of the five scoring-version inputs were caller-attested rather than computed by this package. An enum over the five key names rather than free strings, because AD-32 requires the artifact to state *which* inputs were attested and an unconstrained string cannot be checked against anything. AD-11 names three of the five as caller-attested; the enum admits any subset so a stricter or looser integration stays representable.'),
+        .describe('Which of the six scoring-version inputs were caller-attested rather than computed by this package. An enum over the six key names rather than free strings, because AD-32 requires the artifact to state *which* inputs were attested and an unconstrained string cannot be checked against anything. AD-11 names three of the six as caller-attested; the enum admits any subset so a stricter or looser integration stays representable. `mode` is the one member that is not a choice: `ScoringVersionInputs.mode` is read from the sealed run record and never re-derived, so a list omitting it is a misdeclaration rather than a stricter integration. The schema admits that shape and the constraint ledger records why; `core/emit` always names it.'),
     trials: Trials,
     outcomes: z.array(Outcome),
     uncitedFindings: z
@@ -212,6 +263,7 @@ export const EvidenceArtifact = z
     z
         .strictObject({
         ...evidenceCommonFields,
+        scoringVersionInputs: productionScoringVersionInputs,
         mode: z.literal('production'),
         productionVerdict: Verdict,
     })
@@ -219,8 +271,12 @@ export const EvidenceArtifact = z
     z
         .strictObject({
         ...evidenceCommonFields,
+        scoringVersionInputs: contractScoringVersionInputs,
         mode: z.literal('contract-scoring'),
         contractVerdict: Verdict,
+        uncitedFindingGaps: z
+            .array(UncitedFindingGap)
+            .describe("Owed item 5's rung record, contract-scoring only: one entry per uncited `defect` finding, per `core/score/outcome.ts`'s `uncitedDefectFindingGaps`. Required, not optional, which makes this the `schemaVersion` 2 -> 3 BREAKING bump under AD-11: an empty array is legal and is what a run with no uncited defect finding carries, but the key itself must be present. Never on the production branch, where the ladder signal alone is enough and this key would fail `strictObject`'s `unrecognized_keys` rule."),
         systemRecommendationRecorded: EvaluatorRecommendation.describe("The evaluator's recommendation about the SYSTEM, recorded and never promoted. On a knowingly defective probe a system-directed FAIL is an input rather than a signal about the contract."),
         systemRecommendationNote: z.string().nullable(),
     })
@@ -228,5 +284,5 @@ export const EvidenceArtifact = z
 ])
     .meta({
     id: 'EvidenceArtifact',
-    description: "The scored output, owned by `emit` per AD-24, with no prior art; `score` produces the outcome and verdict values it serializes. The two modes are separate branches because AD-21 requires that the production verdict and the contract verdict never share a field. This expresses that settled sentence and no more: Owed item 4's remaining half stays open, namely mode being fixed before ingest and entering AD-11's identity inputs rather than appearing first here; and the Sealed Run Record still carries no mode.",
+    description: 'The scored output, owned by `emit` per AD-24, with no prior art; `score` produces the outcome and verdict values it serializes. The two modes are separate branches because AD-21 requires that the production verdict and the contract verdict never share a field. Mode is no longer first stated here: the Sealed Run Record now carries a required `mode`, where AD-21\'s "fixed before ingest" puts it, so this artifact restates a mode the sealed record already fixed and is never the source. Owed item 4 is closed as of this schemaVersion: `mode` is `ScoringVersionInputs`\'s sixth field, `core/score/ladder.ts` carries `ProductionAssessment`/`ContractAssessment` and their own total ladders, and `core/score/mode-agreement.ts` rejects a `production` record paired with a `contract-scoring` artifact in both directions as an AD-32 cross-artifact disagreement. That check is a hand-written function at the assembly boundary rather than a schema refinement, since no single schema sees both artifacts; `emit` is its one caller, immediately before returning the artifact it just built. Owed item 5 is closed as of this schemaVersion too: the contract-scoring branch carries a required `uncitedFindingGaps`, and both ladders in `core/score/ladder.ts` gain a shared `uncited-defect-finding` CONCERNS row over `AssessmentCommon.uncitedDefectFindings`, so an ingested defect finding citing no oracle now resolves at least CONCERNS instead of routing nowhere.',
 });