eval-quality 0.1.0 → 0.2.0

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

@@ -255,6 +255,10 @@ export declare const INTERCHANGE_ARTIFACTS: {
                             any: "any";
                             "type-violating": "type-violating";
                         }>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        captured: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        principal: z.ZodString;
                     }, 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>>;
@@ -263,6 +267,10 @@ export declare const INTERCHANGE_ARTIFACTS: {
                             any: "any";
                             "type-violating": "type-violating";
                         }>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        captured: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        principal: z.ZodString;
                     }, 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>>;
@@ -271,6 +279,10 @@ export declare const INTERCHANGE_ARTIFACTS: {
                             any: "any";
                             "type-violating": "type-violating";
                         }>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        captured: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        principal: z.ZodString;
                     }, 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>>;
@@ -279,9 +291,18 @@ export declare const INTERCHANGE_ARTIFACTS: {
                             any: "any";
                             "type-violating": "type-violating";
                         }>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        captured: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        principal: z.ZodString;
                     }, z.core.$strict>]>>>;
                 }, z.core.$strict>;
                 after: z.ZodNullable<z.ZodString>;
+                cardinality: z.ZodEnum<{
+                    any: "any";
+                    "at-most-one": "at-most-one";
+                    "exactly-one": "exactly-one";
+                }>;
             }, z.core.$strict>>;
             scopedResources: z.ZodNullable<z.ZodArray<z.ZodObject<{
                 reference: z.ZodString;
@@ -299,6 +320,12 @@ export declare const INTERCHANGE_ARTIFACTS: {
             testData: z.ZodObject<{
                 setup: z.ZodNullable<z.ZodString>;
                 cleanup: z.ZodNullable<z.ZodString>;
+                principals: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    kind: z.ZodString;
+                }, z.core.$strict>>>;
+                resources: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    kind: z.ZodString;
+                }, z.core.$strict>>>;
             }, z.core.$strict>;
             budgets: z.ZodObject<{
                 maxToolCalls: z.ZodInt;
@@ -394,6 +421,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 reference: z.ZodString;
                 kind: z.ZodString;
             }, z.core.$strict>>;
+            principals: z.ZodArray<z.ZodString>;
             budgets: z.ZodObject<{
                 maxToolCalls: z.ZodInt;
                 maxWallClockMinutes: z.ZodInt;
@@ -412,6 +440,10 @@ export declare const INTERCHANGE_ARTIFACTS: {
             revisionCount: z.ZodInt;
             runId: z.ZodString;
             conditionArm: z.ZodString;
+            mode: z.ZodEnum<{
+                "contract-scoring": "contract-scoring";
+                production: "production";
+            }>;
             trialIndex: z.ZodInt;
             contractDigest: z.ZodString;
             sealedBriefDigest: z.ZodString;
@@ -521,6 +553,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
             }, z.core.$strict>], "findingType">>;
             observations: z.ZodArray<z.ZodObject<{
                 observationId: z.ZodString;
+                sequence: z.ZodInt;
                 operationId: z.ZodString;
                 provenance: z.ZodEnum<{
                     baseline: "baseline";
@@ -695,6 +728,129 @@ export declare const INTERCHANGE_ARTIFACTS: {
             artifactDigest: z.ZodString;
             commitDigest: z.ZodString;
             rationale: z.ZodString;
+            qualification: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                route: z.ZodLiteral<"historical">;
+                failBeforeEvidence: 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">;
+                passAfterEvidence: 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">;
+                fixCommitDigest: z.ZodString;
+                oracleStableAcrossRevisions: z.ZodBoolean;
+            }, z.core.$strict>, z.ZodObject<{
+                route: z.ZodLiteral<"controlled-mutation">;
+                mutationSource: z.ZodString;
+                mutationOperator: z.ZodString;
+                targetArtifact: 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">;
+                expectedObservableFailure: z.ZodString;
+                baselinePassEvidence: 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">;
+                mutatedFailEvidence: 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">;
+                rollbackVerified: z.ZodBoolean;
+            }, z.core.$strict>, z.ZodObject<{
+                route: z.ZodLiteral<"gameability">;
+                degenerateResponse: z.ZodString;
+                naiveOracleSatisfiedEvidence: 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">;
+                disciplinedOracleRejectedEvidence: 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">;
+            }, z.core.$strict>, z.ZodObject<{
+                route: z.ZodLiteral<"canary">;
+                indicts: z.ZodEnum<{
+                    corpus: "corpus";
+                    fixture: "fixture";
+                }>;
+                nonDetectionEvidence: 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">;
+            }, z.core.$strict>, z.ZodObject<{
+                route: z.ZodLiteral<"clean-control">;
+                baselinePassEvidence: 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">;
+                revisionCommitDigest: z.ZodString;
+                noKnownDefectStatement: z.ZodString;
+            }, z.core.$strict>], "route">;
             expectedClean: z.ZodLiteral<true>;
             defects: z.ZodArray<z.ZodObject<{
                 defectId: z.ZodString;
@@ -755,6 +911,129 @@ export declare const INTERCHANGE_ARTIFACTS: {
             artifactDigest: z.ZodString;
             commitDigest: z.ZodString;
             rationale: z.ZodString;
+            qualification: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                route: z.ZodLiteral<"historical">;
+                failBeforeEvidence: 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">;
+                passAfterEvidence: 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">;
+                fixCommitDigest: z.ZodString;
+                oracleStableAcrossRevisions: z.ZodBoolean;
+            }, z.core.$strict>, z.ZodObject<{
+                route: z.ZodLiteral<"controlled-mutation">;
+                mutationSource: z.ZodString;
+                mutationOperator: z.ZodString;
+                targetArtifact: 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">;
+                expectedObservableFailure: z.ZodString;
+                baselinePassEvidence: 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">;
+                mutatedFailEvidence: 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">;
+                rollbackVerified: z.ZodBoolean;
+            }, z.core.$strict>, z.ZodObject<{
+                route: z.ZodLiteral<"gameability">;
+                degenerateResponse: z.ZodString;
+                naiveOracleSatisfiedEvidence: 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">;
+                disciplinedOracleRejectedEvidence: 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">;
+            }, z.core.$strict>, z.ZodObject<{
+                route: z.ZodLiteral<"canary">;
+                indicts: z.ZodEnum<{
+                    corpus: "corpus";
+                    fixture: "fixture";
+                }>;
+                nonDetectionEvidence: 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">;
+            }, z.core.$strict>, z.ZodObject<{
+                route: z.ZodLiteral<"clean-control">;
+                baselinePassEvidence: 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">;
+                revisionCommitDigest: z.ZodString;
+                noKnownDefectStatement: z.ZodString;
+            }, z.core.$strict>], "route">;
             expectedClean: z.ZodLiteral<false>;
             defects: z.ZodArray<z.ZodObject<{
                 defectId: z.ZodString;
@@ -798,6 +1077,72 @@ export declare const INTERCHANGE_ARTIFACTS: {
                     relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
                 }, z.core.$strict>>;
             }, z.core.$strict>>;
+            defectSignature: z.ZodNullable<z.ZodObject<{
+                interfaceKind: z.ZodEnum<{
+                    api: "api";
+                    cli: "cli";
+                    mcp: "mcp";
+                    web: "web";
+                }>;
+                method: z.ZodEnum<{
+                    DELETE: "DELETE";
+                    GET: "GET";
+                    HEAD: "HEAD";
+                    OPTIONS: "OPTIONS";
+                    PATCH: "PATCH";
+                    POST: "POST";
+                    PUT: "PUT";
+                }>;
+                pathTemplate: z.ZodString;
+                observableChannel: 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";
+                }>;
+                condition: z.ZodObject<{
+                    selector: z.ZodObject<{
+                        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>;
+                    }, z.core.$strict>;
+                    predicate: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
         }, z.core.$strict>], "expectedClean">;
         readonly priorArt: 'h0-ground-truth';
         readonly carriesLineage: true;
@@ -883,6 +1228,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 material: "material";
             }>;
             confidenceThreshold: z.ZodNumber;
+            catchThreshold: z.ZodNumber;
             minimumTrialCount: z.ZodInt;
             reExecutionCap: z.ZodInt;
             remediationCap: z.ZodInt;
@@ -898,13 +1244,6 @@ export declare const INTERCHANGE_ARTIFACTS: {
             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;
@@ -914,6 +1253,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 corpusDigest: "corpusDigest";
                 evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
                 fixtureDigest: "fixtureDigest";
+                mode: "mode";
                 scoringPolicyDigest: "scoringPolicyDigest";
             }>>;
             trials: z.ZodObject<{
@@ -1008,6 +1348,14 @@ export declare const INTERCHANGE_ARTIFACTS: {
                     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";
@@ -1021,13 +1369,6 @@ export declare const INTERCHANGE_ARTIFACTS: {
             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;
@@ -1037,6 +1378,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 corpusDigest: "corpusDigest";
                 evaluatorConfigurationDigest: "evaluatorConfigurationDigest";
                 fixtureDigest: "fixtureDigest";
+                mode: "mode";
                 scoringPolicyDigest: "scoringPolicyDigest";
             }>>;
             trials: z.ZodObject<{
@@ -1131,6 +1473,14 @@ export declare const INTERCHANGE_ARTIFACTS: {
                     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";
@@ -1138,6 +1488,27 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 PASS: "PASS";
                 WAIVED: "WAIVED";
             }>;
+            uncitedFindingGaps: z.ZodArray<z.ZodObject<{
+                findingId: z.ZodString;
+                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>>;
+                severity: z.ZodEnum<{
+                    critical: "critical";
+                    low: "low";
+                    material: "material";
+                }>;
+            }, z.core.$strict>>;
             systemRecommendationRecorded: z.ZodEnum<{
                 CONCERNS: "CONCERNS";
                 FAIL: "FAIL";

package/dist/core/schemas/constraint-ledger.js

@@ -1,7 +1,9 @@
 /** the constraints the published JSON Schema cannot carry unaided. */
 import { INTERCHANGE_ARTIFACTS, } from './artifact.js';
+import { PROBE_BINDING_CHANNEL_NON_EMPTY } from './defect-signature.js';
 import { TUPLE_ARITY } from './expression.js';
 import { BINDING_CHANNEL_NON_EMPTY } from './plan.js';
+import { OBSERVATION_SEQUENCE_UNIQUE } from './sealed-run-record.js';
 // Verified on the pin: z.tuple([a, b]) exports `prefixItems` alone (no
 // minItems, maxItems, or items), so the published schema accepts the
 // one-operand and three-operand `equality` that Zod rejects. Arity is the one
@@ -139,5 +141,43 @@ export const CONSTRAINT_LEDGER = [
     operandTypeEntry,
     ...lineageEntries,
     ...secretsProhibitionEntries,
+    {
+        id: OBSERVATION_SEQUENCE_UNIQUE,
+        location: { kind: 'root', artifact: 'sealed-run-record' },
+        branch: null,
+        field: 'observations',
+        statement: "Every observation's `sequence` is unique within the record (ADR-006, owed item 2).",
+        disposition: {
+            kind: 'not-expressible',
+            reason: "Uniqueness of a nested field across sibling array items has no draft-2020-12 keyword: `uniqueItems` compares whole items structurally and nothing in the dialect can name one property path and require distinctness on it alone. Unlike the lineage biconditional above, this constraint IS enforced by Zod (a `.refine()` on `observations`), because owed item 2 requires it schema-enforced and the AD-13 differential corpus never manufactures two observations sharing a `sequence`: the generated mutant walk is keyword-driven (it perturbs one occurrence at a time) and never clones or duplicates an `observations` array item, since that field carries no `maxItems` for the generator's clone-to-exceed step to fire against. The gap is therefore real but inert against the corpus this repository generates, and is stated in `Observation.sequence`'s own description for a non-Zod consumer to reimplement. This safety argument holds only while `observations` carries no `maxItems`: adding one later starts the clone-to-exceed step firing against this field, and this entry must be re-verified then.",
+        },
+    },
+    {
+        id: 'defect-signature-required',
+        location: { kind: 'root', artifact: 'probe' },
+        branch: null,
+        field: null,
+        statement: 'Every probe that is not a known-clean control carries an AD-40 defect signature, except a probe whose class is `canary`, which carries `null`. AD-9\'s "an unqualified probe cannot enter a sealed set" and AD-9\'s route-per-class pairing are the same kind of rule and are enforced beside it.',
+        disposition: {
+            kind: 'not-expressible',
+            reason: 'A union-level `superRefine` is the only Zod spelling, and a refinement exports byte-identically, so Zod would reject a signature-less non-canary probe that ajv accepts. Unlike the observation-sequence entry above, that disagreement is not inert against the corpus this repository generates: the mutant generator manufactures the witness trivially from the accept fixture by nulling one field, and the published-schema differential check exists to fail on exactly such a disagreement. So the schema admits the shape and `qualifyProbe` (`core/score/qualification.ts`) returns a reason code, following `compile/interface-inventory.ts`, which put the declared-principal check in the compiler for the same reason. This argument holds only while the published export drops refinements: a Zod release that emitted a union-level refinement into the document, or a decision to inject a conditional here, makes the gate-side placement a choice rather than a necessity, and this entry must be re-verified then.',
+        },
+    },
+    {
+        id: PROBE_BINDING_CHANNEL_NON_EMPTY,
+        location: {
+            kind: 'definition',
+            artifact: 'probe',
+            name: 'ProbeInputBindingChannel',
+        },
+        branch: null,
+        field: null,
+        statement: "A declared channel of a defect signature's selector names at least one parameter. An unbound channel is `null`, never `{}`. Inject at the definition root, exactly as the contract-side channel does: `minProperties` is ignored on a non-object instance, so it constrains the object branch and leaves the null branch alone.",
+        disposition: {
+            kind: 'inject',
+            dialect: 'draft-2020-12',
+            keywords: { minProperties: 1 },
+        },
+    },
 ];
 export const constraintLedgerEntry = (id) => CONSTRAINT_LEDGER.find((entry) => entry.id === id);